Java入门需要了解（集合工具类-三十三）

集合工具类的作用

Collections

是操作 collection 的静态方法
collection 上进行操作或返回 collection 的静态方法组成

Collections排序

被排序的类实现Comparable接口方式排序

/**
 * 泛型排序接口的简单实现
 */
class SortTest {

    public static void main(String[] args) {
        testStringSort();
    }

    private static void testStringSort() {
        List<String> listStr = new ArrayList<>();
        listStr.add("zzz");
        listStr.add("abc");
        listStr.add("ddd");
        listStr.add("bcde");
        listStr.add("efff");
        System.out.println("sort before listStr = " + listStr);
        sort(listStr);
        System.out.println("sort after listStr = " + listStr);
    }

    /**
    *这样的方法，就可以对所有实现了Comparable接口的类进行简单排序
    *而不仅仅是对String
    */
    public static <T extends Comparable> void sort(List<T> list) {
        for (int i = 0;i < list.size();i++) {
            for (int j = i + 1;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,temp);
                }
            }
        }
    }
}

使用比较器Comparator方式排序

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class SortTest2 {
    public static void main(String[] args) {
        List<Person> listPerson = new ArrayList<>();
        listPerson.add(new Person("zhangsan",21));
        listPerson.add(new Person("lisi",21));
        listPerson.add(new Person("wangwu",18));
        listPerson.add(new Person("xiaohua",17));
        System.out.println(" sort before listPerson = " + listPerson);
        sortByComparator(listPerson,new PersonComparator());
        System.out.println(" sort after listPerson = " + listPerson);
    }


    public static <T> void sortByComparator(List<T> list,Comparator<T> comparator) {
        for (int i = 0;i < list.size();i++) {
            for (int j = i + 1;j < list.size();j++) {
                if (comparator.compare(list.get(i),list.get(j)) > 0) {
                    T temp = list.get(i);
                    list.set(i,list.get(j));
                    list.set(j,temp);
                }
            }
        }
    }


}

/**
 * 用于测试的类
 */
class Person {
    private String name;
    private int age;

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //方便查看打印结果
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/**
 * Person的比较器实现
 */
class PersonComparator implements Comparator<Person> {
    //年龄优先排序，年龄相同的，按照名字的比较排序
    @Override
    public int compare(Person o1,Person o2) {
        int tempAge = o1.getAge() - o2.getAge();
        if (tempAge != 0) {
            return tempAge;
        }
        return o1.getName().compareTo(o2.getName());
    }
}

逆序排序

所有具有排序功能的集合都可以使用这样的方式。

import java.util.Collections;
import java.util.Comparator;
import java.util.TreeSet;

class RevertSortTest {

    public static void main(String[] args) {
        sortTest1();
        sortTest2();
    }

    //使用自定义的比较器
    public static void sortTest1() {
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1,String o2) {
                return o2.compareTo(o1);
            }
        });
        treeSet.add("zzz");
        treeSet.add("abc");
        treeSet.add("bcd");
        treeSet.add("efg");
        treeSet.add("cc");
        System.out.println("sortTest1 treeSet = " + treeSet);
    }

    //使用Collection的逆序比较器
    public static void sortTest2() {
        TreeSet<String> treeSet = new TreeSet<>(Collections.reverseOrder());
        treeSet.add("zzz");
        treeSet.add("abc");
        treeSet.add("bcd");
        treeSet.add("efg");
        treeSet.add("cc");
        System.out.println("sortTest2 treeSet = " + treeSet);
    }

}

Collections二分查找

public static int binarySearch(List<? extends Comparable<? super T>> list,T key)
对已经排序过的列表进行二分查找以获取元素的指定位置
还有一个可以自己指定比较器查找办法

Collections获取最大值元素

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
根据元素的 自然顺序，返回给定 collection 的最大元素

Collections同步线程安全的列表

public static List synchronizedList(List list)
返回指定列表支持的同步（线程安全的）列表

Arrays

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

asList(T…)

public static List asList(T… a)
充当了基于数组的 API 与基于 collection 的 API 之间的桥梁
数组转集合的好处是，集合提供了更多的可操作元素的方法，数组的方法有限
数组的长度是固定的，不能改变长度

函数可变参数

但是在使用可变参数类型时，必须定义在参数列表的结尾

public static void test(String... strArr){
	//strArr为数组形式
	 for (String item: strArr) {
            System.out.println("item = " + item);
     }
}

静态导入

• 导入方式 import static 包名….类名.静态成员;
• 可以直接导入某个类的静态成员。
• 导入方式 import static 包名….类名.*;
• 导入所有的静态成员
• 类名冲突时，需要使用类名