Collections类 Set接口

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

        shuffle();将集合中的元素随机打乱

public static void main(String[]args){
    
    List<Integer> list = new ArrayList<>();
         // 往集合中添加⼀些元素
         list.add(300);
         list.add(100);
         list.add(200);
         list.add(500);
         list.add(400);
    //打乱顺序之前[300, 100, 200, 500,400]
    System.out.println(list);
    Collection.shuffle(list);
    System.out.println("打乱顺序之后"+list);
}

        sort();

public static void main(String[]args){
    
    List<Integer> list = new ArrayList<>();
         // 往集合中添加⼀些元素
         list.add(300);
         list.add(100);
         list.add(200);
         list.add(500);
         list.add(400);
    //排序序之前[300, 100, 200, 500,400]
    System.out.println(list);
    Collection.sort(list);
    System.out.println("排序之后"+list);
    //{100,200,300,400,500}
}

        Comparator比较器

         使用Comparator比较器进行排序

public static void main(String[]args){
    
    List<Integer> list = new ArrayList<>();
         // 往集合中添加⼀些元素
         list.add(300);
         list.add(100);
         list.add(200);
         list.add(500);
         list.add(400);
    //排序之前的集合{300，100，200，500，400}
    System.out.println(list);
    //对list集合指定规则排序：降序
    Collectons.sort(list,newComparator<Integer>(){
        @Override
            public int compare(Integer o1,Interger o2){
            // 指定排序规则
            // 前减后:升序
            // 后减前:降序
            // 前:第⼀个参数 o1
            // 后:第⼆个参数 o2
            return o2 - o1;
    }
});
    System.out.println("排序之后的集合："+list)


    //对list集合指定规则排序：升序
    Collectons.sort(list,newComparator<Integer>(){
        @Override
            public int compare(Integer o1,Interger o2){
            // 指定排序规则
            // 前减后:升序
            // 后减前:降序
            // 前:第⼀个参数 o1
            // 后:第⼆个参数 o2
            return o1 - o2;
    }
});

  Set接口:

        凡是实现了Set接口的类都叫做Set集合

        特点：元素无索引，元素存取无序，元素不可重复（唯一）

        实现类:

                 HashSet集合:元素⽆索引,元素存取⽆序,元 素不可重复(唯⼀)

                 LinkedHashSet集合:元素⽆索引,元素存取 有序,元素不可重复(唯⼀)

                 TreeSet集合:元素⽆索引,元素存取⽆序,元 素不可重复(唯⼀),元素可排序

                  Set集合元素无索引，所以遍历方式只能是：迭代器，增强for循环

        HashSet集合

                hashSet集合是Set接口的一个实现类，其中所存储的元素是不可重复的，元素也是无序的

        HashSet存储自定义类型元素

public class Person{
 //姓名
 public String name;
 //年龄
 public 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 +
     '}';
 }
@Override
     public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() !=
     o.getClass()) return false;
     Person person = (Person) o;
     return age == person.age &&
     Objects.equals(name,
    person.name);
 }
@Override
 public int hashCode() {
 return Objects.hash(name, age);
 }
}



public class Demo {
     public static void main(String[] args) {
     // 创建多个Person对象
     Person p1 = new Person("张三", 18);
     Person p2 = new Person("李四", 38);
     Person p3 = new Person("王五", 28);
     Person p4 = new Person("张三", 18);
     // 创建HashSet集合对象,限制集合中元素的类型为
    Person
     HashSet<Person> set = new HashSet<>();
     // 往集合中添加Person对象
     set.add(p1);
     set.add(p2);
     set.add(p3);
     set.add(p4);
     // 遍历打印集合中的元素
     for (Person p : set) {
     System.out.println(p);
     }
     System.out.println(p1.hashCode());
     System.out.println(p2.hashCode());
     System.out.println(p3.hashCode());
     System.out.println(p4.hashCode());
    }
}
    

        LinkedHashSet

        元素怎么存就怎么取，即存取有序

public static void main(String[] args) {
 Set<String> set = new LinkedHashSet<String>
();
 set.add("bbb");
 set.add("aaa");
 set.add("abc");
 set.add("bbc");
 Iterator<String> it = set.iterator();
 while (it.hasNext()) {
 System.out.println(it.next());
 }
 }
}
结果：
 bbb
 aaa
 abc
 bbc

TreeSet集合

        元素唯一，元素没有索引，使用元素的自然顺序进行排序，要么使用Comparator比较器进行排序

public static void main(String[] args) {
 //⽆参构造,默认使⽤元素的⾃然顺序进⾏排序
 TreeSet<Integer> set = new TreeSet<Integer>
();
 set.add(20);
 set.add(18);
 set.add(23);
 set.add(22);
 set.add(17);
 set.add(24);
 set.add(19);
 System.out.println(set);
}
控制台的输出结果为:
[17, 18, 19, 20, 22, 23, 24]


public static void main(String[] args) {
 //有参构造,传⼊⽐较器,使⽤⽐较器对元素进⾏排序
 TreeSet<Integer> set = new TreeSet<Integer>
(new Comparator<Integer>() {
 @Override
⼩结
略
第三章 Map集合
知识点-- Map概述
 public int compare(Integer o1, Integer
o2) {
 //元素前 - 元素后 : 升序
 //元素后 - 元素前 : 降序
 return o2 - o1;
}
 });
 set.add(20);
 set.add(18);
 set.add(23);
 set.add(22);
 set.add(17);
 set.add(24);
 set.add(19);
 System.out.println(set);
}
控制台的输出结果为:
[24, 23, 22, 20, 19, 18, 17]