当前位置:首页 > Java技术 > java集合的详解

java集合的详解

2022年08月05日 15:13:56Java技术2

一、集合的由来?

通常,我们的程序需要根据程序运行时才知道创建多少个对象。但若非程序运行,程序开发阶段,我们根本不知道到底需要多少个数量的对象,甚至不知道它的准确类型。为了满足这些常规的编程需要,我们要求能在任何时候,任何地点创建任意数量的对象,而这些对象用什么来容纳呢?我们首先想到了数组,但是数组只能放统一类型的数据,而且其长度是固定的,那怎么办呢?集合便应运而生了!

二、什么是集合?

1、集合都存放在java.util包中。

2、集合中存放的都是对象的引用,而非对象本身,出于表达上的便利,我们称集合中的对象就是指集合中对象的引用,而对象本身还是放在堆内存中。

3、集合可以存放不同类型,不限数量的数据类型。

4、集合类型主映要有3种:set(集)、list(列表)和map(射)。

5、集合接口分为:Collection和Map,list、set实现了Collection接口

三、集合框架图

java集合的详解 _ JavaClub全栈架构师技术笔记

四、集合详解

上述所有的集合类,除了 map 系列的集合,即左边集合都实现了 Iterator 接口,这是一个用于遍历集合中元素的接口,主要有hashNext(),next(),remove()三种方法。它的一个子接口 ListIterator 在它的基础上又添加了三种方法,分别是add(),previous(),hasPrevious()。也就是说如果实现 Iterator 接口,那么在遍历集合中元素的时候,只能往后遍历,被遍历后的元素不会再被遍历到,通常无序集合实现的都是这个接口,比如HashSet;而那些元素有序的集合,实现的一般都是ListIterator 接口,实现这个接口的集合可以双向遍历,既可以通过next()访问下一个元素,又可以通过previous()访问前一个 元素,比如ArrayList。

还有一个特点就是抽象类的使用。如果要自己实现一个集合类,去实现那些抽象的接口会非常麻烦,工作量很大。这个时候就可以使用抽象类,这些抽象类中给我们提供了许多现成的实现,我们只需要根据自己的需求重写一些方法或者添加一些方法就可以实现自己需要的集合类,工作量大大降低。

1、Iterator迭代器(接口)

(1)它是Java集合的顶层接口(不包括 map 系列的集合,Map接口 是 map 系列集合的顶层接口)

Object next():返回迭代器刚越过的元素的引用,返回值是 Object,需要强制转换成自己需要的类型

boolean hasNext():判断容器内是否还有可供访问的元素

void remove():删除迭代器刚越过的元素

所以除了 map 系列的集合,我们都能通过迭代器来对集合中的元素进行遍历。

(2)注意:我们可以在源码中追溯到集合的顶层接口,比如 Collection 接口,可以看到它继承的是类 Iterable

java集合的详解 _ JavaClub全栈架构师技术笔记

那这就得说明一下 Iterator 和 Iterable 的区别:

 Iterable :存在于 java.lang 包中。

java集合的详解 _ JavaClub全栈架构师技术笔记

我们可以看到,里面封装了 Iterator 接口。所以只要实现了只要实现了Iterable接口的类,就可以使用Iterator迭代器了。

Iterator :存在于 java.util 包中。

这里我们引用一个Iterator 的实现类 ArrayList 来看一下迭代器的使用:暂时先不管 List 集合是什么,只需要看看迭代器的用法就行了

        //产生一个 List 集合,典型实现为 ArrayList。
        List list = new ArrayList();
        //添加三个元素
        list.add("Tom");
        list.add("Bob");
        list.add("Marry");
        //构造 List 的迭代器
        Iterator it = list.iterator();
        //通过迭代器遍历元素
        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }

2、Collection集合(根接口)

List 接口和 Set 接口的父接口,他继承自接口Iterable

看一下 Collection 集合的使用例子:

        //我们这里将 ArrayList集合作为 Collection 的实现类
        Collection collection = new ArrayList();
        //添加元素
        collection.add("Tom");
        collection.add("Bob");
        //删除指定元素
        collection.remove("Tom");
        //删除所有元素
        Collection c = new ArrayList();
        c.add("Bob");
        collection.removeAll(c);
        //检测是否存在某个元素
        collection.contains("Tom");
        //判断是否为空
        collection.isEmpty();
        //利用增强for循环遍历集合
        for(Object obj : collection){
            System.out.println(obj);
        }
        //利用迭代器 Iterator
        Iterator iterator = collection.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }

3、List集合(接口)

(1) List 接口是继承于 Collection 接口,并且他是有序的,元素都有下标,能够精确的控制每个元素插入的位置,并且元素内容可以重复。

(2)List 接口的三个典型实现:

   ①、List list1 = new ArrayList();

  底层数据结构是动态数组,查询快,增删慢,线程不安全,效率高。

   ②、List list2 = new Vector();

  底层数据结构是动态数组,查询快,增删慢,线程安全,效率低,几乎已经淘汰了这个集合。

       *  vector的初始默认容量和增量都是10,可以通过他的构造方法来设置容量和增量,所谓的增量,就是在容量不够时,增加的量。

       *  vector的子类,栈的特点:先进后出,后进先出

      ③、List list3 = new LinkedList();

  底层数据结构是链表,查询慢,增删快,线程不安全,效率高,数据都存放在独立的内存空间中,而且在每个空间中还               保存下一个储存空间的地址。

怎么记呢?我们可以想象:

  数组就像身上编了号站成一排的人,要找第10个人很容易,根据人身上的编号很快就能找到。但插入、删除慢,要望某个位置插入或删除一个人时,后面的人身上的编号都要变。当然,加入或删除的人始终末尾的也快。

  链表就像手牵着手站成一圈的人,要找第10个人不容易,必须从第一个人一个个数过去。但插入、删除快。插入时只要解开两个人的手,并重新牵上新加进来的人的手就可以。删除一样的道理。

(3)除此之外,List 接口遍历还可以使用普通 for 循环进行遍历,指定位置添加元素,替换元素等等。

      //产生一个 List 集合,典型实现为 ArrayList
      List list = new ArrayList();
      //添加三个元素
      list.add("Tom");
      list.add("Bob");
      list.add("Marry");
      //构造 List 的迭代器
      Iterator it = list.iterator();
      //通过迭代器遍历元素
       while(it.hasNext()){
               Object obj = it.next();
               //System.out.println(obj);
           }
       //在指定地方添加元素
       list.add(2, 0);
       //在指定地方替换元素
       list.set(2, 1);
       //获得指定对象的索引
       int i=list.indexOf(1);
       System.out.println("索引为:"+i);
       //遍历:普通for循环
       for(int j=0;j<list.size();j++){
                System.out.println(list.get(j));
       }

4、Set集合(接口)

典型实现 HashSet(),元素没有下标,不保证存入和取出顺序一致,是一个无序的,不可重复的集合。

(1)Set hashSet = new HashSet();

  ①、HashSet:不能保证元素的顺序,不可重复,不是线程安全的,集合元素可以为 NULL。

  ②、HashSet的底层其实是一个数组,存在的意义是加快查询速度。我们知道在一般的数组中,元素在数组中的索引位置是随机的,元素的取值和元素的位置之间不存在确定的关系,因此,在数组中查找特定的值时,需要把查找值和一系列的元素进行比较,此时的查询效率依赖于查找过程中比较的次数。而 HashSet 集合底层数组的索引和值有一个确定的关系:index=hash(value),那么只需要调用这个公式,就能快速的找到元素或者索引。

③、对于 HashSet,如果两个对象通过 equals() 方法返回 true,这两个对象的 hashCode 值也应该相同。

④、当向HashSet集合中存入一个元素时,HashSet会先调用该对象的hashCode()方法来得到该对象的hashCode值,然后根据hashCode值决定该对象在HashSet中的存储位置。

*  如果 hashCode 值不同,直接把该元素存储到 hashCode() 指定的位置

*  hashCode 值相同,那么会继续判断该元素和集合对象的 equals() 作比较

*  hashCode 相同,equals 为 true,则视为同一个对象,不保存在 hashSet()中

*  hashCode 相同,equals 为 false,则存储在之前对象同槽位的链表上,这非常麻烦,我们应该约束这种情况,即保证:如果两个对象通过 equals() 方法返回 true,这两个对象的 hashCode 值也应该相同。

注意:每一个存储到哈希表中的对象,都得提供 hashCode() 和 equals() 方法的实现,用来判断是否是同一个对象。

   对于 HashSet 集合,我们要保证如果两个对象通过 equals() 方法返回 true,这两个对象的 hashCode 值也应该相同。

常见的 hashCode()算法:

java集合的详解 _ JavaClub全栈架构师技术笔记

(2)Set linkedHashSet = new LinkedHashSet();

   LinkedHashSet:不可以重复,有序,因为底层采用 链表 和 哈希表的算法。链表保证元素的添加顺序,哈希表保证元素的唯一性。

(3)Set treeSet = new TreeSet();

TreeSet:有序;不可重复,底层使用 红黑树算法,擅长于范围查询。

①、如果使用 TreeSet() 无参数的构造器创建一个 TreeSet 对象, 则要求放入其中的元素的类必须实现 Comparable 接口所以, 在其中不能放入 null 元素。

 ②、必须放入同样类的对象(默认会进行排序) ,否则可能会发生类型转换异常.我们可以使用泛型来进行限制。

Set treeSet = new TreeSet();
treeSet.add(1);  //添加一个 Integer 类型的数据
treeSet.add("a");   //添加一个 String 类型的数据
System.out.println(treeSet);  //会报类型转换异常的错误

java集合的详解 _ JavaClub全栈架构师技术笔记

③、自动排序:添加自定义对象的时候,必须要实现 Comparable 接口,并要覆盖 compareTo(Object obj) 方法来自定义比较规则。

 如果 this > obj,返回正数 1

 如果 this < obj,返回负数 -1

 如果 this = obj,返回 0 ,则认为这两个对象相等

④、两个对象通过 Comparable 接口 compareTo(Object obj) 方法的返回值来比较大小, 并进行升序排列。

java集合的详解 _ JavaClub全栈架构师技术笔记

⑤、定制排序: 创建 TreeSet 对象时, 传入 Comparator 接口的实现类. 要求: Comparator 接口的 compare 方法的返回值和 两个元素的 equals() 方法具有一致的返回值。

public class TreeSetTest {
    public static void main(String[] args) {
        Person p1 = new Person(1);
        Person p2 = new Person(2);
        Person p3 = new Person(3);
         
        Set<Person> set = new TreeSet<>(new Person());
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set);  //结果为[1, 2, 3]
    }
 
}
 
class Person implements Comparator<Person>{
    public int age;
    public Person(){}
    public Person(int age){
        this.age = age;
    }
    @Override
    /***
     * 根据年龄大小进行排序
     */
    public int compare(Person o1, Person o2) {
        // TODO Auto-generated method stub
        if(o1.age > o2.age){
            return 1;
        }else if(o1.age < o2.age){
            return -1;
        }else{
            return 0;
        }
    }
     
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return ""+this.age;
    }
}

  ⑥、当需要把一个对象放入 TreeSet 中,重写该对象对应的 equals() 方法时,应保证该方法与 compareTo(Object obj) 方法有一致的结果。

5、以上三个 Set 接口的实现类比较:

共同点:

(1)都不允许元素重复。

(2)都不是线程安全的类,解决办法:Set set = Collections.synchronizedSet(set 对象)。

不同点:

(1)HashSet:不保证元素的添加顺序,底层采用 哈希表算法,查询效率高。判断两个元素是否相等,equals() 方法返回 true,hashCode() 值相等。即要求存入 HashSet 中的元素要覆盖 equals() 方法和 hashCode()方法。

(2)LinkedHashSet:HashSet 的子类,底层采用了 哈希表算法以及 链表算法,既保证了元素的添加顺序,也保证了查询效率。但是整体性能要低于 HashSet。

(3)TreeSet:不保证元素的添加顺序,但是会对集合中的元素进行排序。底层采用 红-黑 树算法(树结构比较适合范围查询)。

6、Map集合(接口)

key-value 的键值对,key 不允许重复,value 可以

(1)严格来说 Map 并不是一个集合,而是两个集合之间 的映射关系。

(2)这两个集合没每一条数据通过映射关系,我们可以看成是一条数据。即 Entry(key,value)。Map 可以看成是由多个 Entry 组成。

(3)因为 Map 集合即没有实现于 Collection 接口,也没有实现 Iterable 接口,所以不能对 Map 集合进行 for-each 遍历。

java集合的详解 _ JavaClub全栈架构师技术笔记

Map<String,Object> hashMap = new HashMap<>();
        //添加元素到 Map 中
        hashMap.put("key1", "value1");
        hashMap.put("key2", "value2");
        hashMap.put("key3", "value3");
        hashMap.put("key4", "value4");
        hashMap.put("key5", "value5");
         
        //删除 Map 中的元素,通过 key 的值
        hashMap.remove("key1");
         
        //通过 get(key) 得到 Map 中的value
        Object str1 = hashMap.get("key1");
         
        //可以通过 添加 方法来修改 Map 中的元素
        hashMap.put("key2", "修改 key2 的 Value");
         
        //通过 map.values() 方法得到 Map 中的 value 集合
        Collection<Object> value = hashMap.values();
        for(Object obj : value){
            //System.out.println(obj);
        }
         
        //通过 map.keySet() 得到 Map 的key 的集合,然后 通过 get(key) 得到 Value
        Set<String> set = hashMap.keySet();
        for(String str : set){
            Object obj = hashMap.get(str);
            //System.out.println(str+"="+obj);
        }
         
        //通过 Map.entrySet() 得到 Map 的 Entry集合,然后遍历
        Set<Map.Entry<String, Object>> entrys = hashMap.entrySet();
        for(Map.Entry<String, Object> entry: entrys){
            String key = entry.getKey();
            Object value2 = entry.getValue();
            System.out.println(key+"="+value2);
        }
         
        System.out.println(hashMap);

(4)Map 的常用实现类:

java集合的详解 _ JavaClub全栈架构师技术笔记

7、Map 和 Set 集合的关系

(1)都有几个类型的集合,HashMap 和 HashSet ,都采用哈希表算法;TreeMap 和 TreeSet 都采用红-黑树算法;LinkedHashMap 和 LinkedHashSet 都采用哈希表算法和红-黑树算法。

(2)分析 Set 的底层源码,我们可以看到,Set 集合 就是由Map集合的Key 组成。

java集合的详解 _ JavaClub全栈架构师技术笔记

谢谢你的浏览,如果对你有所帮助,记得点赞评论哦!

作者:Jacob_924
来源链接:https://blog.csdn.net/Jacob_924/article/details/87969214

版权声明:
1、JavaClub(https://www.javaclub.cn)以学习交流为目的,由作者投稿、网友推荐和小编整理收藏优秀的IT技术及相关内容,包括但不限于文字、图片、音频、视频、软件、程序等,其均来自互联网,本站不享有版权,版权归原作者所有。

2、本站提供的内容仅用于个人学习、研究或欣赏,以及其他非商业性或非盈利性用途,但同时应遵守著作权法及其他相关法律的规定,不得侵犯相关权利人及本网站的合法权利。
3、本网站内容原作者如不愿意在本网站刊登内容,请及时通知本站(javaclubcn@163.com),我们将第一时间核实后及时予以删除。


本文链接:https://www.javaclub.cn/java/17721.html

标签: Java集合Java
分享给朋友:

“java集合的详解” 的相关文章

一分钟搞定Java环境变量配置

一分钟搞定Java环境变量配置

对于学Java的人来说,成功配置环境变量是第一步,因为后期不论 你做什么工作,会发现都需要这些,接下来介绍如何安装与配置,我按照jdk1.6来说明,其他一致。 下载官网 首先将jdk安装好后进行配置。 右击“计算机”,右键打开“属性”,...

Java中四种访问修饰符的区别

在java中共有4种访问级别,按访问权限由高到低为:public(公有的)、protected(受保护的)、友好的(没有任何访问权限关键字修饰)和private(私有的)。 类型 类内部 同一个包其...

Java 并发核心机制

Java 并发核心机制

📦 本文以及示例源码已归档在 javacore 一、J.U.C 简介 Java 的 java.util.concurrent 包(简称 J.U.C)中提供了大量并发工具类,是 Java 并发能力的主要体现(注意,不是全部,有部分并发能力的支持在其他包中)。...

Java 内存模型

Java 内存模型

📦 本文以及示例源码已归档在 javacore Java 内存模型(Java Memory Model),简称 JMM。 JVM 中试图定义一种 JMM 来屏蔽各种硬件和操作系统的内存访问差异,以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。...

Java日志框架那些事儿

Java日志框架那些事儿

在项目开发过程中,我们可以通过 debug 查找问题。而在线上环境我们查找问题只能通过打印日志的方式查找问题。因此对于一个项目而言,日志记录是一个非常重要的问题。因此,如何选择一个合适的日志记录框架也非常重要。在Java开发中,常用的日志记录框架有JDKLog、Log4J、LogBack、SLF4J...

JDBC连接时所犯错误1.字符集设置不合适2.连接MySQL8.0社区版时时区不一致3..包名不能以Java.命名4.驱动被弃用

Microsoft JDBC Driver 的主页为:https://msdn.microsoft.com/en-us/data/aa937724.aspx 下载所需驱动 今天连接时报了四次错,记录下来 1.java.sql.SQLException:...

java之整数的分解可以理解为倒序输出

Scanner in=new Scanner(System.in); int number ; number=in.nextInt(); int result=0; do{ int diget=number%10;...

二分法(折半查找)的运用之java实现猜数字游戏

让计算机输入一个数 然后用户进行猜数游戏 一般而言,七次会猜对,如果猜不对,那么就是你的方法不对 在这儿涉及到的一个算法就是二分法 ***二分法查找,***也称为折半法,是一种在有序数组中查找特定元素的搜索算法。二分法查找的思路如下: (1)首先,从数组...

java计数循环及小技巧

要运行一个很大次数的循环应该选择一个小数,然后去判断 例如本例子是100可以选择10去判断 public static void main(String[] args) { // TODO Auto-generated metho...

java数数字及while和do while 的使用,以及程序的调试与验证

while的条件是在进入循环体之前判断的,执行完一轮循环之后,会再回到循环开始的地方再次判断条件,而不会在循环体中随时判断条件 1.while语句是当条件满足时不断的执行循环体内语句。 2.会提前判断是否满足条件,所以有可能一次也没有执行。 3.条件成立...

发表评论

访客

◎欢迎参与讨论,请在这里发表您的看法和观点。