Java学习笔记⑰（HashSet集合介绍、哈希值、HashSet集合存储数据的结构、存储元素不重复的原理、HashSet集合存储自定义类型元素、LinkedHashSet集合、可变参数）

一、HashSet集合介绍

• java.util.Set接口 extends Collection 接口
• Set接口的特点：

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

• Java.util.HashSet集合 implements Set接口
• HashSet特点：

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

package day17.demo01;

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(3);
        set.add(2);
        set.add(1);
        //使用迭代器遍历set集合
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {
            Integer n= it.next();
            System.out.println(n);//1,2,3
        }
        //使用增强for循环遍历set集合
        System.out.println("=================");
        for (Integer i:set) {
            System.out.println(i);
        }
    }
}

运行结果：

二、哈希值

• 哈希值：是一个十进制的整数由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到地址，不是数据实际存储的物理地址）
• 在Object类有一个方法，可以获取对象的哈希值
• int hashCode() 返回该对象的哈希码值
• hashCode方法的源码：
  public native int hashCode();
  native：代表该方法调用的是本地操作系统的方法

package day17.demo01;

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

        Person p2 = new Person();
        int h2 = p2.hashCode();
        System.out.println(h2);//1313922862 | 1

        /*toString方法的源码：
            return getClass().getName()+"@"+Integer.toNextString(hashCode());
        */
        System.out.println(p1);//day17.demo01.Person@2f4d3709
        System.out.println(p2);//day17.demo01.Person@4e50df2e
        System.out.println(p1==p2);//false

        /*String类的哈希值
            String类重写Object类的hashCode方法
        */
        String s1=new String("abc");//96354
        String s2=new String("abc");//96354
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395
    }
}

package day17.demo01;

public class Person extends Object{
//重写HashCode方法
    @Override
    public int hashCode() {
        return 1;
    }
}

运行结果：

三、HashSet集合存储数据的结构

四、HashSet集合存储元素不重复的原理

五、HashSet集合存储自定义类型元素

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

package day17.demo02;

import java.util.HashSet;

public class HashSetSavePerson {
    public static void main(String[] args) {
        //创建HashSet集合存储Person
        HashSet<Person> set = new HashSet<>();
        Person p1 = new Person("小美女",18);
        Person p2 = new Person("小美女",18);
        Person p3 = new Person("小美女",19);
        System.out.println(p1.hashCode());//734175839
        System.out.println(p2.hashCode());//734175839

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

运行结果：

六、LinkedHashSet集合

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

package day17.demo02;

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

public class Demo02LinkedHashSet {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("www");
        set.add("abc");
        set.add("itcast");
        System.out.println(set);//[abc, www, itcast]

        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("www");
        linked.add("abc");
        linked.add("itcast");
        System.out.println(linked);//[www, abc, itcast]
    }
}

运行结果：

七、可变参数

• 可变参数：是JDK1.5之后出现的新特性
• 使用前提：当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数。
• 使用格式：定义方法时使用
  修饰符 返回值类型 方法名（数据类型…变量名）{}
• 可变参数的原理：
  可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数传递的参数个数，可以是0个（不传递），1,2…多个

package day17.demo02;

public class Demo02VarArgs {
    public static void main(String[] args) {
//        int i = add();
//        int i = add(10);
        int i = add(10,20);
//        int i = add(10,20,30,40,50,60,70,80,90,100);
        System.out.println(i);
        method("abc",5.5,10,1,2,3,4);
    }
    /*
          可变参数的注意事项
            1. 一个方法的参数列表，只能有一个可变参数
            2. 如果方法的参数有多个，那么可变参数必须写在参数列表的末尾
        */
    /*public static void method(int...a,String...b) {

        }*/
        /*public static void method(String b,double c,int d,int...a) {

        }*/
    //可变参数的特殊(终极)写法
    public static void method(Object...obj) {

    }
    /*定义计算(0-n)整数和的方法
        已知：计算整数的和，数据类型已经确定int
        但是参数的个数还不确定，不知道要计算几个整数的和，就可以使用可变参数
        add():就会创建一个长度为0的数组，new int[0]
        add(10):就会创建一个长度为1的数组，存储传递过来的参数 new int[] {10};
        add(10,20):就会创建一个长度为2的数组，存储传递过来的参数 new int[] {10,20};
        add(10,20,30,40,50,60,70,80,90,100):就会创建一个长度为10的数组，存储传递过来的参数 new int[] {10,20,30,40,50,60,70,80,90,100};
     */
    public static int add(int...arr) {
//        System.out.println(arr);//[I@b4c966a 底层是一个数组
//        System.out.println(arr.length);//0,1,2,10
        int sum = 0;
        //遍历数组，获取数组中的每一个元素
        for (int i:arr) {
            //累加求和
            sum +=i;
        }
        //把求和结果返回
        return sum;
    }
    //定义一个方法，计算三个int类型整数的和
    /*public static int add(int a,int b,int c) {
        return a+b+c;
    }*/
    //定义一个方法，计算两个int类型整数的和
    /*public static int add(int a,int b) {
        return a+b;
    }*/
}

运行结果：