0
点赞
收藏
分享

微信扫一扫

Collections类(笔记)

柠檬果然酸 2022-03-23 阅读 45
java学习

1.Collections的常用功能(重点)

package com.itheima.demo01Collections;

import java.util.ArrayList;
import java.util.Collections;

/*
    java.util.Collections是集合工具类，用来对集合进行操作。
      常用方法如下：
    - public static void shuffle(List<?> list):打乱集合中元素顺序。
    - public static <T> void sort(List<T> list):根据元素的自然顺序 对指定列表按升序进行排序。
    注意:
        以上两个方法的参数,只能传递List集合,对List集合进行排序|打乱顺序
        不能传递Set集合
 */
public class Demo01Collections {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(5);
        list01.add(6);
        list01.add(4);
        list01.add(2);
        System.out.println(list01);//[1, 3, 5, 6, 4, 2]

        //public static <T> void sort(List<T> list):根据元素的自然顺序对指定集合按升序进行排序。
        //升序:小==>大  降序:大==>小
        Collections.sort(list01);
        System.out.println(list01);//[1, 2, 3, 4, 5, 6]

        //public static void shuffle(List<?> list):[随机]打乱集合中元素顺序。
        Collections.shuffle(list01);
        System.out.println(list01);//[4, 3, 6, 2, 5, 1] [2, 6, 3, 4, 5, 1] [4, 5, 3, 2, 6, 1] [6, 1, 4, 5, 2, 3]

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("aa");
        list02.add("AA");
        list02.add("AD");
        list02.add("bb");
        list02.add("12");
        list02.add("ab");
        System.out.println(list02);//[aa, AA, AD, bb, 12, ab]
        Collections.sort(list02);//自然顺序:编码表的顺序
        System.out.println(list02);//[12, AA, AD, aa, ab, bb]
    }
}

2.Comparator比较器(重点)(是一个接口)

  • 方法:

在这里插入图片描述

在这里插入图片描述

package com.itheima.demo01Collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/*
    static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定[比较器产生的顺序]对指定集合进行排序。
    参数:
        List<T> list:传递要排序的List集合
        Comparator<? super T> c:比较器
    java.util.Comparator<T> 接口:强行对某个集合进行整体排序的比较函数。
    成员方法:
        int compare(T o1, T o2) 比较用来排序的两个参数。
    参数:
        T o1, T o2:会依次获取到集合中相邻的两个元素
    排序的规则:
        o1-o2:升序排序
        o2-o1:降序排序
        o1==o2:两个元素相等
 */
public class Demo02Collections {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(5);
        list01.add(6);
        list01.add(4);
        list01.add(2);
        System.out.println(list01);//[1, 3, 5, 6, 4, 2]

        //static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定[比较器产生的顺序]对指定集合进行排序。
        Collections.sort(list01, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序:o1-o2
                return o1-o2;
            }
        });
        System.out.println(list01);//[1, 2, 3, 4, 5, 6]

        //Collections.sort(list01, new ComparatorImpl());
        Collections.sort(list01, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //降序:o2-o1
                return o2-o1;
            }
        });
        System.out.println(list01);//[6, 5, 4, 3, 2, 1]
    }
}

在这里插入图片描述
字符串自定义排序规则

package com.itheima.demo01Collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo03Collections {
    public static void main(String[] args) {
        ArrayList<String> list02 = new ArrayList<>();
        list02.add("aa");
        list02.add("AA");
        list02.add("AD");
        list02.add("bb");
        list02.add("12");
        list02.add("ab");
        Collections.sort(list02, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //先按照字符串的第一个字符进行降序排序
                int a =  o2.charAt(0)-o1.charAt(0);//'a'-'A'==>97-65
                if(a==0){
                    //首字母相等,在按照第二个字母降序排序
                    a = o2.charAt(1)-o1.charAt(1);
                }
                return a;
            }
        });
        System.out.println(list02);//[bb, ab, aa, AD, AA, 12]

        Collections.sort(list02, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                /*
                    String类成员方法:
                        int compareTo(String anotherString)
                            按字典(编码表)顺序比较两个字符串。
                 */
                //字符串降序排序
                return o2.compareTo(o1);
            }
        });
        System.out.println(list02);//[bb, ab, aa, AD, AA, 12]

        Collections.sort(list02, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //字符串升序
                return o1.compareTo(o2);
            }
        });
        System.out.println(list02);//[12, AA, AD, aa, ab, bb]
    }
}

🎗经验分享

1.已知使用Collections中的sort代码

public class Demo04Collections {
    public static void main(String[] args) {
        //创建AarrayList集合对象,泛型使用Person
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("azhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",19));
        list.add(new Person("zhaoliu",18));
        list.add(new Person("tianqi",21));

        Collections.sort(list);
    }
}

public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

2.出现的问题

3.问题的分析

4.问题解决办法

package com;

public class Person implements Comparable<Person>{
    private String name;
    private int age;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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 int compareTo(Person o) {
        //比较两个人的年龄一个是this,一个是参数Person o
        //return this.age - o.age;//按照年龄升序
        return o.age - this.age;//按照年龄降序
    }
}

package com;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo01Collections {
    public static void main(String[] args) {
        //创建AarrayList集合对象,泛型使用Person
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("azhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",19));
        list.add(new Person("zhaoliu",18));
        list.add(new Person("tianqi",21));

        Collections.sort(list);

        System.out.println(list);
    }
}

程序运行结果(降序排序):有了排序规则sort方法不在报错
在这里插入图片描述
在这里插入图片描述

public class Demo01Collections {
    public static void main(String[] args) {		
		//创建AarrayList集合对象,泛型使用Person
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("azhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",19));
        list.add(new Person("zhaoliu",18));
        list.add(new Person("tianqi",21));

        //使用Collections集合工具类中的方法sort,对集合中的元素根据比较器产生的规则排序(年龄升序排序)
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                //年龄升序排序
                return o1.getAge()-o2.getAge();
            }
        });
        System.out.println(list);

        //按照两个人的年龄升序排序,如果两个人的年龄相同,按照姓名的首字母降序排序
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                //按照两个人的年龄升序排序
                int a = o1.getAge()-o2.getAge();
                //判断两个人的年龄是否相等
                if(a==0){
                    //按照姓名的首字母降序排序
                    a = o2.getName().charAt(0) - o1.getName().charAt(0);
                }
                return a;
            }
        });
        System.out.println(list);

        //按照两个人的年龄升序排序,如果两个人的年龄相同,按照姓名进行降序排序
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                //按照两个人的年龄升序排序
                int a = o1.getAge()-o2.getAge();
                //判断两个人的年龄是否相等
                if(a==0){
                    //按照姓名进行降序排序
                    /*
                        String类中的方法
                            int compareTo(String anotherString)按字典顺序(编码表的顺序)比较两个字符串。
                            会取出两个字符串中的每个字符,依次比较
                     */
                    a = o2.getName().compareTo(o1.getName());
                }
                return a;
            }
        });
        System.out.println(list);
    }
}

package com;

public class Person{
    private String name;
    private int age;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }

}

程序运行结果:
在这里插入图片描述
3.可变参数

package com.itheima.demo03variableArgs;

/*
    可变参数:
        是JDK1.5之后出现的新特性
    作用:
        【作为方法的形式参数使用,可以接收任意个同种数据类型的实际参数】
        当我们定义一个方法,方法参数的数据类型已经确定了,但是参数的个数不确定,就可以使用可变参数
    格式:
        修饰符 返回值类型 方法名(数据类型...变量名){
            方法体;
        }
    数据类型...变量名:可变参数
    int...a:可以接收任意个int类型的整数(不传递参数,传递1个参数,传递10个参数....传递100个参数...)
    String...a:可以接收任意个String类型的字符串(不传递参数,传递1个参数,传递10个参数....传递100个参数...)
    -------------------------------------------------
    注意:可变参数的底层就是一个数组,定义不同长度的数组,来存储传递的不同个数
 */
public class Demo01 {
    public static void main(String[] args) {
        //getSum();
        //getSum(10);
        int s1 = getSum(10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
        System.out.println("s1:"+s1);//s1:550
        int s2 = getSum(10, 20);
        System.out.println("s2:"+s2);//s2:30
    }

    /*
        定义一个方法,计算n个int类型整数和并返回
        已知:数据类型int
        未知:传递多少个参数
        解决:使用可变参数解决
        --------------------------------------------
        getSum();那么可变参数就会创建一个长度为0的数组,存储数据 int[] a = new int[]{ };
        getSum(10);那么可变参数就会创建一个长度为1的数组,存储数据 int[] a = new int[]{10};
        getSum(10,20);那么可变参数就会创建一个长度为2的数组,存储数据 int[] a = new int[]{10,20};
        ...
        getSum(10,20,30,40,50,60,70,80,90,100);那么可变参数就会创建一个长度为10的数组,
            存储数据 int[] a = new int[]{10,20,30,40,50,60,70,80,90,100};
     */
    public static int getSum(int...a){
        //System.out.println(a);
        //System.out.println(a.length);
        int sum = 0;
        for (int i : a) {
            sum+=i;
        }
        return sum;
    }
    /*
        定义一个方法,计算两四个int类型整数的和并返回
     */
    /*public static int getSum(int a,int b,int c,int d){
        return a+b+c+d;
    }*/

    /*
        定义一个方法,计算两三个int类型整数的和并返回
     */
    /*public static int getSum(int a,int b,int c){
        return a+b+c;
    }*/

    /*
        定义一个方法,计算两个int类型整数的和并返回
     */
    /*public static int getSum(int a,int b){
        return a+b;
    }*/
}

重点:记住可变参数可以接收任意个同种数据类型的元素

package com.itheima.demo03variableArgs;

import java.util.ArrayList;

public class Demo02 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        method(10,1.1,list,true,false,true,false,true,true,false);
    }
    
    //可变参数的注意事项
    //1.一个方法的参数列表中只能写一个可变参数
    //public static void method(String...a,int...b){ }
    
    //2.方法的参数列表如果有多个参数,可变参数必须写在末尾
    //Vararg parameter must be the last in the list
    //public static void method(int a, double b,boolean...boo ,ArrayList<String> list){ }
    //public static void method(int a, double b,ArrayList<String> list,boolean...boo){ }
    
    //3.看java底层源码
    //public static void method(Object...obj){}
    public static <T> T[] method(T...t){
        return t;
    }
}

可变参数注意事项:
1.一个方法的参数列表中只能写一个可变参数

2.方法的参数列表如果有多个参数,可变参数必须写在末尾
在这里插入图片描述
3.看java底层源码
在这里插入图片描述
4.Collections集合工具类中的方法addAll
在这里插入图片描述

package com.itheima.demo03variableArgs;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;

/*
    Collections集合工具类中的方法addAll
    static <T> boolean addAll(Collection<? super T> c, T... elements)
          将所有指定元素添加到指定 collection 中。
 */
public class Demo03addAll {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        //add一次添加一个元素
        //list.add(1);
        //list.add(2);
        //list.add(3);
        //list.add(4);
        //list.add(5);
        //addAll一次添加多个元素
        Collections.addAll(list,1,2,3,4,5);
        System.out.println(list);

        LinkedList<String> linked = new LinkedList<>();
        Collections.addAll(linked,"aa","bb","jack","rose");
        System.out.println(linked);//[aa, bb, jack, rose]

        HashSet<Double> set = new HashSet<>();
        Collections.addAll(set,1.1,2.2,3.3,4.5,5.5);
        System.out.println(set);
    }
}
举报

相关推荐

Collections类

javaSystem键值对数字化转型

【Java笔记】Collections工具类的使用

java开发语言面向对象

Collections工具类

java

如何使用Collections类

rabbitmq架构springbootjava

Collections类是什么？

java开发语言后端

【Java Collections工具类】

java开发语言

Collections类操作集合

排序算法java数据结构

Collections工具类使用

java

JDK 工具类之 Collections

javaidesed编程语言

Java精选笔记_集合概述(Collection接口、Collections工具类、Arrays工具类)

集合Collection接口Collections工具类Arrays工具类数组虚拟化云计算
0 条评论