Set集合使用

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

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class demoSet {
    public static void main(String[] args) {
        Set<Integer> set=new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(1);
        System.out.println(set);
        Iterator<Integer> it=set.iterator();
        while (it.hasNext()){
            Integer a=it.next();
            System.out.println(a);
        }
        System.out.println("===");
        for (Integer i : set) {
            System.out.println(i);
        }
    }
}

HashSet存储自定义元素
set集合报错元素唯一；
存储的元素（String,Integer,Student,Person)必须重写方法和equals方法
要求：同名同年龄视为同人，只能存储一次
创建一个Person类

import java.util.Objects;

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

    @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 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;
    }
}

import java.util.HashSet;
public class demoHashSet {
    public static void main(String[] args) {
        HashSet<Person> hashSet=new HashSet<>();
        Person p1=new Person("小美女",18);
        Person p2=new Person("小美女",18);
        Person p3=new Person("小美女",19);
        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);
        System.out.println(hashSet);
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p1==p2);
        System.out.println(p1.equals(p2));
    }
}

LinkedHashSet与HashSet区别

java.util.LinkedHashSet集合extends HashSet集合
LinkedHashSet集合特点；底层是一个哈希表（数组+链表/红黑树）+链表；多了一条链表（记录元素的顺序）
保证元素的有序性

import java.util.HashSet;
import java.util.LinkedHashSet;
public class demoLinkedhashSet {
    public static void main(String[] args) {
        HashSet<String> hs=new HashSet<>();
        hs.add("aaa");
        hs.add("bbb");
        hs.add("ccc");
        hs.add("aaa");
        System.out.println(hs);//无序
        LinkedHashSet<String> hs1=new LinkedHashSet<>();
        hs1.add("aaa");
        hs1.add("bbb");
        hs1.add("ccc");
        hs1.add("aaa");
        System.out.println(hs1);//有序
    }
}

可变参数

可变参数使用前提：当方法的参数列表数据类型已经确定，但是参数个数不确定就可以使用可变参数
使用格式：定义方法时使用：修饰符 返回值类型 方法名（数据类型…变量名）{}
可变参数的原理：可变参数底层就是一个数组，根据传递参数个数的不同会创建不同长度的数组来存储这些
参数，传递参数的个数可以时0个，1，2，3，，，，多个
可变参数最终写法：修饰符 返回值类型 方法名（Object…变量名）
注意事项：1、一个方法的参数列表只能有一个可变参数
2、如果方法的参数有多个，那么可变参数必须写在参数列表末尾
如错误1 public static void method（int…a,String…b）是错误的，只能有一个可变参数

public class demoVarArgs {
    public static void main(String[] args) {
        int i=add(10,20,30,40);
        System.out.println(i);
        method(1,"asd",1,2,3,3);//如果方法的参数有多个，那么可变参数必须写在参数列表末尾
        method2(1,"asd",1.2);
    }
    /*定义一个方法，计算几个int类型整数和
    add();就会创建一个长度为0的数组，new int[0]
    add(10);就会创建一个长度为1的数组，new int[1]
    add(10,20);就会创建一个长度为2的数组，new int[2]*/
    public static int add(int...arr){
        System.out.println(arr);
        System.out.println(arr.length);
        int sum=0;
        for(int i:arr){
            sum+=i;
        }
        return 0;
    }
    public static void method(int a,String b,int...arr){}
    public static void method2(Object...a){}
}