Java 集合框架工具类

• Collections
• Arrays

Collections

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

常用方法

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

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

常用方法:

1. 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(", ");
        }
}

1. 数组转换成 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

1. 集合转成数组:
   • 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)