【Java学习】Set集合、Collections工具类

Set接口 extends Collection接口
Set接口的特点：
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
HashSet集合 implement Set接口
HashSet特点：
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
3.是一个无序集合，存储元素和取出元素的顺序有可能不一致
4.底层是一个哈希表结构(查询的速度非常快)

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Demo01Set {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        // 使用add方法往集合中添加元素
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {
            Integer n = it.next();
            System.out.println(n);
        }

        for (Integer n : set) {
            System.out.println(n);
        }
    }
}

哈希值：是一个十进制的整数，由系统随机给出(就是对象的地址值，是一个逻辑地址，是模拟出来得到的地址，不是数据实际存储的物理地址
在Object类有一个方法，可以获取对象的哈希值
int hasCode() 返回该对象的哈希码值
hasCode方法的源码：

public native int hashCode();
native:代表该方法调用的是本地操作系统的方法

HashSet存储自定义类型元素
set集合保存元素唯一：
存储的元素(String,Integer,…Student.Person),必须重写hasCode方法和equals方法
要求：
同名同年龄的人，视为同一个人，只能存储一次

import java.util.Objects;

class Person {
    private String name;
    private int 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);
    }

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

    public Person() {
    }

    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;
    }
}
public class Demo04HashSetSavePerson {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        Person p1 = new Person("小仙女",19);
        Person p2 = new Person("小美女",18);
        Person p3 = new Person("小美女",18);

        System.out.println(p1.hashCode()); // 722193131
        System.out.println(p2.hashCode()); // 734175839
        System.out.println(p3.hashCode()); // 734175839

        System.out.println(p2==p3); // false
        System.out.println(p2.equals(p3)); // true
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set); //[Person{name='小仙女', age=19}, Person{name='小美女', age=18}]
    }
}

LinkedHashSet集合特点：
底层是一个哈希表(数组+链表/红黑树)+链表：多了一条链表(记录元素的存储顺序)，保证元素有序

可变参数：是JDK1.5之后出现的新特性
使用前提：
当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数
使用格式：定义方法时使用
修饰符 返回值类型 方法名(数据类型...变量名){}
可变参数的原理：
可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数
传递的参数个数，可以是0个(不传递),1,2…多个
可变参数的注意事项：
1.一个方法的参数列表，只能有一个可变参数
2.如果方法的参数有多个，那么可变参数必须写在参数列表的末尾

public class Demo01VarArgs {
    public static void main(String[] args) {
        int i = add(12,12);
        System.out.println(i);
    }
    /*
    定义计算（0-n）整数和的方法
    已知：计算整数的和，数据类型已经确定int
    但是参数的个数不确定，不知道要计算几个整数的和，就可以使用可变参数
     */
    public static int add(int...arr){
        //System.out.println(arr);
        int sum = 0;
        for (int i : arr) {
            sum =  sum + i;
        }
        return sum;
    }
//    public static int add(int a,int b){
//        return a+b;
//    }
}

Collections 是集合工具类，用来对集合进行操作。部分方法如下
-public static <T> boolean addAll(Collection<T>c,T...elements):往集合中添加一些元素
-public static void shuffle(List<?> list) 打乱集合顺序

public static void sort(List list) 对集合进行排序，默认为升序
注意：
sort使用前提
被排序的集合里边存储的元素，必须实现Comparable，重写接口中的方法compareTo定义排序的规则

Comparable接口的排序规则：
自己(this)-参数:升序

public static void sort(List list, Comparator<? super T>):将集合中元素按照指定规则排序

Comparator和Comparable的区别
Comparable:自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判，比较两个

Comparator规则：
o1-o2 升序，反之降序