Set集合

1.HashSet集合

java. util.Set接口extends Collection接口
Set接口的特点:

1. 不允许存储重复的元素
2. 没有索引，没有带索引的方法,也不能使用普通的for循环遍历

java. util. HashSet集合implements Set接口
HashSet的特点:

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

package cn.itcast.day11.demo07;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetMain {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(4);
        set.add(3);
        set.add(1);
        //使用迭代器遍历set集合
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            Integer n = it.next();
            System.out.println(n);
        }
        //使用增强for遍历set集合
        System.out.println("======================");
        for (Integer i : set) {
            System.out.println(i);

        }
    }

}

执行结果

1
2
3
4
==============
1
2
3
4

2. 哈希值

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

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

package cn.itcast.day11.demo07;

public class HashCodeMain {
    public static void main(String[] args) {
        //person类继承了Object类，所以可以使用Object类的hashcode方法
        Person p1 = new Person();
        int h1 = p1.hashCode();
        System.out.println(h1);

        Person p2 = new Person();
        int h2 = p2.hashCode();
        System.out.println(h2);

        System.out.println(p1);
        System.out.println(p2);


        //String 类的哈希值：String类重写object类的hashCode方法
        String s1 = new String("周冬雨");
        String s2 = new String("周冬雨");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

    }
}

执行结果

189568618
793589513
cn.itcast.day11.demo07.Person@b4c966a
cn.itcast.day11.demo07.Person@2f4d3709
21452068
21452068

3.HashSet集合存储数据的结构

HashSet集合存储数据的结构(哈希表)
jdk1.8版本之前:哈希表=数组+链表
jdk1.8版本之后:
哈希表=数组+链表;
哈希表=数组+红黑树(提高查询的速度)
哈希表的特点:速度快

4. set集合存储元素不重复的原理

package cn.itcast.day11.demo07;

import java.util.HashSet;

public class HashSetSaveString {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        String s1 = new String ("刘亦菲");
        String s2 = new String ("刘亦菲");
        set.add(s1);
        set.add(s2);
        set.add("重地");
        set.add("通话");
        set.add("刘亦菲");
        System.out.println(set);
    }
}

执行结果

[重地, 通话, 刘亦菲]

5. HashSet存储自定义类型元素

HashSet存储自定义类型元素

set集合报错元素唯一:
存储的元素(String, Integer,...Student, Person... ),必须重写hashCode方法和equals方法
要求:
同名同年龄的人，视为同- -个人,只能存储一次

学生类：重写了toString方法和Hashcode和Equals

package cn.itcast.day11.demo07;

import java.util.Objects;

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

    public Student(String 刘亦菲, String s) {
    }

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

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

    @Override
    public int hashCode() {
        return Objects.hash(name, 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;
    }
}

package cn.itcast.day11.demo07;

import java.util.HashSet;

public class HashSetStudent {
    public static void main(String[] args) {
        HashSet<Student> set = new HashSet<>();
        Student st1 = new Student("刘亦菲",20);
        Student st2 = new Student("刘亦菲",20);
        Student st3 = new Student("刘亦菲",19);
        System.out.println(st1.hashCode());
        System.out.println(st2.hashCode());
        set.add(st1);
        set.add(st2);
        set.add(st3);
        System.out.println(set);

    }

}

执行结果

646484529
646484529
[Student{name='刘亦菲', age=19}, Student{name='刘亦菲', age=20}]

6.LinkedHashSet集合

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

package cn.itcast.day11.demo07;

import java.util.HashSet;
import java.util.LinkedHashSet;

public class LinkedHashSetMain {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("www");
        set.add("abc");
        set.add("周冬雨");
        set.add("周冬雨");
        System.out.println(set);//无序，不允许重复
        System.out.println("================");
        LinkedHashSet<String> link = new LinkedHashSet<>();
        link.add("www");
        link.add("abc");
        link.add("周冬雨");
        link.add("周冬雨");
        System.out.println(link);//有序，不允许重复

    }
}

执行结果

[abc, 周冬雨, www]
================
[www, abc, 周冬雨]

7.可变参数

可变参数:是JDK1.5之后出现的新特性
使用前提:
当方法的参数列表数据类型已经确定 ,但是参数的个数不确定,就可以使用可变参数。

使用格式:定义方法时使用
修饰符 返回值类型方法名(数据类型.. .变量名){}

可变参数的原理:
可变参数底层就是一个数组,根据传递参数个数不同，会创建不同长度的数组,来存储这些参数
传递的参数个数。可以是0个(不传递).1,2…多个

定义计算(0-n)整数和的方法
已知:计算整数的和，数据类型已经确定int
但是参数的个数不确定,不知道要计算几个整数的和,就可以使用可变参数
add();就会创建一-个长度为的数组，new int[0]
add(10);就会创建- - -个长度为1的数组，存储传递来过的参数new int[]{10};
add(10, 20);就会创建一个长度为2的数组,存储传递来过的参数new int[ ]{10,20};

package cn.itcast.day11.demo07;

public class VarPermater {
    public static void main(String[] args) {
        add(12,34,21);
        add(1,2,3,4,5,6);
    }


    public static int add(int...array){
        int sum = 0;
        for (int i : array) {
            sum += i;
        }
        System.out.println(sum);
        return sum;
    }
}

执行结果

67
21

可变参数的注意事项

1. 一个方法的参数列表，,只能有一个可变参数
2. 如果方法的参数有多个,那么可变参数必须写在参数列表的末尾