2019-9-25【Javase】集合：set、map、queue

最新推荐文章于 2021-05-07 12:16:01 发布
最新推荐文章于 2021-05-07 12:16:01 发布
阅读量723 收藏
点赞数
分类专栏： Javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45505750/article/details/101380989
版权
本文深入探讨了Java集合框架中的Set集合，包括HashSet和TreeSet的原理、应用及其区别。同时，简单介绍了队列的概念，并对Collections接口进行了讲解。此外，详细阐述了Map接口的特性，如HashMap、LinkedHashMap和TreeMap的区别，强调了它们的存储方式、排序和对null键值的支持情况。
摘要由CSDN通过智能技术生成

文章目录

一、Set集合

在这里插入图片描述
Set 接口 集 ： 数据是唯一存储，无序的。
HashSet实现类：
底层 数据结构 哈希表。

1.HashSet

在这里插入图片描述

数组 + 链表 + 二叉树。

原理:

在这里插入图片描述

原码:

        /*
         * new HashSet:
         * 加载因子:
         *  static final float DEFAULT_LOAD_FACTOR = 0.75f; 
         *  
         *  数组的初始容量： 16
         *   static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
         *  二叉树节点临界值:
         *  static final int TREEIFY_THRESHOLD = 8;
         *   
         */
        HashSet<String> set = new HashSet<>();
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
    }
}
        Set<String> set = new HashSet<>();
        set.add("ab");
        set.add("ac");
        set.add("ba");
        System.out.println(set);// [ab, ac, ba]
        set.add("ab");
        System.out.println(set);// [ab, ac, ba]

重写：hashCode和equals()方法：

class Student{
    private int no;
    private String name;
    public Student(int no, String name) {
        this.no = no;
        this.name = name;
    }
    public int getNo() {
        return no;
    }
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return "Student [no=" + no + ", name=" + name + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + no;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)// guojing.equals(guojing)
            return true;
        if (obj == null)// guojing.equals(null)
            return false;
        if (this.getClass() != obj.getClass())//  guojing.equals("hello")
            return false;
        Student other = (Student) obj;// 
        if (no != other.no)
            return false;
        return true;
    }
    
/*  @Override
    public int hashCode() {
        return no;
    }
    @Override
    public boolean equals(Object obj) {
        //  只要学号相同 那么 就返回 true
        // this.no    (Student)obj .no
        Student stu = (Student)obj;// 
        return this.no == stu.no;
    }*/
    
}
public class TestHashSet1 {
​
    public static void main(String[] args) {
        Set<Student> set = new HashSet<>();
        Student guojing = new Student(11, "郭靖");
        Student yangkang = new Student(11, "郭靖");
        Student huangrong = new Student(22, "黄蓉");
        set.add(guojing);
        set.add(yangkang);
        set.add(huangrong);

    //信息
        set.forEach(System.out::println);
        
        
​
    }
​}

2、TreeSet

在这里插入图片描述

基本应用：

   public static void main(String[] args) {
        // 默认： 自然升序排序 Comparable
//      Set<String> set = new TreeSet<>();
        // Comparator
        Set<String> set = new TreeSet<>((s1,s2)->s2.compareTo(s1));
        set.add("aa");
        set.add("cc");
        set.add("bb");
//      System.out.println(set);// [aa, bb, cc]
        System.out.println(set);// [cc, bb, aa]
​
    }

底层:二叉树

树:由分支关系组成的层次结构。

在这里插入图片描述

去重：

class Employee implements Comparable<Employee>{
    private int no;
    private String name;
    private int age;
    public Employee(int no, String name, int age) {
        super();
        this.no = no;
        this.name = name;
        this.age = age;
    }
    public int getNo() {
        return no;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "Employee [no=" + no + ", name=" + name + ", age=" + age + "]";
    }
    @Override
    public int compareTo(Employee o) {
        //  按照年龄  升序
        int n = this.age - o.age;
        if( n == 0)
            return this.no - o.no;
        return n;
    }
    
}
public class TestTreeSet1 {
​
    public static void main(String[] args) {
        Set<Employee> set = new TreeSet<>();
        Employee guojing = new Employee(11, "郭靖", 20);
        Employee yangkang = new Employee(33, "杨康", 20);
        Employee huangrong = new Employee(22, "黄蓉", 20);
        set.add(guojing);
        set.add(yangkang);
        set.add(huangrong);
        // -----------------------------
        
   set.forEach(System.out::println);
    }
​
}

3.区别

HashSet :底层 哈希表。
hashCode() ,equals() 重写自己去重。
唯一，无序。
LinkedHashSet: 底层 链表。
唯一，有序，添加的顺序维护。
TreeSet: 底层 二叉树。
唯一，有序，默认 Comparable自然排序，自己定制顺序Comparator .

HashSet > LinkedHashSet>TreeSet
        // 无序
//      Set<String> set = new HashSet<>();
//      Set<String> set = new LinkedHashSet<>();
        Set<String> set = new TreeSet<>((s1,s2)->s2.compareTo(s1));
        set.add("aa");
        set.add("bb");
        set.add("ab");
        set.add("cc");
        
//      System.out.println(set);// [aa, bb, cc, ab] HashSEt
        //-------------顺序--------------------------------
        // 元素添加的顺序
//      System.out.println(set); // [aa, bb, ab, cc] LinkedHashSet
        // 自己定制顺序
//      System.out.println(set);// [aa, ab, bb, cc] 默认 Comparable顺序
        System.out.println(set);// [cc, bb, ab, aa] Comparator降序

二、队列

在这里插入图片描述

  public static void main(String[] args) {
        // 创建了一个队列
//      Queue<String> q = new ArrayDeque<>();
        Queue<String> q = new LinkedList<>();
        // 入队
        q.add("aa");// 添加成功true ,失败 异常
        q.add("bb");
        q.offer("cc");// 添加成功true,失败 false;
        // 要求：队列 不允许 添加null值。但是有个特殊的可以添加null值得LinkedList
        q.add(null);// java.lang.NullPointerException 
        System.out.println(q);// [aa, bb, cc]
        // 出队
//      System.out.println(q.remove());// aa 删除成功返回元素，失败异常
//      System.out.println(q.remove());// bb
//      System.out.println(q.poll());// cc 删除成功返回元素，失败 null
        // 循环出队
        while(q.size() > 0) {
            System.out.println(q.poll());
        }
        
   // 获得队头元素（获取并不删除）
//      System.out.println(q.element());// aa 获得成功 返回元素，失败异常
//      System.out.println(q.peek());// aa 获得成功返回元素，失败 null
//      System.out.println(q.size());// 0
​
    }

三、Collections

在这里插入图片描述

   public static void main(String[] args) {
        //                       LinkedList
        List<String> list = new ArrayList<>();
        // 添加
        list.add("aa");
        list.add("cc");
        // 向集合中添加多个元素
        Collections.addAll(list, "bb","dd","ee");
        System.out.println(list);// [aa, cc, bb, dd, ee]
        // 1. 排序：自然升序 Comparable  List
        Collections.sort(list);
        System.out.println(list);// [aa, bb, cc, dd, ee]
        // 2.  List
//      Collections.sort(list, (s1,s2)->s2.compareTo(s1));
//      System.out.println(list);// [ee, dd, cc, bb, aa]
        // 3. 二分查找：前提升序排序 存在 返回正数  （索引),不存在返回 -插入点-1
        System.out.println(Collections.binarySearch(list, "cc"));// 2
        // 4. 集合中最大的元素
        System.out.println(Collections.max(list));// ee
        // 5。 集合中最小的元素
        System.out.println(Collections.min(list));// aa
        // 6.  List  反转集合元素
        Collections.reverse(list);//  [ee, dd, cc, bb, aa]
        // 7. 获得 第二个参数元素 在集合中出现的次数 
        
        System.out.println(Collections.frequency(list, "aa"));// 1
        Collections.addAll(list, "aa","aa");// [ee, dd, cc, bb, aa, aa, aa]
        System.out.println(Collections.frequency(list, "aa"));// 3
        // 8. 用第二个元素 替换掉集合中的 所有元素
        Collections.fill(list, "hello");// [hello, hello, hello, hello, hello, hello, hello]
        System.out.println(list);
        
    }

四、Map

在这里插入图片描述
Map接口： 映射。 双列存储。
key/value
键/值 对
键是唯一的，值是可以重复的。

在这里插入图片描述

public static void main(String[] args) {
    // 编号/数据
    Map<Integer,String> map = new HashMap<>();
    // 添加元素
    map.put(11, "aa");
    map.put(22, "bb");
    map.put(33, "cc");
    System.out.println(map);// {33=cc, 22=bb, 11=aa}
    // 1. 键值对 的个数
    System.out.println(map.size());// 3
    // 2.
    System.out.println(map.isEmpty());// false
    // 3. 是否存在指定的键
    System.out.println(map.containsKey(11));// true
    // 4。 是否存在指定的值
    System.out.println(map.containsValue("cc"));// true
    // 5. 删除指定的键对应的键值对信息
    map.remove(33);
    System.out.println(map);// {22=bb, 11=aa}
    // 6. 获取键的集合，Set 唯一
    System.out.println(map.keySet());// [22, 11]
    // 7. 获得值得集合,Collection
    System.out.println(map.values());// [bb, aa]
    // 8. 清空集合
    map.clear();
    System.out.println(map.isEmpty());// true
    System.out.println(map.size());// 0
}

注意：

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 编号/数据
        Map<Integer,String> map = new HashMap<>();
//      Map<Integer,String> map = new LinkedHashMap<>();
//      Map<Integer,String> map = new TreeMap<>();
        // 添加元素
        map.put(11, "aa");
        map.put(22, "bb");
        map.put(33, "cc");
        System.out.println(map);//{33=cc, 22=bb, 11=aa}
        map.put(null, null);// HashMap,LinkedHashMap支持
//      map.put(11, "aa");// {null=null, 33=cc, 22=bb, 11=aa} 键是唯一得
        map.put(11, "hello");// {null=null, 33=cc, 22=bb, 11=hello} 键冲突，会用新得值替换旧的值
        System.out.println(map);
        
        
    }

Map得遍历:

    public static void main(String[] args) {
​
        Map<Integer,String> map = new HashMap<>();
        // 添加元素
        map.put(11, "aa");
        map.put(22, "bb");
        map.put(33, "cc");
        System.out.println(map);// {33=cc, 22=bb, 11=aa}
        // 遍历集合元素
        // 1. 集合得forEach
        map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer t, String u) {
                System.out.println(t + "," + u);
            }
            
        });
        // Lambda
        map.forEach((k,v)->System.out.println(k + ":" + v));
        // 2. Iterator
        // 1) 分别遍历
        map.keySet().iterator().forEachRemaining(System.out::println);
        map.values().iterator().forEachRemaining(System.out::println);
        // 2) map.entrySet() 获得得是键值对Entry得集合 ，类型Set
        map.entrySet().iterator().forEachRemaining(e->{System.out.println(e.getKey()+","+e.getValue());});
        
    }

Map区别:

HashMap: 键唯一，速度快。
无序的。
支持 null键 和null值。
LinkedHashMap: 键唯一，有序，按照元素添加的顺序维护的。
支持 null键 和null值。
TreeMap: 键唯一，有序，自己定制顺序，Comparator定制顺序（键）
不支持null键 和null值。

HashMap > LinkeHashMap > TreeMap

十日十人羽
关注
专栏目录
JavaSE Set接口（HashSet、LinkedHashSet、TreeSet）
Lv Zejiang
08-10 1505
Java自我学习路线一、HashSet概述二、HashSet的构造方法1. 无参构造方法2. 有参构造方法三、HashSet常用方法1. add方法2. remove方法四、LinkedHashSet概述 一、HashSet概述 继承关系： HashSet->AbstractSet->AbstractCollection->Collection->Iterable(接口) HashSet是Java集合Set的一个实现类，Set是一个接口，其实现类除HashSet之外，还有TreeS
10【List、Set、Queue】
緑水長流*z
08-03 3878
一、List集合 1.1 List集合概述 List接口是单列集合的一个重要分支，下面主要有两个实现 ArrayList和LinkedList，List类型接口的特点是存储的元素是有序的，即存放进去是什么顺序，取出来还是什么顺序，也就是基于线性存储，可以看作是一个可变数组； List接口特点： List接口存储的数据是有序排列的，原来存储的时候是什么顺序，取出来就什么顺序（Set接口存储的是无序的）； List接口为存储的每一个元素都分配了一个索引，通过索引我们可以精确的来访
asp.net 在线影院欣赏系统
05-26
系统功能模块 1、后台管理模块： 该模块主要功能是对电影进行的添加，删除，修改和电影类型的增删改。 2、前台管理模块 该模块的主要功能是观看浏览电影的信息。 系统环境：Windows XP SP3 软件平台：Visual Studio 2005 Macromedia Dreamweaver 8 数 据 库：SQL 2000 开发技术：ASP.NET
golang 自定义Set 及 使用
魏菱延的博客
06-11 6053
定义 package MyDataType import ( "fmt" ) var Exists = struct{}{} //set类型 type Set struct { // struct为结构体类型的变量 m map[interface{}]struct{} } // 定义非空结构体 type S struct { a uint16 b uint32 } //返回一个...
es6--Set实现交集、差集、并集
少油少盐不要辣
06-15 1208
let arr1 = [1,2,3]; let arr2 = [2,3,4,5]; // 交集 let newArr1 = arr1.filter((ele) => { return new Set(arr2).has(ele); }) console.log('交集--', newArr1); // 差集 let newArr...
鲲鹏泰山（arm）服务器搭建ambari
qq_40988607的博客
07-20 6232
鲲鹏搭建ambari以及项目部署说明 华为鲲鹏泰山为arm芯片的服务器，市面上现在x86比较多。导致许多x86软件包在鲲鹏服务器上装不上。 此文章是鲲鹏arrch64上搭建ambari详细步骤； 注意：cdh没有arm的包。倒是可以参照华为软件栈的文档去迁移。
java源码知乎-JavaSE:JavaSE知乎专栏源代码，知乎专栏：https://zhuanlan.zhihu.com/javase
05-24
- **List、Set、Queue与Map**：掌握ArrayList、LinkedList、HashSet、TreeSet、LinkedList、PriorityQueue、HashMap、TreeMap等接口和类的用法。 - **泛型**：理解泛型的作用，以及如何在集合中使用泛型来提高代码...
旺旺老师JavaSE教程：集合框架与类对象解析
Java集合框架包括接口（如List、Set、Queue等）和实现这些接口的类（如ArrayList、HashSet、LinkedList等）。这个框架使得程序员能够高效地处理各种类型的对象集合，无论是列表、集合并集还是队列。 旺旺老师的教程...
Java 深入学习（1） —— 容器类（集合类）Set、List、Queue、Map 之间的区别
HeatDeath的博客
11-28 895
容器类大致分类示意图（非精确分类）（绿色表示 interface，蓝色表示 class）容器类类库划分1、 Collection。一个独立元素的序列。这些元素都服从一条或多条规则。List 必须按照插入顺序保存元素 Set 不能有重复元素 Queue 按照排队规则来确定对象产生的顺序所有 Collection 都可以使用 foreach 遍历 Collection 在每个“槽”中只能保存一个元素Co
狂神说--javase09--集合框架
Mar.三月
05-07 898
java给我们封装好了很多的类，集合在以后的开发很常用。 目前狂神老师还没有推出此类课程，我自己来学学
java中的set_Java中的Set集合类
weixin_39677027的博客
02-12 333
1. 概述Java中的Set和正好和数学上直观的集(set)的概念是相同的。Set最大的特性就是不允许在其中存放的元素是重复的。根据这个特点，我们就可以使用Set这个接口来实现前面提到的关于商品种类的存储需求。Set 可以被用来过滤在其他集合中存放的元素，从而得到一个没有包含重复新的集合。2. 常用方法按照定义，Set 接口继承 Collection 接口，而且它不允许集合中存在重复项。所有原始方...
JAVASE
weixin_45277567的博客
10-23 715
javaSE 进制&字节&DOS命令&Jvm 进制 计算机中的数据不同于人们生活中的数据，人们生活采用十进制数，而计算机中全部采用二进制数表示，它只包含 0、1两个数，逢二进一，1+1=10。每一个0或者每一个1，叫做一个bit（比特）。 字节 字节是我们常见的计算机中最小存储单元。计算机存储任何的数据，都是以字节的形式存储，右键点击文件属性， 我们可以查看文件的字节大小。 8个bit（二进制位） 0000-0000表示为1个字节，写成1 byte或者1 B。 位（bit）：一个
JavaSE基础———Set接口中的常用类HashSet、LinkedHashSet和TreeSet
zhupup
11-09 509
1. HashSet 集合    （1）HashSet 的概述      HashSet 的底层数据结构是哈希表（哈希表是一个元素为链表的数组）。HashSet 不是线程安全的，集合元素可以是null。当向HashSet 中存入一个元素时，HashSet 会调用该对象的HashCode()方法来得到该对象的HashCode值，然后根据HashCode值决定该对象在HashSet 中的存储位置。  ...
Python_Set集合
宿先生的暖被窝
07-03 4974
1.
Java集合之Set概述及内外比较器详解
小小默：进无止境
11-18 2169
Set接口是Collection的子接口，set接口没有提供额外的方法Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals 方法map中的所有key，即为一个set；所有value，即为一个collection。1.Set实现类之一：HashSet2.hashCode() 方法3......
JavaSE十二（Set）
qq_46002941的博客
10-19 1651
文章目录Set3.1 Set集合的概述和特点3.2 哈希值3.3 HashSet集合的概述和特点3.4 HashSet集合保证元素唯一性源码分析3.5 常见数据结构之哈希表案例：HashSet集合存储学生对象并遍历3.6 LinkedHashSet集合概述和特点3.7 TreeSet集合概述和特点3.8 自然排序Comparator的使用3.9 比较器Comparator排序的使用案例：成绩排序案例：不重复的随机数 Set 3.1 Set集合的概述和特点 Set集合的特点 不包含重复元素的集合 没有带索引
golang set 做差集，交集，并集
YMY_mine的博客
08-01 2618
package main import ( "fmt" "reflect" "gopkg.in/fatih/set.v0" ) /*set并集 交集 差集计算示例*/ func main() { a := set.New(set.ThreadSafe) c := 8 a.Add(1) a.Add(2) a.Add(3) a.Add(c) b := set.New(s...
golang header.Set与header.Add区别
weixin_30498807的博客
07-30 3721
req.Header.Set("User-Agent","自定义的浏览器") req.Header.Set("User-Agent","自定义的浏览器3") 当我们使用Set时候，如果原来这一项已存在，后面的就修改已有的。所以这里最终的结果就是自定义的浏览器3 req.Header.Add("User-Agent","自定义的浏览器") req.Header.Add...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值