Arrays数组工具类
常用方法介绍 （以下方法还有其他参数的重载方法，就不一一列出来了，这只是告诉大家方法的作用，其余重载的方法也相差无几）
static List<T> asList(T... o)
传入一个类型的参数，个数不限制，返回该参数类型的集合
List<Integer> list = Arrays.asList(1,2,3,5); //输出[1, 2, 3, 4, 5] System.out.println(list);static int compare(int[] a, int[] b)
比较数组a和数组b的总和，如果a的总和等于b的总和返回0，a的总和大于b的总和返回1，a的总和小于b的总和返回-1
int[] a = {1,2,3,4}; int[] b = {1,2,3,4}; //输出为0 System.out.println(Arrays.compare(a,b))static int[] copyOf(int[] original, int newLength)
赋值传入的这数组，另一个参数为要赋值数组的长度，从这个数组的第一个开始，如果超出了这数组的长度，则超出的值默认为0。
int[] arr = {56,4,6,4,89,0}; int[] ints = Arrays.copyOf(arr, 9); //输出[56, 4, 6, 4, 89, 0, 0, 0, 0] System.out.println(Arrays.toString(ints));static int[] copyOfRange(int[] arr, int from, int to)
赋值指定索引下数组，从from开始到to结束（不包括to）
int[] arr = {56,4,6,4,89,0}; int[] ints = Arrays.copyOfRange(arr,1,3); //输出[4, 6] System.out.println(Arrays.toString(ints));static boolean equalse(int[] arr, int[] arr1);
比较两个数组内容是否一致，一致就返回true，不一致就返回false。
int[] arr = {56,4,6,4,89,0}; int[] arr2 = {56,4,6,4,89,0}; //输出true System.out.println(Arrays.equals(arr,arr2));static int mismatch(int[] arr, int[] arr2);
比较两个数组，返回数组中第一个相同索引但是不同值得索引，如果数组一样则返回-1
int[] arr = {56,4,6,4,89,0}; int[] arr2 = {56,2,6,4,89,4}; //输出1 System.out.println( Arrays.mismatch(arr,arr2));static void sort(int[] arr)
按数字升序排序数组
int[] arr = {56,4,6,4,89,0}; Arrays.sort(arr); //[0, 4, 4, 6, 56, 89] System.out.println( Arrays.toString(arr));static String toString(int[] arr)
返回数组的字符串
int[] arr = {56,4,6,4,89,0}; //[56, 4, 6, 4, 89, 0] System.out.println( Arrays.toString(arr));
Objects工具类,一些类的基本操作工具类
static boolean equals(Object o, Object o1)
比较两个对象的地址值是否一致，一致返回true，否则返回false
我也想多写一点可发现这个类没有什么方法好说的了，哈哈哈Person p1 = new Person("老王",56); Person p2 = new Person("老刘",12); //输出false System.out.println(Objects.equals(p1,p2));
Collections集合工具类
static <T> boolean addAll(Collection<? super T> c, T... element)
添加多个参数到一个集合里面（set集合和list集合都可以），添加成功返回true，否则返回false
List<String> list = new ArrayList<>(); Collections.addAll(list, "a","b","c","d"); //[a, b, c, d] System.out.println(list);static void copy(List<? super T > dest, List<? super T> src)
复制一个list集合的元素到另一个集合
List<String> list = new ArrayList<>(); List<String> list1 = new ArrayList<>(); Collections.addAll(list, "a","b","c","d"); Collections.copy(list,list1); System.out.println(list1);static boolean disjoint(Collection<?> c, Collection<?> c1)
比较两个集合是否有相同元素，如果没有就返回true，否则返回false
List<String> list = new ArrayList<>(); List<String> list1 = new ArrayList<>(); Collections.addAll(list,"a","c","d"); Collections.addAll(list1,"a","w","e"); //输出false System.out.println(Collections.disjoint(list1,list));static <T> void fill(List<? super T> list, Object o)
使用指定元素替换list集合的使用元素
List<String> list = new ArrayList<>(); Collections.addAll(list,"a","c","d"); Collections.fill(list,"1"); //输出[1, 1, 1] System.out.println(list);static int frequency(Collection<?> c, Object o)
返回指定元素在集合中出现的次数
List<String> list = new ArrayList<>(); Collections.addAll(list,"a","c","d","c"); //输出1 System.out.println(Collections.frequency(list,"a"));
static <T extends Object & Comparable<? super T> > T max(Collection<? extends T> c)
根据自然排序返回集合的最大值
自然排序：就是java的整数类和浮点数类可以根据大小来排
List<Integer> list = new ArrayList<>(); Collections.addAll(list,5,6,2,9,45,12); Integer max = Collections.max(list); //输出45 System.out.println(max);
static <T> T max(Collection<? extends T> coll, Comparator<? super T> com)
根据自定义比较器来比较集合的自定义类型，自定义类型要实现Comparator集合
注：该类还有一个获取集合的最小值方法，用法和以上两个方法一样，就是方法名为min，在这里就不一一演示了
List<Person> list = new ArrayList<>(); Person p1 = new Person("老王",12); Person p2 = new Person("老刘",35); Person p3 = new Person("老李",4); list.add(p1); list.add(p2); list.add(p3); //匿名内部内实现Comparator接口自定义比较器 Person person = Collections.max(list, new Comparator<Person>() { @Override //该方法的参数为集合的泛型，拿自定义类型的两个可以比较的属性进行相减 //例： o1的年龄减去o2的年龄然后返回的就是该集合年龄最大的一个元素 // 如果o2 减去 o1 返回的就是该集合年龄最小的元素 public int compare(Person o1, Person o2) { return o1.getAge()-o2.getAge(); } }); //输出 Person{name='老李', age=4} System.out.println(person);//lambda实现Comparator接口自定义比较器 Person person = Collections.max(list,(o1, o2) -> o1.getAge()-o2.getAge() ); //输出 Person{name='老李', age=4} System.out.println(person);static <T> boolean replaceAll(List<T> list,T oldVal, T newVal);
使用指定元素替代，指定集合中出现的全部元素，有就返回true没有就返回false
List<String> list = new ArrayList<>(); Collections.addAll(list, "a", "c", "d","a"); boolean b = Collections.replaceAll(list,"a","t"); //true System.out.println(b); //[t, c, d, t] System.out.println(list);static void reverse(List<?> list)
反转集合元素
List<String> list = new ArrayList<>(); Collections.addAll(list, "a", "c", "d","5"); Collections.reverse(list); //[5, d, c, a] System.out.println(list);static void shuffle（List<?> list）
随机打乱list集合的顺序
List<String> list = new ArrayList<>(); Collections.addAll(list, "a", "c", "d","5"); Collections.shuffle(list); //[c, d, a, 5] System.out.println(list);static <T extends Comparable<? super T>> void sort(List<T> list)
根据元素按照顺序的方式排序 （ 针对可以比较元素，不可以比较元素要自定义比较器，）
List<Integer> list = new ArrayList<>(); Collections.addAll(list, 1,2,5,1,2,9,6,23,4,6); Collections.sort(list); //[1, 1, 2, 2, 4, 5, 6, 6, 9, 23] System.out.println(list);static <T> void sort(List<T> list, Comparator<? super T> c)
根据自定义比较器排序集合的元素
List<Person> list = new ArrayList<>(); list.add(new Person("老王",66)); list.add(new Person("老刘",44)); list.add(new Person("老李",69)); list.add(new Person("老黄",67)); list.add(new Person("老黑",63)); //匿名内部类实现比较器 Collections.sort(list, new Comparator<Person>() { @Override //按照年龄的升序排列，如果是o2.getAge() - o1.getAge()就是降序排列 public int compare(Person o1, Person o2) { return o1.getAge()-o2.getAge(); } }); //输出44,63,66,67,69, for (Person person : list) { System.out.print(person.getAge()+","); }static <T> void swap(List<T> list, int i, int j)
集合中指定索引上面的值交换位置
List<String> list = new ArrayList<>(); Collections.addAll(list, "aa","dd","tt","vv"); Collections.swap(list,0,2); //[tt, dd, aa, vv] System.out.println(list);
![单点登录-CAS[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)