Java 集合框架工具类

2022-09-14 12:44:14

Collections
Arrays

Collections

集合框架的工具类, 里面的方法都是静态的, 可以直接使用类名调用

常用方法

1. sort(List<T> list);  // 对实现了 Comparable 接口覆盖了 ComprareTo() 方法的 list 集合排序

// 指定比较器的 list 集合排序

2. static <T> void sort(List<T> list, Comparator<? super T> c);

public static void main(String[] args){

    demo_1();

}

public static void demo_1(){

    List<String> list = new ArrayList<String>();

    list.add("abc");

    list.add("abc");

    list.add("zzz");

    list.add("cba");

    list.add("eee");

    // 使用工具类中的 sort() 方法对 list 集合排序

    // 因为 String 类覆盖了 CompareTo() 方法

    Collections.sort(list);

    System.out.println(list);

}

// 模拟 sort() 方法的实现过程

public static void mySort(List<String> list){

    // 选择排序

    for(int i = 0; i<list.size()-1; i++){

        for(int j=i+1; j<list.size(); j++){

            // list 集合 String 类型元素比较

            // 因为元素比较使用的是 Comparable 接口中的 CompareTo() 方法

            if(list.get(i).compareTo(list.get(j))>0){

                // list 集合两个元素互换位置

                String temp = list.get(i);

                list.set(i, list.get(j));

                list.set(j, list.get(i));

        }

    }

}

}

// 升级版本

// list 集合中必须具备比较性, 因此, T extends Comparable

public static <T extends Comparable<? super T>> void mySort(List<T> list){

    for(int i = 0; i < list.size()-1; i++){

        for(int j = 0; j < list.size(); j++){

            if(list.get(i).compareTo(list.get(j))>0){

                T temp = list.get(i);

                list.set(i, list.get(j));

                list.set(j, list.get(i));

        }

    }

}

}

// 带有比较器的 sort() 方法

public static <T> void mySort(List<T> list, Comparator<? super T> comp){

    for(int i = 0; i < list.size() -1; i++){

        for(int j = 0; j < list.size(); j++){

            if(comp.compare(list.get(i), list.get(j)){

                Collections.swap(list, i, j);

        }

    }

}

}

// 3. 交换集合元素的位置

       static void swap(List<?> list, int i, int j); 

// 4. 二分查找(折半查找)

        static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key);

// 5. 求集合最大值

      max(Collection<? extends T> coll);

// 6. 逆序

      reverseOrder(); // 返回一个比较器

      reverseOrder(Comparator<T> cmp);  // 根据已有比较器来反转

// 7. 替换

        replaceAll(List<T> list, T oldVal, T newVal); // 使用另一个值替换 list 集合中所有某一指定的值

        fill(List<? super T> list, T obj); // 可以将集合中所有的值替换为同一个值

// 8. 随机排序

    shffle(List<?> list);

// 9. 多线程时, 给非同步集合加锁变成同步集合

        synchronizedCollection(Collection<T> c);

        synchronizedList(List<T> list);

// 以 list 为例, 说明非同步集合变成同步集合原理

    List list = new ArrayList(); // 非同步集合

    list = MyCollections.synList(list); // 返回一个同步的 list

    class MyCollections{

        public static List synList(List list){

            return new MyList(list);

        }

        // 私有化 MyList 类

        private class MyList implements List{

            private List list;

            // 锁

            private static final Object lock = new Object();

            // 构造函数

            Mylist(List list){

                this.list = list;

            }

            // 覆盖 list 接口的方法, 直接使用构造函数传入的 List 集合中的方法覆盖

            // 只是在方法之前加锁

            public boolean add(Object obj){

                synchronized(lock);

                {

                    return list.add(obj);

                }

            }

            public boolean remove(Object obj){

                synchronized(lock);

                {

                    return list.remove(obj);

                }

            }

        }

    }

Arrays

集合框架的工具类, 里面的方法都是静态的.

常用方法:

toString(); // 返回指定数组的字符串表示形式

// toString() 方法实现原理

public static String toString(int[] a){

    // 健壮性判断

    if(a == null){

        return "null";

    }

    int iMax = a.length - 1;

    if( iMax == -1)

        return "[]";

        StringBuilder b = new StringBuilder();

        b.append('[');

        for(int i = 0; ; i++) { // 中间省略条件判断, 提高效率

            b.append(a[i]);

        if(i == iMax)   //iMax 是常量, 条件在此处判断

        return b.append(']').toString();

            b.append(", ");

        }

}

数组转换成 List 集合 : List asList(数组);

原因: 可以使用操作集合的方法操作数组中的元素.

// 判断数组中是否存在某一个元素

String[] arr = {"abc", "haha","xixi"};

// 1. 数组转换为集合

List<String> list = Arrays.asList(arr);

boolean b = list.contains("xixi");

// 注意一: 数组的长度是固定的, 所以对于集合的增删方法是不可以使用的.

        会出现 UnsupportedOperationException 异常.

     list.add("ccc"); //出现异常

// 注意二:

//  如果数组中的元素是对象, 那么转成集合时,直接将数组中的元素作为集合中的元素进行存储

String[] arr = {"abc", "haha", "xixi"};

List<String> list = Arrays.asList(arr);

System.out.println(list);  // 输出结果: [abc,haha,xixi]

//  如果数组中的元素是基本类型数值, 那么会将该数组作为集合中的元素进行存储.

//  基本数据类型不能存入集合中

int[] arr1 = {22,33,44,25};

List<int[]> list1 = Arrays.asList(arr1); // List<int[]> 类型为数组

System.out.println(list1);  // 输出结果为: [[I@7852e922

集合转成数组:
- Collection 接口中
  - Object toArray(); 存在类型提升为 Object
  - <T> T[] toArray(T[] a);
- 集合转成数组: 可以对集合中的元素操作方法进行限定, 不允许对集合中元素进行增删

List<String> list = new ArrayList<String>();

list.add("abc1");

list.add("abc2");

list.add("abc3");

/*

 * toArray() 方法需要传入一个指定类型的数组

 * 数组长度如何定义呢?

 * 如果长度小于集合的 size, 那么该方法会创建一个同类型并且与集合 size 相同的数组

 * 如果长度大于集合的 size, 那么该方法就会使用指定的数组, 存储集合中的元素, 其他位置默认为 null

 *

 * 建议, 数组长度最好指定为 集合的 size

 */

String[] arr = list.toArray(new String[list.size()]);

System.out.println(Arrays.toString(arr));

_参考资料_
- [JavaSE 基础视频(毕向东)](https://www.bilibili.com/video/av3124630/#page=5)
- [JDK 1.6 中文文档](http://tool.oschina.net/apidocs/apidoc?api=jdk-zh)

码农公寓

Collections

常用方法

Arrays

常用方法:

相关文章