Collections 工具类和 Arrays 工具类常见方法

深藏阁楼爱情的钟 2023-07-24 09:08 15阅读 0赞

*  Collections 工具类和 Arrays 工具类常见方法
    
     *  Collections
        
         *  排序操作
         *  查找,替换操作
         *  同步控制
     *  Arrays类的常见操作
        
         *  排序 : `sort()`
         *  查找 : `binarySearch()`
         *  比较: `equals()`
         *  填充 : `fill()`
         *  转列表 `asList()`
         *  转字符串 `toString()`
         *  复制 `copyOf()`

# Collections 工具类和 Arrays 工具类常见方法 #

## Collections ##

Collections 工具类常用方法:

1.  排序
2.  查找,替换操作
3.  同步控制(不推荐，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合)

### 排序操作 ###

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), 用新元素替换旧元素

**示例代码：**

### 同步控制 ###

Collections提供了多个`synchronizedXxx()`方法·，该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。

我们知道 HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap 都是线程不安全的。Collections提供了多个静态方法可以把他们包装成线程同步的集合。

**最好不要用下面这些方法，效率非常低，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合。**

方法如下：

synchronizedCollection(Collection<T>  c) //返回指定 collection 支持的同步（线程安全的）collection。
    synchronizedList(List<T> list)//返回指定列表支持的同步（线程安全的）List。
    synchronizedMap(Map<K,V> m) //返回由指定映射支持的同步（线程安全的）Map。
    synchronizedSet(Set<T> s) //返回指定 set 支持的同步（线程安全的）set。

### Collections还可以设置不可变集合，提供了如下三类方法： ###

emptyXxx(): 返回一个空的、不可变的集合对象，此处的集合既可以是List，也可以是Set，还可以是Map。
    singletonXxx(): 返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，此处的集合可以是：List，Set，Map。
    unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。
    上面三类方法的参数是原有的集合对象，返回值是该集合的”只读“版本。

**示例代码：**

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);
            HashSet<Integer> integers1 = new HashSet<>();
            integers1.add(1);
            integers1.add(3);
            integers1.add(2);
            Map scores = new HashMap();
            scores.put("语文" , 80);
            scores.put("Java" , 82);
    
            //Collections.emptyXXX();创建一个空的、不可改变的XXX对象
            List<Object> list = Collections.emptyList();
            System.out.println(list);//[]
            Set<Object> objects = Collections.emptySet();
            System.out.println(objects);//[]
            Map<Object, Object> objectObjectMap = Collections.emptyMap();
            System.out.println(objectObjectMap);//{}
    
            //Collections.singletonXXX();
            List<ArrayList<Integer>> arrayLists = Collections.singletonList(arrayList);
            System.out.println(arrayLists);//[[-1, 3, 3, -5, 7, 4, -9, -7]]
            //创建一个只有一个元素，且不可改变的Set对象
            Set<ArrayList<Integer>> singleton = Collections.singleton(arrayList);
            System.out.println(singleton);//[[-1, 3, 3, -5, 7, 4, -9, -7]]
            Map<String, String> nihao = Collections.singletonMap("1", "nihao");
            System.out.println(nihao);//{1=nihao}
    
            //unmodifiableXXX();创建普通XXX对象对应的不可变版本
            List<Integer> integers = Collections.unmodifiableList(arrayList);
            System.out.println(integers);//[-1, 3, 3, -5, 7, 4, -9, -7]
            Set<Integer> integers2 = Collections.unmodifiableSet(integers1);
            System.out.println(integers2);//[1, 2, 3]
            Map<Object, Object> objectObjectMap2 = Collections.unmodifiableMap(scores);
            System.out.println(objectObjectMap2);//{Java=82, 语文=80}
    
            //添加出现异常：java.lang.UnsupportedOperationException
    // list.add(1);
    // arrayLists.add(arrayList);
    // integers.add(1);

## Arrays类的常见操作 ##

1.  排序 : `sort()`
2.  查找 : `binarySearch()`
3.  比较: `equals()`
4.  填充 : `fill()`
5.  转列表: `asList()`
6.  转字符串 : `toString()`
7.  复制: `copyOf()`

### 排序 : `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();

在做算法面试题的时候，我们还可能会经常遇到对字符串排序的情况,`Arrays.sort()` 对每个字符串的特定位置进行比较，然后按照升序排序。

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();