当我们做文件的上传时，如果遇到同样的文件名，如果不做处理是会直接覆盖原文件的
所以应该先检测该文件名是否在文件夹里已经存在
先写一个方法，查找出该文件夹下所有文件名称

/**
	 * 
	 * @param path 需要遍历的路径
	 * @return 路径下文件的名称集合
	 */
	private static ArrayList<String> getFile(String path,int deep){   
        // 获得指定文件对象  
        File file = new File(path);   
        // 获得该文件夹内的所有文件   
        File[] array = file.listFiles();   
        ArrayList<String> list = new ArrayList<String>();
        int n = 0;
        for(int i=0;i<array.length;i++)
        {   
            if(array[i].isFile())//如果是文件
            {   
                    for (int j = 0; j < deep; j++)//输出前置空格
                    System.out.print(" ");
                // 只输出文件名字  
                    list.add(array[i].getName()); 
            }
        }  
        return list;
    } 





此时路径下有这一个文件
编写方法检查此文件是否存在，如果存在，在文件名后面加一个索引

/**
	 * 
	 * @param names 文件下文件名的集合
	 * @param name 存入的文件名
	 * @param index 索引的开始位置
	 * @return 符合要求的文件名
	 */
	private static String checkFileName(ArrayList<String> names,String name,int index) {
		if(names.contains(name.substring(0,name.indexOf("."))+index+name.substring(name.indexOf("."),name.length()))) {
			name = checkFileName(names,name,index+1);
		} else {
			return name.substring(0,name.indexOf("."))+index+name.substring(name.indexOf("."),name.length());
		}
		return name;
	}
        }




此时在main方法调用两个方法
                ArrayList<String> list = getFile("E:\\Test",0);
                //传入一个已经存在的文件名
		String filename = "test.txt";
		filename = checkFileName(list, filename, 0);
		System.out.println(filename);
执行结果


我在路径下新建一个文件（模拟上传上去的）


再次调用方法
结果

Question：一些网站对于密码具有一定规则。编写一个方法，检测字符串是否是一个有效密码。
Example：假定密码规则如下：
密码必须至少8位字符。
密码仅能包含字母和数字。
密码必须包含至少两个数字。
Answer：
（一）第一种方法视通过字符串的方法对给出的密码字符进行判断，得到结果

import java.util.Scanner;
public class PassWord {
	public static int NumberCount(String s){//计算字符串中的数字的个数
		int count = 0;
		for(int i = 0;i < s.length();i++){
			if(Character.isDigit(s.charAt(i)))
			count++;
		}
		return count;
	}
	public static boolean Test(String s){//字符串中是否仅含字母和数字
		boolean Password = false;
		for(int i = 0;i<s.length();i++){
			if(Character.isDigit(s.charAt(i))||Character.isLetter(s.charAt(i)))
				Password = true;
			else{
				Password = false;
				break;
			}
		}
		return Password;
	}
	public static void TestString(String s){检验是否符合规则
		if(NumberCount(s) >= 2 && s.length() >= 8 && Test(s))
			System.out.println("The password is valid");
		else 
			System.out.println("The password is invalid");
	}
	public static void main(String []args) {//测试程序
		Scanner input  = new Scanner(System.in);
		System.out.println("请输入密码：");
		String password = input.nextLine();
		PassWord string = new PassWord();
		string.TestString(password);
	}
	
}

题目描述：
 1、编写一个方法验证一个IP地址的格式是否正确，正确返回true，不正确返回false，该方法可定义如下
 public boolean isRightIP(String ip)
 其中，参数是要验证的IP字符串。（注：IP地址由4部分构成，即a.b.c.d，每个部分是0~255的整数）
 2、从键盘读入以字符，在main方法中调用isRightIP(String ip)以测试输入的字符串是否为合法的IP，给出结果。
 
分析：题目意思是要检测输入的IP地址是否合法和是否正确，合不合法的标准是：输入的只可以是数字或者“.”，若是有其他字符则是输入不合法。检测IP地址是否正确就是检测IP地址的每个部分是否是0~255。public boolean ceshi (String ip)方法是检测IP地址是否有不合法字符；public boolean chishi1(String ip)方法是检测IP地址的“.”是否超过了三个。
 代码如下：
 
package ch;
import java.util.Scanner;
class judge{ 
	public boolean isRightIP (String ip) {//检测IP地址是否正确
		String[] input=ip.split("\\.");
		int a=Integer.parseInt(input[0]);//IP地址的第一个部分
		int b=Integer.parseInt(input[1]);//IP地址的第二个部分
		int c=Integer.parseInt(input[2]);//IP地址的第三个部分
		int d=Integer.parseInt(input[3]);//IP地址的第四个部分
		if(a>=0 && a<=255 && b>=0 && b<=255&& c>=0 && c<=255&&d>=0 && d<=255  )
		{
		    System.out.println("true");
			return true;
		}
		else {
			System.out.println("false");
			return false;
		}
	}
    public boolean ceshi (String ip) {//检测IP地址是否合法
		int i=ip.length();
		int x=0;
		for(int j=0;j<i;j++) {
			if((ip.charAt(j)>47&&ip.charAt(j)<59)||ip.charAt(j)=='.'){
				x++;
			}
		}
		if(x==i)
		    return true;
		else
		    return false;	
	}
    public boolean chishi1(String ip)//检测IP地址是否合法
    {
    	int x=0;
    	int i=ip.length();
		for(int j=0;j<i;j++) {
			if(ip.charAt(j)==46)
				x++;
		}
		if(x==3)
			return true;
		else
			return false;
    }
}
public class IPText{
	public static void main(String [] args) {
		Scanner in=new Scanner (System.in);
		System.out.println("请循环输入IP地址：");
		while(in.hasNext())
		{
			
		    String IP=in.nextLine();
		    judge ip;
		    ip=new judge();
		    boolean m=ip.ceshi(IP);
		    boolean n=ip.chishi1(IP);
		    if(m==false||n==false)
		    {
			    System.out.println("输入有误！请重新输入：");
		    }
		    else
			ip.isRightIP(IP);
	    }
	}
}

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSession;

public class NetStateUtil {
    static HostnameVerifier hv = new HostnameVerifier() {  
        public boolean verify(String urlHostName, SSLSession session) {  
            return true;  
        }  
    };  
    public String connectingAddress(String remoteInetAddr){
        boolean flag=false;
        String tempUrl=remoteInetAddr.substring(0, 5);//取出地址前5位
        if(tempUrl.contains("http")){//判断传过来的地址中是否有http
            if(tempUrl.equals("https")){//判断服务器是否是https协议
                try {
                    trustAllHttpsCertificates();//当协议是https时
                } catch (Exception e) {
                    e.printStackTrace();
                }  
                HttpsURLConnection.setDefaultHostnameVerifier(hv);//当协议是https时
            }
            flag=isConnServerByHttp(remoteInetAddr);
        }else{//传过来的是IP地址
            flag=isReachable(remoteInetAddr);
        }
        if(flag){
            return "正常";
        }else{
            return "异常";
        }
    }
    /**
     * 传入需要连接的IP，返回是否连接成功
     *
     * @param remoteInetAddr
     * @return
     */
    public static boolean isReachable(String remoteInetAddr) {// IP地址是否可达，相当于Ping命令
        boolean reachable = false;
        try {
            InetAddress address = InetAddress.getByName(remoteInetAddr);
            reachable = address.isReachable(1500);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return reachable;
    }

    public static boolean isConnServerByHttp(String serverUrl) {// 服务器是否开启
        boolean connFlag = false;
        URL url;
        HttpURLConnection conn = null;
        try {
            url = new URL(serverUrl);
            conn = (HttpURLConnection) url.openConnection();
            conn.setConnectTimeout(3 * 1000);
            if (conn.getResponseCode() == 200) {// 如果连接成功则设置为true
                connFlag = true;
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            conn.disconnect();
        }
        return connFlag;
    }
    /*以下是Https适用*/
    private static void trustAllHttpsCertificates() throws Exception {  
        javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1];  
        javax.net.ssl.TrustManager tm = new miTM();  
        trustAllCerts[0] = tm;  
        javax.net.ssl.SSLContext sc = javax.net.ssl.SSLContext  
                .getInstance("SSL");  
        sc.init(null, trustAllCerts, null);  
        javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc  
                .getSocketFactory());  
    }  
 
    static class miTM implements javax.net.ssl.TrustManager,  
            javax.net.ssl.X509TrustManager {  
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {  
            return null;  
        }  
 
        public boolean isServerTrusted(  
                java.security.cert.X509Certificate[] certs) {  
            return true;  
        }  
 
        public boolean isClientTrusted(  
                java.security.cert.X509Certificate[] certs) {  
            return true;  
        }  
 
        public void checkServerTrusted(  
                java.security.cert.X509Certificate[] certs, String authType)  
                throws java.security.cert.CertificateException {  
            return;  
        }  
 
        public void checkClientTrusted(  
                java.security.cert.X509Certificate[] certs, String authType)  
                throws java.security.cert.CertificateException {  
            return;  
        }  
    }  
    /*以上是Https适用*/
}
 
测试的时候只需要将IP地址或web服务器的地址传过去就可以进行检测，检测返回的结果是“正常”或“异常”：
 
       NetStateUtil netStateUtil=new NetStateUtil();
        String url1="https://1.1.1.1:2017";//测试https
        String url2="http://1.1.1.1:2017";//测试http
        String url3="1.1.1.1";//测试普通ip
        System.out.println(url1+":"+netStateUtil.connectingAddress(url1));
        System.out.println(url2+":"+netStateUtil.connectingAddress(url2));
        System.out.println(url3+":"+netStateUtil.connectingAddress(url3));
 
说明一下，上面的几个url的字符串中的ip我已经更改过了，大家拿去后更改成自己想测试的ip即可
  
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
转：https://blog.csdn.net/chenshunyuan6/article/details/78623406