暑期JAVA学习（11.2）集合工具类Collections

一、Collections集合工具类

●java.utils.Collections：是集合工具类

●作用：Collections并不属于集合，是用来操作集合的工具类。

二、Collections常用的API

方法名称	说明
public static boolean addAll(Collection<? super T> C, T… elements)	给集合对象批量添加元素
public static void shuffle(List<?> list)	打乱List集合元素的顺序

三、Collections排序相关API

●使用范围:只能对于List集合的排序。

排序方式1:

方法名称	说明
public static void sort(List list)	将集合中元素按照默认规则排序

注意：本方式不可以直接对自定义类型的List集合排序,除非自定义类型实现了比较规则Comparable接口。

排序方式2:

方法名称	说明
publiz static void sort(List list, Comparator<? super T> c)	将集合中元素按照指定规则排序

四、举例

public class CollectionsDemo1 {
    public static void main(String[] args) {
        /**
         * 目标: Collections 工具类的使用。
         * java.utils.Collections:是集合工具类
         * Collections并不属于集合，是用来操作集合的工具类。
         * Collections有几个常用的API:
         * - public static <T> boolean addAll(Collection<? super T> c, T... elements)
         * 给集合对象批量添加元素!
         * - public static void shuffle(List<?> list) :打乱集合顺序。
         * - public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
         * - public static <T> void sort(List<T> list, Comparator<? super T> c):将集合中元素按照指定规则排序。
         */

        //1. public static <T> boolean addAll(Collection<? super T> c, T... elements)
        //给集合对象批量添加元素!
        List<String> lists = new ArrayList<>();
//        lists.add("one");
//        lists.add("two");
//        lists.add("three");
//        lists.add("four");
        //批量加元素更方便
        Collections.addAll(lists,"one","two","three","four");
        System.out.println(lists);//[one, two, three, four]
        System.out.println("--------------------------");

        //2. public static void shuffle(List<?> list) :打乱集合顺序。
        Collections.shuffle(lists);
        System.out.println(lists);
        System.out.println("--------------------------");

        //3.方式一：public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。(排值特性的元素)
        List<Integer> lists1 = new ArrayList<>();//shift + F6可同步改
        Collections.addAll(lists1,1,2,3,4);
        System.out.println(lists1);//[1, 2, 3, 4]
        Collections.shuffle(lists1);
        System.out.println(lists1);
        Collections.sort(lists1);
        System.out.println(lists1);//[1, 2, 3, 4]
        System.out.println("--------------------------");

        //将集合中元素按照指定规则排序。
        List<Summerday10.Apple> apples = new ArrayList<>();
        //本身就可以重复，而使用TreeSet自定义排序规则时，不可以重复，需再通过其他语句过滤
        apples.add(new Summerday10.Apple("红富士","红色",9.9,500));
        apples.add(new Summerday10.Apple("红将军","红色",15.0,500));
        apples.add(new Summerday10.Apple("青苹果","青色",19.9,600));
        apples.add(new Summerday10.Apple("红玉","红色",15.8,1000));
        //[Apple{name='红富士', color='红色', price=9.9, weight=500},
        // Apple{name='红将军', color='红色', price=15.0, weight=500},
        // Apple{name='青苹果', color='青色', price=19.9, weight=600},
        // Apple{name='红玉', color='红色', price=15.8, weight=1000}]

        Collections.sort(apples);//可以的，Apple类已经重写排序规则
        System.out.println(apples);
        System.out.println("--------------------------");

        // 4.方式二： public static <T> void sort(List<T> list, Comparator<? super T> c):将集合中元素按照指定规则排序。
        //将集合中元素按照指定规则排序。
        List<Summerday10.Apple> apples1 = new ArrayList<>();
        //本身就可以重复，而使用TreeSet自定义排序规则时，不可以重复，需再通过其他语句过滤
        apples1.add(new Summerday10.Apple("红富士","红色",9.9,500));
        apples1.add(new Summerday10.Apple("红将军","红色",15.0,500));
        apples1.add(new Summerday10.Apple("青苹果","青色",19.9,600));
        apples1.add(new Summerday10.Apple("红玉","红色",15.8,1000));

        //sort方法自带比较器对象
        Collections.sort(apples1, new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return Double.compare(o1.getPrice(), o2.getPrice());//按照价格排序
                //存储的对象有实现比较规则，sort方法也自带比较器，默认使用sort方法自带的比较器排序。
            }
        });
        System.out.println(apples1);
        //[Apple{name='红富士', color='红色', price=9.9, weight=500},
        // Apple{name='红将军', color='红色', price=15.0, weight=500},
        // Apple{name='红玉', color='红色', price=15.8, weight=1000},
        // Apple{name='青苹果', color='青色', price=19.9, weight=600}]

    }
}

public class Apple implements Comparable<Apple>{
    private String name;
    private String color;
    private double price;
    private int weight;

    public Apple() {
    }

    public Apple(String name, String color, double price, int weight) {
        this.name = name;
        this.color = color;
        this.price = price;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;

    }

    @Override
    public String toString() {
        return "Apple{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", price=" + price +
                ", weight=" + weight +
                '}';
    }

    /**
     * 方式一：类自定义比较规则
     * @param o
     * @return
     */
    @Override
    public int compareTo(Apple o) {
        //按照重量进行比较
        return this.weight - o.weight;//重量相同时，不会去掉重量相同的元素
    }

}