java.util Collections 和Arrays 工具类的常用方法介绍以及使用

Colletions

Java 集合的工具类

Collections 工具类的常用方法：

• 1.排序
• 2.查找和替换

排序

• 1.void reverse(List list) 反转集合
• 2.void shuffle (List list) 随机排序
• 3.void sort(List list) 按照自然顺序的升序进行排序
• 4.void sort(List list,Comparator c) 按照自定义规则进行排序
• 5.void swap(List list,int i,int j) 交换索引i和j的元素
• 6.void rotate (List list,int distance) 旋转。当distance为正数的时候，将list集合后distance个元素移到前面；当distance为负数的时候，将 list的前distance个元素整体移到后面。

代码：

 public static void collection_sor() {
        List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(30);
        list.add(10);
        list.add(6);
        list.add(89);
        list.add(-10);
        //1.void reverse(List list) 反转集合
        System.out.println("反转集合前：" + list);
        Collections.reverse(list);
        System.out.println("反转集合后：" + list);
        //2.void shuffle (List list) 随机排序
        System.out.println("随机排序前：" + list);
        Collections.shuffle(list);
        System.out.println("随机排序后：" + list);
        //3.void sort(List list) 按照自然顺序的升序排序
        System.out.println("按照自然顺序升序排序前："+ list);
        Collections.sort(list);
        System.out.println("按照自然顺序升序排序后："+ list);
        //4.void sort(List list,Comparator c)  按照Comparator 的逻辑进行排序
        System.out.println("自定义排序前（降序）：" + list);
        Collections.sort(list,(Integer o1,Integer o2)->o2-o1);
        System.out.println("自定义排序后（降序）：" + list);
        //5.void swap(List list,int i,int j) 交换索引 i  j  元素的位置
        System.out.println("交换前（0 和 4交换）：" + list);
        Collections.swap(list,0,4);
        System.out.println("交换后（0 和 4交换）：" + list);
        //6.void rotate (List list,int distance)旋转。当distance为正数时，将List后distance个元素移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。
        System.out.println("旋转前:"+list);
        Collections.rotate(list,3);
        System.out.println("旋转后:"+list);
		
    }

输出结果：

反转集合前：[20, 30, 10, 6, 89, -10]
反转集合后：[-10, 89, 6, 10, 30, 20]
随机排序前：[-10, 89, 6, 10, 30, 20]
随机排序后：[6, 89, 10, -10, 20, 30]
按照自然顺序升序排序前：[6, 89, 10, -10, 20, 30]
按照自然顺序升序排序后：[-10, 6, 10, 20, 30, 89]
自定义排序前（降序）：[-10, 6, 10, 20, 30, 89]
自定义排序后（降序）：[89, 30, 20, 10, 6, -10]
交换前（0 和 4交换）：[89, 30, 20, 10, 6, -10]
交换后（0 和 4交换）：[6, 30, 20, 10, 89, -10]
旋转前:[6, 30, 20, 10, 89, -10]
旋转后:[10, 89, -10, 6, 30, 20]

查找和替换

• 1.int binarySearch(List list,Object key) 对List进行二分查找，返回索引。list必须是有序的
• 2.int max(Collection coll) 根据元素的自然顺序，返回最大的元素。
• 3.int max(Collection coll,Comparator c) 根据自定义排序，返回最大的元素。
• 4.int min(Collection coll) 根据元素的自然顺序，返回最小的元素。
• 5.int min(Collection coll,Comparator c) 根据自定义排序，返回最小的元素。
• 6.void fill(List list,Object key) 用指定元素，代替list中所有的元素
• 7.int frequency(Collection c ,Object o) 统计元素出现的次数
• 8.int indexOfSubList(List list,List target) 统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).
• 9.int lastIndexOfSubList(List list,List target) 统计target在list中最后一次出现的索引，找不到则返回-1
• 10.boolean replaceAll(List list, Object oldVal, Object newVal) 用新元素替换旧元素

代码演示：

 public static void findAndReplace(){
        ArrayList <Integer> list1 = new ArrayList<>();
        list1.add(20);
        list1.add(30);
        list1.add(20);
        list1.add(6);
        list1.add(89);
        list1.add(-10);


        ArrayList <Integer> list2 = new ArrayList<>();
        list2.add(6);
        list2.add(89);

        System.out.println("原始集合 list1： "+ list1);
        System.out.println("原始集合 list2： "+ list2);

        System.out.println("Collections.max(list1):   " + Collections.max(list1));

        System.out.println("Collections.max(list1,c)    " + Collections.max(list1,(o1,o2)->o2-o1));

        System.out.println("Collections.min(coll)  "+ Collections.min(list1));

        System.out.println("Collections.min(coll，c)  "+ Collections.min(list1,(o1,o2)->o2-o1));

        System.out.println("统计20出现的次数：  "+ Collections.frequency(list1,20));

        System.out.println("Collections.indexOfSubList(list1,list2)   "  + Collections.indexOfSubList(list1,list2));

        System.out.println("Collections.lastIndexOfSubList(list1,list2)   "  + Collections.lastIndexOfSubList(list1,list2));

        //int binarySearch(List list,Object key)
        Collections.sort(list1);
        System.out.println("元素 20 在list1 中的索引位置为："+ Collections.binarySearch(list1,20));


        System.out.println("将list2中元素全部替换成 0   " );
        Collections.fill(list2,0);
        System.out.println("替换后的list2" + list2);

        //将list1中的20替换成-20
        System.out.println("Collections .replaceAll()" + Collections.replaceAll(list1,20,-20));
        System.out.println("替换后的list1" + list1);
    }
    
输出结果：


原始集合 list1： [20, 30, 20, 6, 89, -10]
原始集合 list2： [6, 89]
Collections.max(list1):   89
Collections.max(list1,c)    -10
Collections.min(coll)  -10
Collections.min(coll，c)  89
统计20出现的次数：  2
Collections.indexOfSubList(list1,list2)   3
Collections.lastIndexOfSubList(list1,list2)   3
元素 20 在list1 中的索引位置为：2
将list2中元素全部替换成 0   
替换后的list2[0, 0]
Collections .replaceAll()true
替换后的list1[-10, 6, -20, -20, 30, 89]

Arrays

Java数组的工具类

Arrays 工具类的常用方法：

• 排序 : sort()
• 查找 : binarySearch()
• 比较: equals()
• 填充 : fill()
• 转列表: asList()
• 转字符串 : toString()
• 复制: copyOf()

排序

Arrays 排序算法使用的是 Quickly_Sort

 // *******************排序***********************
        int[] arr = new int[10];
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            arr[i] = random.nextInt(100);
        }
        System.out.println("原始数组为：");
        print(arr);

        // Arrays.sort(int []arr)  按照自然顺序的升序进行排序
        Arrays.sort(arr);
        System.out.println("Arrays.sort(arr)");
        print(arr);

        // Arrays.sort(int []arr , int fromIndex,int toIndex)  按照升序排序 从fromIndex --- toIndex-1的那一部分数据
        int [] arr2 = {20,10,309,-129,23};
        System.out.println("原始数组");
        print(arr2);
        Arrays.sort(arr2,2,arr2.length);
        System.out.println("Arrays.sort(arr2,2,arr2.length);");
        print(arr2);

        int arr3[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
        System.out.println("原始数组");
        print(arr3);
        // parallelSort(int[] a) 按照数字顺序排列指定的数组(并行的)。同sort方法一样也有按范围的排序
        Arrays.parallelSort(arr3);
        System.out.println("Arrays.parallelSort(arr3)");
        print(arr3);

	输出结果：


	原始数组为：
	36  13  57  59  67  52  55  92  18  83  
	Arrays.sort(arr)
	13  18  36  52  55  57  59  67  83  92  
	原始数组
	20  10  309  -129  23  
	Arrays.sort(arr2,2,arr2.length);
	20  10  -129  23  309  
	原始数组
	1  3  2  7  6  5  4  9  
	Arrays.parallelSort(arr3)
	1  2  3  4  5  6  7  9 

查找

  //***************查找 binarySearch()******************
        int[]  arr4 = { 10,20,0,-29,34 };
        System.out.println("原始数组");
        // 排序后再进行二分查找，否则找不到
        Arrays.sort(arr4);
        System.out.println("Arrays.binarySearch(arr4,20)");
        int s = Arrays.binarySearch(arr4, 20);
        System.out.println("20在数组的位置：" + s);


输出结果：


原始数组
Arrays.binarySearch(arr4,20)
20在数组的位置：3

比较

        //***************比较 equals()*********************
         int[]  arr4 = { 10,20,0,-29,34 };
        int[] arr5 = {10,20,0,-29,34};
        /*
         * 元素数量相同，并且相同位置的元素相同。 另外，如果两个数组引用都是null，则它们被认为是相等的 。
         */
        // 输出true
        System.out.println("Arrays.equals(arr4, arr5):" + Arrays.equals(arr4, arr5));


输出结果：


Arrays.equals(arr4, arr5):true

填充

// *************填充fill(批量初始化)****************
        int[] arr6 = { 1, 2, 3, 3, 3, 3, 6, 6, 6 };
        System.out.println("原始数组");
        print(arr6);
        // 数组中所有元素重新分配值
        Arrays.fill(arr6, 3);
        System.out.println("Arrays.fill(arr6, 3)：");
        // 输出结果：333333333
        print(arr6);

        int[] arr7 = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
        System.out.println("原始数组");
        print(arr7);
        // 数组中指定范围元素重新分配值
        Arrays.fill(arr7, 0, 2, 9);
        System.out.println("Arrays.fill(arr7, 0, 2, 9);：");
        // 输出结果：993333666
        print(arr7);

输出结果：


原始数组
1  2  3  3  3  3  6  6  6  
Arrays.fill(arr6, 3)：
3  3  3  3  3  3  3  3  3  
原始数组
1  2  3  3  3  3  6  6  6  
Arrays.fill(arr7, 0, 2, 9);：
9  9  3  3  3  3  6  6  6  

转列表

 // *************转列表 asList()****************
        /*
         * 返回由指定数组支持的固定大小的列表。
         * （将返回的列表更改为“写入数组”。）该方法作为基于数组和基于集合的API之间的桥梁，与Collection.toArray()相结合 。
         * 返回的列表是可序列化的，并实现RandomAccess 。
         * 此方法还提供了一种方便的方式来创建一个初始化为包含几个元素的固定大小的列表如下：
         */
        List<String> stooges = Arrays.asList("Hello", "World", "Say Hi");
        System.out.println(stooges);

输出结果：


[Hello, World, Say Hi]

转字符串

 // *************转字符串 toString()****************
        /*
         * 返回指定数组的内容的字符串表示形式。
         */
        char[] k = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
        System.out.println(Arrays.toString(k));// [a, f, b, c, e, A, C, B]


输出结果：


[a, f, b, c, e, A, C, B]

复制

   // *************复制 copy****************
        // copyOf 方法实现数组复制,h为数组，6为复制的长度
        int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
        int i[] = Arrays.copyOf(h, 6);
        System.out.println("Arrays.copyOf(h, 6);：");
        // 输出结果：123333
        print(i);

        // copyOfRange将指定数组的指定范围复制到新数组中
        int j[] = Arrays.copyOfRange(h, 6, 11);
        System.out.println("Arrays.copyOfRange(h, 6, 11)：");
        // 输出结果66600(h数组只有9个元素这里是从索引6到索引11复制所以不足的就为0)
      print(j);


输出结果：

Arrays.copyOf(h, 6);：
1  2  3  3  3  3  
Arrays.copyOfRange(h, 6, 11)：
6  6  6  0  0  

不怕学得少，就怕不学习