Set、HashSet、LinkedHashSet、可变参数

最新推荐文章于 2024-01-27 09:30:00 发布
原创 最新推荐文章于 2024-01-27 09:30:00 发布 · 201 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #算法 #set #hash

本文详细介绍了Java中的Set接口及其常见实现类如HashSet和LinkedHashSet。讲解了Set接口的特点，如不允许存储重复元素，无索引等，并通过示例展示了HashSet如何利用哈希表存储元素。此外，还探讨了自定义类型元素在HashSet中的存储原理，强调了重写equals和hashCode方法的重要性。最后提到了LinkedHashSet的有序特性以及Java的可变参数（varargs）用法。

目录

Set

1.概述：

        java.util.Set接口 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 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);//不允许存储重复的元素，所以这个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);
        }
    }
}

2.Set集合存储元素不重复的原理：

在这里插入图片描述

哈希值

哈希值：是一个十进制的整数，由系统随机给出(就是对象的地址值，是一个逻辑地址，是模拟出来得到地址，不是数据实际存储的物理地址)

        在Object类有一个方法，可以获取对象的哈希值
        int hashCode() 返回该对象的哈希码值。
        hashCode方法的源码：
                public native int hashCode();
                native：代表该方法调用的是本地操作系统的方法

public class Person extends  Object{
    //重写hashCode方法

    @Override
    public int hashCode() {
        return  1;
    }
}

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);//1967205423  | 1（覆盖重写之后的哈希值）

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

        /*
           // toString方法的源码:
           //return getClass().getName() + "@" + Integer.toHexString(hashCode());
         */
        System.out.println(p1);//com.itheima.demo03.hashCode.Person@75412c2f
        System.out.println(p2);//com.itheima.demo03.hashCode.Person@282ba1e 
                                        //（282ba1e 与上面的42121758相同，但42121758是十进制的整数）
        System.out.println(p1==p2);//false

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

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

哈希表

JDK1.8版本之后：
        哈希表=数组+链表；
        哈希表=数组+红黑树（提高查询的速度）

        哈希表的特点：速度快

在这里插入图片描述

用HashSet存储自定义类型元素

import java.util.Objects;

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

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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 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;

/*
    HashSet存储自定义类型元素

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

    要求:
        同名同年龄的人,视为同一个人,只能存储一次
 */
public class Demo03HashSetSavePerson {
    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());//1967205423
        System.out.println(p2.hashCode());//42121758//产生不同的哈希值是因为没有重写类中的
                                            //hashCode()的方法

        System.out.println(p1==p2);//false
        System.out.println(p1.equals(p2));//false//没有重写equals方法
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set);
    }

}

LinkedHashSet集合

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

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

public class Demo04LinkedHashSet {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("www");
        set.add("abc");
        set.add("abc");
        set.add("ccc");
        System.out.println(set);//[abc, www, ccc] 无序,不允许重复

        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("www");
        linked.add("abc");
        linked.add("abc");
        linked.add("itcast");
        System.out.println(linked);//[www, abc, itcast] 有序,不允许重复
                                    //使得插入与打印的顺序一致。
    }
}

可变参数

        可变参数：是JDK1.5之后出现的新特性

        使用前提:
                当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数.

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

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

public class Demo01VarArgs {
    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); 就会创建一个长度为2的数组,存储传递来过的参数 new int[]{10,20,30,40,50,60,70,80,90,100};
     */
    public static int add(int...arr){
        //System.out.println(arr);//[I@2ac1fdc4 底层是一个数组
        //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;
    }*/
}
Set集合-可变参数-Collections工具类
好好学习
07-20 446
Set java.util.Set接口 extends Collection接口 Set接口的特点：不允许存储重复的元素，没有索引，没有带索引的方法，也不能使用普通的for循环进行遍历 java.util.HashSet集合，implements Set接口 HashSet特点： 1、不允许存储重复的元素 2、没有索引，没有带索引的方法，也不能使用普通的for循环遍历 3、是一个无序的集合，存储元素和取出元素的顺序可能不一致 4、底层是一个哈希表结构（查询的速度非常的快） public class Demo
Java Set系列集合（Collections集合工具类、可变参数）
weixin_47138646的博客
02-28 1293
Set系列集合特点无序：存取顺序不一致不重复：可以去除重复无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。Set集合实现类特点HashSet : 无序、不重复、无索引。LinkedHashSet：有序、不重复、无索引。TreeSet：排序、不重复、无索引。Set集合的功能上基本上与Collection的API一致。//一行经典代码︰无序 不重复 无索引 // set sets = new LinkedHashSet();
LinkedHashSet
A_Zeng_的博客
12-28 1804
概述： ​ 他是Set集合典型实现类HashSet的子类，继承了set集合的所有功能和特点，同时把其中的重要特点给修改，把无序变为有序。 特点： ​ 1、有序 ​ 2、无索引 ​ 3、元素不可重复 使用场景： ​ 去重的同时可以保证元素的有序 代码示例 import java.util.LinkedHashSet; public class LinkedHashSetDemo { public static void main(String[] args) { //创建LinkedHashSet对象
LinkedHashSet实现原理分析
CoderLife9192的专栏
10-02 570
http://wiki.jikexueyuan.com/project/java-collection/linkedhashset.html LinkedHashSet 概述 思考了好久，到底要不要总结 LinkedHashSet 的内容 = = 我在之前的博文中，分别写了 HashMap 和 HashSet，然后我们可以看到 HashSet 的方法基本上都是基于 Hash
HashSet和LinkedHashSet的区别
最新发布
不安分的猿人的专栏
01-27 824
不可变集合（Immutable Set）是一种特殊的集合，它的内容在创建后就不能再被修改。这意味着一旦一个不可变集合被创建，你就不能向其中添加、删除或更改任何元素。不可变集合在多线程环境中非常有用，因为它们本质上是线程安全的，可以在多个线程之间共享而无需额外的同步。使用方法：这个方法接受一个现有的集合作为参数，并返回一个不可修改视图。需要注意的是，这并不会创建一个新的集合，而只是返回了一个不可修改的视图。如果原始集合在创建不可修改视图后被修改，那么这些修改也会反映在不可修改视图中。
java set泛型_Java中的Set集合，泛型，可变参数
05-26
同时，Java中的Set集合也支持可变参数，我们可以使用以下方式来添加多个元素： ``` set.addAll("a", "b", "c"); ``` 这样就可以将a、b、c三个元素添加到set集合中。 需要注意的是，由于Set集合不允许重复元素，...
Java基础（21）asList()方法、集合嵌套、Set集合、HashSet集合、LinkedHashSet集合、TreeSet集合
nswzr的博客
05-18 892
1. asList()方法 1. Arrays工具类的asList(T … t)方法的使用：将数组转化成集合 2. 传进来基本类型数组和引用类型数组的差别 public class TestDemo01 { public static void main(String[] args) { //传入引用类型 List<String> strings = Arrays.asList("abc", "def", "ghi", "jkl"); L
Java LinkedHashSet
Damon Liu的博客
02-27 382
public class LinkedHashSet extends HashSet implements Set, Cloneable, java.io.Serializable 首先,从上面代码可以看出,LinkedHashSet是HashSet的一个子类,并且实现了Set接口,Cloneable接口和Serializable接口. LinkedHashSet和
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是哈猿啊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值