最详细的Collections类和Arrays类常见方法复习

最新推荐文章于 2022-07-29 23:36:58 发布

weixin_34357962

最新推荐文章于 2022-07-29 23:36:58 发布

阅读量158

点赞数

文章标签：数据结构与算法

原文链接：https://segmentfault.com/a/1190000014203555

版权

1. Collections类的常见操作：

1.1. 排序操作：

集合类库使用的是归并排序比快速排序要慢一些，快速排序是通用排序算法的传统选择。但是，归并排序有一个主要的优点就是稳定。

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

        // 定制排序的用法
        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);

1.2. 查找，替换操作：

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)//统计targe在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));

1.3. 同步控制：

Collectons提供了多个synchronizedXxx()方法·，该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。
我们知道HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap都是线程不安全的。Collections提供了多个静态方法可以把他们包装成线程同步的集合。
方法如下：

synchronizedCollection(Collection<T>  c) //返回指定 collection 支持的同步（线程安全的）collection。


synchronizedList(List<T> list)//返回指定列表支持的同步（线程安全的）List。

synchronizedMap(Map<K,V> m) //返回由指定映射支持的同步（线程安全的）Map。

synchronizedSet(Set<T> s) //返回指定 set 支持的同步（线程安全的）set。

1.4. 设置不可变集合：

emptyXxx(): 返回一个空的、不可变的集合对象，此处的集合既可以是：List，Set，Map.如emptyList（）：返回空列表（immutable），此列表是可序列化的。

singletonXxx(): 返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，此处的集合可以是：List，Set，Map。如：singletonList(T o)：返回一个只包含指定对象的不可变列表。，返回的列表是可序列化的。

unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。如：unmodifiableList(List<? extends T> list)：返回指定列表的不可修改视图。

上面三类方法的参数是原有的集合对象，返回值是该集合的"只读"版本。

1. Arrays类的常见操作：

排序 :sort()
查找 :binarySearch()
比较: equals
填充 :fill
转列表: asList()
哈希:hashCode()
转字符串 :toString()

示例代码：

/**
 * TODO Arrays类方法测试
 * 包含用于操作数组的各种方法（如排序和搜索）。 该类还包含一个静态工厂，可以将数组视为列表。 
 * 如果指定的数组引用为空，则该类中的方法都抛出一个NullPointerException ，除非另有说明。 
 * @author 寇爽
 * @date 2017年11月20日
 * @version 1.8
 */
public class ArraysMethodsDemo {
    public static void main(String[] args) {
        // *************排序 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();

        // *************查找 binarySearch()****************
        char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
        System.out.println("Arrays.binarySearch(e, 'c')：");
        int s = Arrays.binarySearch(e, 'c');
        System.out.println("字符c在数组的位置：" + s);

        // *************比较 equals****************
        char[] f = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
        /*
         * 元素数量相同，并且相同位置的元素相同。 另外，如果两个数组引用都是null，则它们被认为是相等的 。
         */
        // 输出true
        System.out.println("Arrays.equals(e, f):" + Arrays.equals(e, f));
        // 输出false，因为数组d已经被排过序，所以数组d和e虽然由相同元素构成，但是相同位置的元素不同
        System.out.println("Arrays.equals(d, e):" + Arrays.equals(d, e));

        // *************填充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);
        }
        // 换行
        System.out.println();

        // *************复制copy****************
        // copyOf方法实现数组复制,h为数组，6为复制的长度
        int i[] = Arrays.copyOf(h, 6);
        System.out.println("Arrays.copyOf(h, 6);：");
        // 输出结果：993333
        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();

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

        // *************哈希 Hash()****************
        char[] k = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
        // 输出数组k的hash值
        System.out.println(Arrays.hashCode(k));

        // *************转字符串 toString()****************
        /*
         * 返回指定数组的内容的字符串表示形式。 字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。
         * 相邻的元素由字符", "分隔（逗号后跟一个空格）。 元素被转换为字符串由String.valueOf(int)。
         * 返回"null"如果a是null。
         */
        // 输出结果：[a, f, b, c, e, A, C, B]
        System.out.println(Arrays.toString(k));

    }
}

weixin_34357962

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
最详细的Collections类和Arrays类常见方法复习

1. Collections类的常见操作：1.1. 排序操作：集合类库使用的是归并排序比快速排序要慢一些，快速排序是通用排序算法的传统选择。但是，归并排序有一个主要的优点就是稳定。void re...
复制链接

扫一扫

最详细的Collections类和Arrays类常见方法复习

<font face="楷体">1. Collections类的常见操作：</font>

<font face="楷体">1.1. 排序操作：</font>

<font face="楷体">1.2. 查找，替换操作：</font>

<font face="楷体">1.3. 同步控制：</font>

<font face="楷体">1.4. 设置不可变集合：</font>

<font face="楷体">1. Arrays类的常见操作：</font>

最详细的Collections类和Arrays类常见方法复习

<font face="楷体">1. Collections类的常见操作：</font>

<font face="楷体">1.1. 排序操作：</font>

<font face="楷体">1.2. 查找，替换操作：</font>

<font face="楷体">1.3. 同步控制：</font>

<font face="楷体">1.4. 设置不可变集合：</font>

<font face="楷体">1. Arrays类的常见操作：</font>

“相关推荐”对你有帮助么？