Arrays工具类，正则表达式

1.Arrays工具类
1.Arrays工具类概述：

//Arrays里面的方法全部都是静态的
public class Test {
    public static void main(String[] args) {
//        数组的工具类
//        数组的遍历
        int[] arr={2,323,13,1,51,1,5,15,15,33};
//        将数组直接打印成字符串,该功能返回的是String类型
        System.out.println(Arrays.toString(arr));
    }
}

2.Arrays工具类方法

//将数组进行排序
public class Test1 {
    public static void main(String[] args) {
        int[] arr={2,214,234,412,42,1,125,215,1,52};
//        通过Arrays.sort方法对数组进行排序
//        Arrays.sort(arr);//默认升序排列
//        System.out.println(Arrays.toString(arr));
//        Arrays.sort(arr,1,5);//指定一段范围进行排序(也是含头不含尾)
//        System.out.println(Arrays.toString(arr));
        Integer[] a={321,421,32,4125,5235,23};//对包装类进行排序
        Arrays.sort(a, new Comparator<Integer>() {
            @Override
            public int compare(Integer b, Integer c) {
                return b-c;//匿名内部类,b-c>0,升序排,b-c<0,降序排
            }
        });
        System.out.println(Arrays.toString(a));


    }
}

3.Arrays工具类得查找方法

//二分查找(前提是数组要有序)
public class Test2 {
    public static void main(String[] args) {
  int a[]={32,4124,1,1212,1000,1,512,51,512,51,512,421,421,2,21,12,412,412,21,};
        Arrays.sort(a);//对数组进行排序了,升序
        System.out.println(Arrays.toString(a));
//        对数组进行查找元素索引的方法:
        int index =Arrays.binarySearch(a,21);//对于有重复元素的,查找的为元素第一次出现的索引,二分法进行的查找
        System.out.println(index);
    }
}

4.Arrays得equals方法

//比较两个数组元素是否一样
public class Test3 {
    public static void main(String[] args) {
   int[] arr1={312,2,2,131,13,334,3,41412,4,51,154,111};
        int[] arr2={312,2,2,111,131,13,334,3,41412,4,51,154};
        boolean a= Arrays.equals(arr1,arr2);//要求元素位置和元素大小一一对应,完全一样才可以,这里面就111,的位置不一样
        System.out.println(a);
    }
}

5.复制数组功能

//复制数组
public class Test4 {
    public static void main(String[] args) {
        int[] arr={321,31,3,13,14,4,2,412,421,};
        int[] ints = Arrays.copyOf(arr, 3);//复制这几个元素(3个元素),数字代表其长度,返回一个数组
        System.out.println(Arrays.toString(ints));
        int[] ints1 = Arrays.copyOf(arr, arr.length);//全部复制
        System.out.println(Arrays.toString(ints1));
//        copyOfRange(int[] original, int from, int to)
//          将指定数组的指定范围复制到一个新数组。
        int[] ints2 = Arrays.copyOfRange(arr, 2, 5);//含头不含尾,所以一共三个元素,2是起始索引,5是终止索引
        System.out.println(Arrays.toString(ints2));

    }
}

2.正则表达式
1.正则表达式得写法

package 正则表达式.正则表达式的写法;
//从这个类开始，这里面的字符最好把它当作正则表达式去看待
//且正则表达式都是字符串类型的
//都是单个匹配的
public class Test {
    public static void main(String[] args) {
//        定义正则表达式
        String regx="a";
        boolean a = "aaa".matches("a");//匹配列表中任意一个字符，就是括号里面的
       regx="[a,b,c,d,e]";

       "aaa".matches(regx);//"aaa"和regx中的任意一个字符进行匹配，如果匹配上了，返回true，注意是匹配，不是判断是否相等
        boolean matches = "a".matches(regx);
        System.out.println(matches);//true
      regx="[a-z]";//就代表a-z 26个字母,A-Z,0-9也是这样
        boolean matches1 = "f".matches(regx);
        System.out.println(matches1);//true
        regx="[A-Z]";
        regx="[0-9]";
        regx="[a-zA-Z0-9]";//包含了a-z，A-Z，0-9所有的字符
        regx="[^a-z]";//表示取反，只要不是a-z就行
        System.out.println("9".matches(regx));//ture，因为9不在a-z的里面，如果把9换成a-z任意一个，就不行了，因为为取反，为false
        regx = ".";//表示通配符，代表任意一个字符，注意是任意一个，不能是多个，任意字符都可以，JAVA认定符号都可以
        regx="..";//代表任意两个字符
        System.out.println("!b".matches(regx));
//        这个点本意代表的是任意字符，但是我匹配的时候我就是想看看一个字符是不是和点进行匹配，就需要对.这个字符进行转义（\\）就
//        可以了
//        如果只是想匹配点（.）本身，就只是想匹配点，那样要带转义字符，\\.就可以了，代表的是将点转义了，就是只是看看点是不是和
//        点进行匹配，为什么是两个\\，先记住，后面在回看吧
        regx="\\.";
        System.out.println(".".matches(regx));
        regx="|";//本意是或者的意思，但是我就是想比较"|"这个单纯的这个字符是否和"|"匹配，就要进行转义，转义先记着是"\\"两个
//           比如：
        regx="a|b";//表示的是a或b
        regx="\\|";//就进行了转义，表示成了只是一个“|”字符了
        regx ="\\w";//代表[a-zA-Z_0-9]，转义字符就为\\w，这个表示取任何单个字母都可以,下划线也带着记住
        System.out.println("dasda");
        regx="\\W";//大写的W就表示\\w的取反，就是不能取那些
        System.out.println("a".matches(regx));
        System.out.print("\t");//除了换行符，tab这么写，别的就按照//的格式来
        System.out.println("1111111");
        regx="\\d";//跟0-9的意思一样
        System.out.println("6".matches(regx));//true
        regx="\\D";//表示不能取数字，大写的好像都是像取反的，取反是^
        System.out.println(" ".matches(regx));
        regx="\\s";//匹配空格字符
        System.out.println("a".matches("^\\w"));//这种的都是认双不认单，写成单个\的就报错，写成双的才行
        System.out.println("\\\\\\n");//\t \n 还有跟换行啥的都关的都是可单可爽，但是写成单的就会行使他的功能，
//        多了的话（\是奇数的情况下），会执行该功能，即\n看成一个（会行使功能换行），完事剩下的\除以二就行，
//        类似\n要是双的情况下，就直接显示（偶数的\）除以2加个n
//        还有一个，下划线也认单不认双，这个单双是刨去了自己的那个下划线，记住
//       反正记住，只有换行的那几个是单斜杠的，其余的转义的都是双斜杠的，记住吧，如果只想让特殊功能的字符变成普通的字符，加
//        两个\\，如果想让普通的字符变成特殊功能的字符，加两个\\，记住这个就行了
    }
}

2.数量正则表达式得写法

//数量正则表达式的写法
public class Test1 {
    public static void main(String[] args) {
// ?表示一次或一次也没有，比如""空串，就是没有，空串也代表一次也没有，空串就代表没出现过，无论哪个字母，只要没出现就是true被
//        所以空串就可以代表任意一个字母一次也没出现过
        String regx="ab?";//表示运行a或b出现一次或者不出现，多了就是false
        System.out.println("a".matches(regx));//true
        System.out.println(("ab".matches(regx)));//true
        System.out.println("abb".matches(regx));//false
        regx="\\w?";//这样写的话就表示成了，字母出现一次或者没出现都算true,这里要记得只能选一个字符与其匹配，因为这两个
//        正则表达式的规则就是选一个字符
        regx="[a-z]?";//只能选一个字符与其匹配
        System.out.println("aa".matches(regx));//false
        System.out.println("ab".matches(regx));//false
        System.out.println("".matches(regx));//表示任意一个字母一次也没出现过,true
//
//        ===========================================================
//        * 零次或多次，大于等于1次，都算多次
        regx="[a-z]*";//表示小写字母可以出现0次和多次，有别的字符不行
        System.out.println("dsadasasfafafasfsaf".matches(regx));//只有小写字母为true
//        这贼奇怪，记住吧，写成[a-zA-Z_0-9]或\\w或\\d中，*和+可以匹配任种且任意个字符，?只能匹配一个
//        +表示一次或多次，最少为一次
             regx="b+c+";//表示只能b或c最少写一次，别的不能写，写了就为false
        System.out.println("bccbcbcbcbcb".matches(regx));//true
        regx="\\w+";
        System.out.println("dfsafDJDHFA_44141r32524522341".matches(regx));
        regx="a{3}";//表示a出现的次数只能是三次
        System.out.println("aaa".matches(regx));//true
//        加入要数组字母下划线，只能写6位密码，可以这样写
        regx="\\w{6}";
        System.out.println("a12345".matches(regx));
        regx="\\w{6,}";//这个叫做至少6次，注意看里面的逗号
        System.out.println("asfasfsafasgasga".matches(regx));//true,至少，只要，最多的时候都是不限制使用次数的，一个字母可以写
//        多次

          regx="\\w{6,12}";//表示小于等于12次，大于等于6次
        System.out.println("dadfdsgv".matches(regx));

         regx="[1-9][0-9]{4,14}";//这个正则表达式的意思是第一位只能以1到9取一个数，第二位开始可以取0到9的数，然后最少取4位
//        最多取14位，从第二位开始时最少取4，最多取14，规定取次数的的这个要紧挨着取值范围的
//================================================================================================
//        现在试试手机的那个例子：
//        以1开头，手机号码为11位，每一位都是数字，手机号码第二位3-9
        String num="[1][3-9][0-9]{9}";//从第三位开始只能写9次数字
        System.out.println("1315218a232".matches(num));//false
    }

}

3.正则表达是规则：

public class Test {
    public static void main(String[] args) {
//        正则表达式：正确规则的表达式，是一种语法，作用：定义一些规则，用来对对应数据进行规则的校验
//        很多语言都支持正则表达式
//        正则表达式是一个独立的语法，主要用来判断字符的格式什么的是不是正确。
//        案例，查看邮箱名是否正确：
//        6-18个字符，可以用字母，数字，下划线，需要以字母开头：(下面写得是我按照QQ邮箱得格式写的)
        String num="\\w[a-zA-Z0-9_@#\\.]{5,17}";//这里的点要转义一下，否则就是通用字符了
        System.out.println("Guotao123@qq.com".matches(num));
        System.out.println("1044143167@qq.com".matches(num));
        System.out.println("\\");
        System.out.println("\\.");//这也是代表成了一个普通得符号
        System.out.println("\\^");//这样就表示的是单纯的一个^符号，没有任何功能的，^在正则表达式里面是代表非得意思
          String num1="[A-Za-z]\\w{0,11}@qq\\.com";//后面那一块@qq.com要是想写死就写成这样得，也就是说只能写成@qq.com，
//        写成别得就是是错
        System.out.println("F044143167@qq.com".matches(num1));//要想只是使用该字符，不用其特定功能得一定要转义
      String mmm="[a-zA-Z]{1}";
        System.out.println("a".matches(mmm));
//        判断中文得正则表达式：
        String chinese="[u4e00-u9fa5]";//所有得汉字都是从里面取得，记住这个就行，最后记
    }
}

4.关于正则表达式的练习：

import java.util.Scanner;

//练习：定义一个手机号的规则，要求：
//以“1”开头
//手机号长度就是11
//手机号第二位要是 3456789
public class Test2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的手机号码");
        String s = scanner.nextLine();
        boolean b = Judgment(s);
        if (b){
            System.out.println("您的手机号码格式正确");
        }else {
            System.out.println("您的手机号码格式不正确");
        }

    }
//用普通方法去做的：
    private static boolean Judgment(String s) {
        boolean judge=false;
        if (s.startsWith("1")&&s.length()==11&&!(s.charAt(1)==0||s.charAt(1)==1||s.charAt(1)==2)){
            for (int i = 1; i < s.length(); i++) {
               // if (s.charAt(i)>='0'&&s.charAt(i)<='9')//这里可以用这个，当然也可以用新学的，效率还高点
                if (Character.isDigit(s.charAt(i)))//用这个新学的方法就可以
                    judge=true;
//                else {
//                    judge= false;
//                    break;
//                }
            }
        }
        return judge;
    }
}