Java 进阶学习笔记day_05（Collections类、可变参数、Set接口、HashSet、LinkedHashSet、TreeSet）

本文链接：https://blog.youkuaiyun.com/weixin_43754657/article/details/123693788

Collections类

java.util.Collections是集合工具类，用来对集合进行操作

Collections类的的三个常用静态方法
shuffle（打乱集合顺序
sort（默认规则排序 - 升序
sort（指定规则排序


	public class Text {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        list.add(800);
        list.add(100);
        list.add(400);
        list.add(500);
        list.add(600);

        Collections.shuffle(list);
        // 乱序之前 list = [800, 500, 600, 400, 100]
        System.out.println("list = " + list);

        // 打乱顺序之后的集合 list = [800, 500, 600, 400, 100]
        System.out.println("list = " + list);

        // 默认会以升序排序  list = [100, 400, 500, 600, 800] 
        Collections.sort(list);
        System.out.println("list = " + list);

        // 用指定的方法排序
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {

                // 前减后 - 升序
                // 后前前 - 降序
                return o2 - o1; // list = [800, 600, 500, 400, 100]
            }
        });
        System.out.println("list = " + list);
    }
}

使用自己定义的类进行排序时_


	class Show{
    String name;
    int a;

    public Show() {
    }

    public Show(String name, int a) {
        this.name = name;
        this.a = a;
    }

    @Override
    public String toString() {
        return "Show{" +
                "name='" + name + '\'' +
                ", a=" + a +
                '}';
    }
}


public class Text {
    public static void main(String[] args) {
        List<Show> list = new ArrayList<>();

        list.add(new Show("张三",16));
        list.add(new Show("李四",26));
        list.add(new Show("老六",56));
        list.add(new Show("王五",46));
        list.add(new Show("老王",16));


        Collections.sort(list, new Comparator<Show>() {
            @Override
            public int compare(Show o1, Show o2) {
                // 按年龄进行降序排序
                return o2.a - o1.a;
            }
        });

        for (Show show : list) {
            System.out.println("list = " + show);
        }

        // 输出：
        // 当使用自己定义的类时，需要重写 equals() hashCode() 方法
        //list = Show{name='老六', a=56}
        //list = Show{name='王五', a=46}
        //list = Show{name='李四', a=26}
        //list = Show{name='张三', a=16}
        //list = Show{name='老王', a=16}
        
    }
}

可变参数

在JDK1.5之后，定义了可变参数，用来表示一个方法需要接受的多个同类型参数

格式：


	修饰符 返回值类型 方法名(数据类型... 变量名){
    
}


	public class Text2 {
    public static void main(String[] args) {

        // 调用show 方法
        show(10,20,30,40,50);
        // 当传递多个不同类型的参数时，可变参数要放在最后
        show2("个数",200,300);

    }
    public static void show(int... num){

        // 可以当数组来使用遍历
        for (int i = 0; i < num.length; i++) {
            // 遍历num 中的元素并输出
            System.out.println(num[i]); // 输出 10 20 30 40 50 
        }
    }
    public static void show2(String name,int... num2){

    }
}

Collections工具类中的批量添加元素的静态方法_

static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素


	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;
	
	public class Text3 {
	    public static void main(String[] args) {
	
	        List<Integer> list = new ArrayList<>();
	
	        Collections.addAll(list,10,20,30,40,50,60,70);
	        
	        // 输出 [10, 20, 30, 40, 50, 60, 70]
	        System.out.println(list);
	    }
}

Set接口

java.util.Set接口继承自Collection接口，是单列集合的一个重要分支
元素没有索引,元素唯一(不重复)

注意：
Set集合元素没有索引,只能使用迭代器或者增强for循环进行遍历元素
Set集合没有特殊的方法,都是使用Collection的方法
Set接口就是Set集合,但凡实现了Set接口的类也叫做Set集合

常用实现类

HashSet类: 元素没有索引,元素唯一,元素存取顺序不一致（存储结构采用的是哈希表结构,由哈希表保证元素唯一）
LinkedHashSet类:元素没有索引,元素唯一,元素存取顺序一致（存储结构采用的是哈希表+链表结构,由哈希表保证元素唯一,由链表保证元素存取顺序一致）
TreeSet类: 元素没有索引,元素唯一,可以对元素进行排序（存储结构采用的是红黑树结构,由红黑树保证元素唯一,由比较器来对元素进行排序）

HashSet

java.util.HashSet是Set接口的一个实现类, 底层的实现其实是一个java.util.HashMap支持


	import java.util.HashSet;

	public class Text4 {
	    public static void main(String[] args) {
	        HashSet<String> hSet = new HashSet<>();
	
			// 向集合中添加元素
	        hSet.add("abc");
	        hSet.add("abd");
	        hSet.add("acd");
	        hSet.add("cba");
	        hSet.add("abc");
	
	        // 输出 hSet = [abd, abc, acd, cba]  （元素唯一，存取无序）
	        System.out.println("hSet = " + hSet);
    }
}

HashSet存储自定义类型元素_

HashSet存储自定义类型元素,要求该元素所属的类要重写hashCode和equals方法


	import java.util.HashSet;
import java.util.Objects;

class Student{
    String name;
    int age;

    public Student() {
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Text5 {
    public static void main(String[] args) {
        HashSet<Student> hSet = new HashSet<>();

        // 创建学生对象并添加到 hSet 集合中
        hSet.add(new Student("小红",16));
        hSet.add(new Student("小明",18));
        hSet.add(new Student("小黑",16));
        hSet.add(new Student("小红",16));

        // 遍历集合
        for (Student stu : hSet) {
            // 自己定义的类要重写hashCode和equals方法
            System.out.println(stu);
        }
    }
}

注意：

重写hashCode和equals方法比较的是类中各个元素的值，如全部相同则只会保留相同的一个对象

LinkedHashSet

元素没有索引,元素唯一,元素存取顺序一致


	import java.util.LinkedHashSet;

	public class Text6 {
	    public static void main(String[] args) {
	        LinkedHashSet<Integer> lhSet = new LinkedHashSet<>();
	            lhSet.add(200);
	            lhSet.add(500);
	            lhSet.add(100);
	            lhSet.add(700);
	            lhSet.add(400);
	            lhSet.add(400);
	
	        // 输出 lhSet = [200, 500, 100, 700, 400]
	        System.out.println("lhSet = " + lhSet);
	    }
}

TreeSet

TreeSet集合是Set接口的一个实现类，底层依赖于TreeMap,是一种基于红黑树的实现

元素没有索引,元素唯一,可以对元素进行排序
存储结构采用的是红黑树结构,由红黑树保证元素唯一,由比较器来对元素进行排序

要求集合元素所属的类必须实现Comparable接口,重写compareTo方法,在compareTo方法中指定排序规则


	import java.util.Comparator;
	import java.util.TreeSet;
	
	public class Text7 {
	    public static void main(String[] args) {
	        TreeSet<Integer> tSet = new TreeSet<>();
	
	        tSet.add(500);
	        tSet.add(300);
	        tSet.add(100);
	        tSet.add(200);
	        tSet.add(500);
	
	        // 输出 tSet = [100, 200, 300, 500]
	        System.out.println("tSet = " + tSet);
	
	        TreeSet<Integer> tSet2 = new TreeSet<>(new Comparator<Integer>() {
	            @Override
	            public int compare(Integer o1, Integer o2) {
	                // 按降序排序
	                return o2 - o1;
	            }
	        });
	
	        tSet2.add(500);
	        tSet2.add(300);
	        tSet2.add(100);
	        tSet2.add(200);
	        tSet2.add(500);
	        // 输出 tSet2 = [500, 300, 200, 100]
	        System.out.println("tSet2 = " + tSet2);
	    }
}