从0学开发笔记-Set接口

1. HashSet集合介绍

package cn.itcast.demo01;

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

/*
    java.util.Set接口 extends Collection接口
    Set接口的特点：
        1. 不允许存储重复的元素
        2. 没有索引，没有带索引的方法，也不能使用普通的for循环
    java,util,HashSet集合 implements Set接口
    HashSet特点：
        1. 不允许存储重复的元素
        2. 没有索引，没有带索引的方法，也不能使用普通的佛如循环遍历
        3. 是一个无序的集合，存储元素和取出元素的顺序有可能不一致
        4. 底层是一个哈希表结构（查询速度非常快）
 */
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(1);
        System.out.println(set);
        //使用迭代器遍历set集合
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            Integer n = it.next();
            System.out.println(n);
        }//1,2,3
        //增强for循环
        for (Integer integer : set) {
            System.out.println(integer);

        }

    }
}

2. 哈希值

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

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

        /*
            toString 方法的源码：
                return getClass().getName()+"@"+Integer.toHexString(hashCode());
         */
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p1==p2);

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

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


    }
}

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

3. Set集合存储元素不重复原理

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

package cn.itcast.demo01;

import java.util.HashSet;

/*
    hashSet存储自定义类型

    set集合报错唯一元素：
        存储的元素(String,Integer,...,Student,Person),必须重写hashCode方法和equals方法

    要求：
        同名同年龄的人，视为同一个人，只能存储一次
 */
public class Demo03HashSavePerson {
    public static void main(String[] args) {
        //创建HashCode集合存储Person
        HashSet<Person01> set = new HashSet<>();
        Person01 p1 = new Person01("小美女",18);
        Person01 p2 = new Person01("小美女",18);
        Person01 p3 = new Person01("小美女",19);
        System.out.println(p1.hashCode());//重写hashcode和equals前：1967205423、重写hashcode和equals后：734175839
        System.out.println(p2.hashCode());//重写hashcode和equals前：42121758重写hashcode和equals后：734175839

        System.out.println(p1==p2);//重写hashcode和equals前：false 重写hashcode和equals后：false
        System.out.println(p1.equals(p2));//重写hashcode和equals前：false 重写hashcode和equals后：true

        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set);//重写hashcode和equals前：p1 p2相同装进去了 重写hashcode和equals后：装不进去了

    }

}

package cn.itcast.demo01;

import java.util.Objects;

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

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

    public Person01() {
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person01 person01 = (Person01) o;
        return age == person01.age &&
                Objects.equals(name, person01.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

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

5.LinkedHashSet集合

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

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

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

        LinkedHashSet linked = new LinkedHashSet();
        linked.add("www");
        linked.add("abc");
        linked.add("abc");
        linked.add("itcast");
        System.out.println(linked);



    }
}

6. 可变参数

package cn.itcast.demo02;
/*
    可变参数：是JDK1.5之后出现的新特性
    使用前提：
        当方法的参数列表数据类型已经确定，但是参数个数不确定，就可以使用可变参数
    使用格式：定义方法时使用
        修饰符 返回值类型 方法名（数据类型...变量名）{}
    可变参数的原理：
        可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数
        传递参数的个数，可以是0个（不传递），1，2，、、、多个
 */
public class Demo01VarArg {
    public static void main(String[] args) {
        //int i = add();
        //int i = add(10);
        int i = add(10,20);
        System.out.println(i);
    }
    /*
        可变参数的注意事项
            1.一个方法的参数列表，只能有一个可变参数
            2.如果方法的参数有多个，那么可变参数必须写在列表的末尾
     */

//    public static void method(int...a,String...b){错误写法
//
//    }

//    public  static void method(String a,double b,int...c){正确写法
//
//    }

    //可变参数的终极写法
//        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}
     */
    public static int add(int...arr){
        //System.out.println(arr);//[I@50cbc42f 底层是一个数组
        //System.out.println(arr.length);//0
        int sum = 0;
        //遍历数组，获取数组中的每一个元素（增强for循环）
        for (int i : arr) {
            //累加求和
            sum += i;
        }
        return sum;
    }
}