基础之Collections与Arrays

水深无声 2023-06-01 12:50 7阅读 0赞

### Collections工具类： ###

#### 排序操作： ####

**void reverse(List list)**//反转  
**void shuffle(List list)**//随机排序  
**void sort(List list)**//按自然排序的升序排序  
**void sort(List list, Comparator c)**//定制排序，由Comparator控制排序逻辑  
**void swap(List list, int i , int j)**//交换两个索引位置的元素  
**void rotate(List list, int distance)**//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。

ArrayList<Integer> arrayList = new ArrayList<Integer>();
    arrayList.add(-1);
    arrayList.add(3);
    arrayList.add(3);
    arrayList.add(-5);
    arrayList.add(7);
    arrayList.add(4);
    arrayList.add(-9);
    arrayList.add(-7);
    System.out.println("原始数组:");
    System.out.println(arrayList);
    // void reverse(List list)：反转
    Collections.reverse(arrayList);
    System.out.println("Collections.reverse(arrayList):");
    System.out.println(arrayList);
    
    
    Collections.rotate(arrayList, 4);
    System.out.println("Collections.rotate(arrayList, 4):");
    System.out.println(arrayList);
    
    // void sort(List list),按自然排序的升序排序
    Collections.sort(arrayList);
    System.out.println("Collections.sort(arrayList):");
    System.out.println(arrayList);
    
    // void shuffle(List list),随机排序
    Collections.shuffle(arrayList);
    System.out.println("Collections.shuffle(arrayList):");
    System.out.println(arrayList);
    
    // void swap(List list, int i , int j),交换两个索引位置的元素
    Collections.swap(arrayList, 2, 5);
    System.out.println("Collections.swap(arrayList, 2, 5):");
    System.out.println(arrayList);
    
    // 定制排序的用法
    Collections.sort(arrayList, new Comparator<Integer>() {
    
      @Override
      public int compare(Integer o1, Integer o2) {
        return o2.compareTo(o1);
      }
    });
    System.out.println("定制排序后：");
    System.out.println(arrayList);

#### 查找，替换操作： ####

**int binarySearch(List list, Object key)**//对List进行二分查找，返回索引，注意List必须是有序的  
**int max(Collection coll)**//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)  
**int max(Collection coll, Comparator c)**//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int **min(Collection coll, Comparator c)**  
**void fill(List list, Object obj)**//用指定的元素代替指定list中的所有元素。  
**int frequency(Collection c, Object o)**//统计元素出现次数  
**int indexOfSubList(List list, List target)**//统计target在list中第一次出现的索引，找不到则返回-1，类比int **lastIndexOfSubList(List source, list target).**  
**boolean replaceAll(List list, Object oldVal, Object newVal)**//用新元素替换旧元素

ArrayList<Integer> arrayList = new ArrayList<Integer>();
    arrayList.add(-1);
    arrayList.add(3);
    arrayList.add(3);
    arrayList.add(-5);
    arrayList.add(7);
    arrayList.add(4);
    arrayList.add(-9);
    arrayList.add(-7);
    ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
    arrayList2.add(-3);
    arrayList2.add(-5);
    arrayList2.add(7);
    System.out.println("原始数组:");
    System.out.println(arrayList);
    
    System.out.println("Collections.max(arrayList):");
    System.out.println(Collections.max(arrayList));
    
    System.out.println("Collections.min(arrayList):");
    System.out.println(Collections.min(arrayList));
    
    System.out.println("Collections.replaceAll(arrayList, 3, -3):");
    Collections.replaceAll(arrayList, 3, -3);
    System.out.println(arrayList);
    
    System.out.println("Collections.frequency(arrayList, -3):");
    System.out.println(Collections.frequency(arrayList, -3));
    
    System.out.println("Collections.indexOfSubList(arrayList, arrayList2):");
    System.out.println(Collections.indexOfSubList(arrayList, arrayList2));
    
    System.out.println("Collections.binarySearch(arrayList, 7):");
    // 对List进行二分查找，返回索引，List必须是有序的
    Collections.sort(arrayList);
    System.out.println(Collections.binarySearch(arrayList, 7));

### Arrays工具类： ###

#### 排序 : **sort()** ####

// *************排序 sort****************
    int a[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
    // sort(int[] a)方法按照数字顺序排列指定的数组。
    Arrays.sort(a);
    System.out.println("Arrays.sort(a):");
    for (int i : a) {
      System.out.print(i);
    }
    // 换行
    System.out.println();
    
    // sort(int[] a,int fromIndex,int toIndex)按升序排列数组的指定范围
    int b[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
    Arrays.sort(b, 2, 6);
    System.out.println("Arrays.sort(b, 2, 6):");
    for (int i : b) {
      System.out.print(i);
    }
    // 换行
    System.out.println();
    
    int c[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
    // parallelSort(int[] a) 按照数字顺序排列指定的数组(并行的)。同sort方法一样也有按范围的排序
    Arrays.parallelSort(c);
    System.out.println("Arrays.parallelSort(c)：");
    for (int i : c) {
      System.out.print(i);
    }
    // 换行
    System.out.println();
    
    // parallelSort给字符数组排序，sort也可以
    char d[] = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
    Arrays.parallelSort(d);
    System.out.println("Arrays.parallelSort(d)：");
    for (char d2 : d) {
      System.out.print(d2);
    }
    // 换行
    System.out.println();
    
    //对字符串排序的情况
    String[] strs = { "abcdehg", "abcdefg", "abcdeag" };
    Arrays.sort(strs);
    System.out.println(Arrays.toString(strs));//[abcdeag, abcdefg, abcdehg]

#### 查找 : **binarySearch()** ####

// *************查找 binarySearch()****************
    char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
    // 排序后再进行二分查找，否则找不到
    Arrays.sort(e);
    System.out.println("Arrays.sort(e)" + Arrays.toString(e));
    System.out.println("Arrays.binarySearch(e, 'c')：");
    int s = Arrays.binarySearch(e, 'c');
    System.out.println("字符c在数组的位置：" + s);

#### 比较: **equals()** ####

// *************比较 equals****************
    char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
    char[] f = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
    /*
    * 元素数量相同，并且相同位置的元素相同。 另外，如果两个数组引用都是null，则它们被认为是相等的 。
    */
    // 输出true
    System.out.println("Arrays.equals(e, f):" + Arrays.equals(e, f));

#### 填充 : **fill()** ####

// *************填充fill(批量初始化)****************
    int[] g = { 1, 2, 3, 3, 3, 3, 6, 6, 6 };
    // 数组中所有元素重新分配值
    Arrays.fill(g, 3);
    System.out.println("Arrays.fill(g, 3)：");
    // 输出结果：333333333
    for (int i : g) {
      System.out.print(i);
    }
    // 换行
    System.out.println();
    
    int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
    // 数组中指定范围元素重新分配值
    Arrays.fill(h, 0, 2, 9);
    System.out.println("Arrays.fill(h, 0, 2, 9);：");
    // 输出结果：993333666
    for (int i : h) {
      System.out.print(i);
    }

#### 转列表: **asList()** ####

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

#### 转字符串 : **toString()** ####

// *************转字符串 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]

#### 复制: **copyOf()** ####

// *************复制 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
    for (int j : i) {
      System.out.print(j);
    }
    // 换行
    System.out.println();
    // copyOfRange将指定数组的指定范围复制到新数组中
    int j[] = Arrays.copyOfRange(h, 6, 11);
    System.out.println("Arrays.copyOfRange(h, 6, 11)：");
    // 输出结果66600(h数组只有9个元素这里是从索引6到索引11复制所以不足的就为0)
    for (int j2 : j) {
      System.out.print(j2);
    }
    // 换行
    System.out.println();

转载于:https://www.cnblogs.com/itzlg/p/11374850.html