JAVA容器集合全面解析(Collection和Map)

目录
  • 前言
  • 一.Collection集合
    • 1.1List集合
      • 1.1.1ArrayList集合
      • 1.1.2LinkedList集合
    • 1.2Set集合
      • 1.2.1HashSet集合
      • HashSet集合保证元素唯一性源码分析:
      • 1.2.2TreeSet集合
      • 比较器排序Comparator的使用:
  • 二.Map集合
    • 2.1Map集合的概述与特点
    • 2.2Map集合的获取功能
    • 2.3Map集合的遍历方式(方式一)
    • 2.4Map集合的遍历方式(方式二)
    • 2.5HashMap集合

前言

本次我将分享的是java中常用的容器集合,大体分为了两类(Collection单列集合和Map双列集合),什么是双列,单列集合呢?看完这篇博客,或许你将有些许收获。Collection集合下主要讲解List集合和Set集合,而双列集合,我主要讲解HashMap集合。

一.Collection集合

Collection集合概述

是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素

JDK 不提供此接口的任何直接实现,它提供更具体的子接口(如Set和List)实现

常用方法:

1.1List集合

List集合概述:

有序集合(也称为序列),用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素,并搜索列表中的元素

与Set集合不同,列表通常允许重复的元素

List集合特点:

有索引

可以存储重复元素

元素存取有序

List集合特有的方法:

遍历方式:

//学生类
public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

//--------------------------------------------------------
//测试类
public class ListDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<Student> list = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);

        //把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //迭代器:集合特有的遍历方式
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("--------");

        //普通for:带有索引的遍历方式
        for(int i=0; i<list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("--------");

        //增强for:最方便的遍历方式
        for(Student s : list) {
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

接下来讲的是List集合的实现类:

1.1.1ArrayList集合

ArrayList集合的底层是数组结构实现,查询快、增删慢,它的一些常用方法可以参考List集合的

常用方法。

1.1.2LinkedList集合

LinkedList集合底层是链表结构实现,查询慢、增删快,它有一些特有的常用方法

1.2Set集合

Set集合的特点

元素存取无序

没有索引、只能通过迭代器或增强for循环遍历

不能存储重复元素

在我讲解HashSet之前我们必须先了解哈希值的概念,方便我们理解接下来的一些集合

哈希值简介

是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

如何获取哈希值

Object类中的public int hashCode():返回对象的哈希码值

哈希值的特点

同一个对象多次调用hashCode()方法返回的哈希值是相同的

默认情况下,不同对象的哈希值是不同的。而重写hashCode()方法,可以实现让不同对象的哈希值相同

1.2.1HashSet集合

HashSet集合的特点

底层数据结构是哈希表

对集合的迭代顺序不作任何保证,也就是说不保证存储和取出的元素顺序一致

没有带索引的方法,所以不能使用普通for循环遍历

由于是Set集合,所以是不包含重复元素的集合

HashSet的基本使用:

public class HashSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> hs = new HashSet<String>();

        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");

        hs.add("world");

        //遍历
        for(String s : hs) {
            System.out.println(s);
        }
    }
}

HashSet集合保证元素唯一性源码分析:

1.根据对象的哈希值计算存储位置

如果当前位置没有元素则直接存入

如果当前位置有元素存在,则进入第二步

2.当前元素的元素和已经存在的元素比较哈希值

如果哈希值不同,则将当前元素进行存储

如果哈希值相同,则进入第三步

3.通过equals()方法比较两个元素的内容

如果内容不相同,则将当前元素进行存储

如果内容相同,则不存储当前元素

图解:

拓展:LinkedHashSet

LinkedHashSet集合特点

哈希表和链表实现的Set接口,具有可预测的迭代次序

由链表保证元素有序,也就是说元素的存储和取出顺序是一致的

由哈希表保证元素唯一,也就是说没有重复的元素

1.2.2TreeSet集合

TreeSet集合概述

元素有序,可以按照一定的规则进行排序,具体排序方式取决于构造方法

TreeSet():根据其元素的自然排序进行排序

TreeSet(Comparator comparator) :根据指定的比较器进行排序

没有带索引的方法,所以不能使用普通for循环遍历

由于是Set集合,所以不包含重复元素的集合

要理解好TreeSet必须先了解自然排序Comparable:

案例需求

存储学生对象并遍历,创建TreeSet集合使用无参构造方法

要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序

实现步骤

用TreeSet集合存储自定义对象,无参构造方法使用的是自然排序对元素进行排序的

自然排序,就是让元素所属的类实现Comparable接口,重写compareTo(T o)方法

重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写

public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

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

    @Override
    public int compareTo(Student s) {
//        return 0;
//        return 1;
//        return -1;
        //按照年龄从小到大排序
       int num = this.age - s.age;
//        int num = s.age - this.age;
        //年龄相同时,按照姓名的字母顺序排序
       int num2 = num==0?this.name.compareTo(s.name):num;
        return num2;
    }
}
//------------------------------------------------
public class TreeSetDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>();

        //创建学生对象
        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);

        Student s5 = new Student("linqingxia",33);
        Student s6 = new Student("linqingxia",33);

        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

比较器排序Comparator的使用:

案例需求

存储学生对象并遍历,创建TreeSet集合使用带参构造方法

要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序

实现步骤

用TreeSet集合存储自定义对象,带参构造方法使用的是比较器排序对元素进行排序的

比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(T o1,T o2)方法

重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写

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

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.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;
    }
}
//===================================================================
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //this.age - s.age
                //s1,s2
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        //创建学生对象
        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);

        Student s5 = new Student("linqingxia",33);
        Student s6 = new Student("linqingxia",33);

        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

二.Map集合

2.1Map集合的概述与特点

Map集合概述

interface Map<K,V>  K:键的类型;V:值的类型

Map集合的特点

键值对映射关系

一个键对应一个值

键不能重复,值可以重复

元素存取无序

Map集合的基本使用:

Map集合的一些常用方法:

public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key,V value):添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");

        //V remove(Object key):根据键删除键值对元素
//        System.out.println(map.remove("郭靖"));
//        System.out.println(map.remove("郭襄"));

        //void clear():移除所有的键值对元素
//        map.clear();

        //boolean containsKey(Object key):判断集合是否包含指定的键
//        System.out.println(map.containsKey("郭靖"));
//        System.out.println(map.containsKey("郭襄"));

        //boolean isEmpty():判断集合是否为空
//        System.out.println(map.isEmpty());

        //int size():集合的长度,也就是集合中键值对的个数
        System.out.println(map.size());

        //输出集合对象
        System.out.println(map);
    }
}

2.2Map集合的获取功能

方法介绍:

public class MapDemo03 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //V get(Object key):根据键获取值
//        System.out.println(map.get("张无忌"));
//        System.out.println(map.get("张三丰"));

        //Set<K> keySet():获取所有键的集合
//        Set<String> keySet = map.keySet();
//        for(String key : keySet) {
//            System.out.println(key);
//        }

        //Collection<V> values():获取所有值的集合
        Collection<String> values = map.values();
        for(String value : values) {
            System.out.println(value);
        }
    }
}

2.3Map集合的遍历方式(方式一)

遍历思路

我们刚才存储的元素都是成对出现的,所以我们把Map看成是一个夫妻对的集合

把所有的丈夫给集中起来

遍历丈夫的集合,获取到每一个丈夫

根据丈夫去找对应的妻子

步骤分析

获取所有键的集合。用keySet()方法实现

遍历键的集合,获取到每一个键。用增强for实现

根据键去找值。用get(Object key)方法实现

public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键的集合。用keySet()方法实现
        Set<String> keySet = map.keySet();
        //遍历键的集合,获取到每一个键。用增强for实现
        for (String key : keySet) {
            //根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

2.4Map集合的遍历方式(方式二)

遍历思路

我们刚才存储的元素都是成对出现的,所以我们把Map看成是一个夫妻对的集合

获取所有结婚证的集合

遍历结婚证的集合,得到每一个结婚证

根据结婚证获取丈夫和妻子

步骤分析

获取所有键值对对象的集合

Set<Map.Entry<K,V>> entrySet():获取所有键值对对象的集合

遍历键值对对象的集合,得到每一个键值对对象

用增强for实现,得到每一个Map.Entry

根据键值对对象获取键和值

用getKey()得到键

用getValue()得到值

代码实现

public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历键值对对象的集合,得到每一个键值对对象
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}

2.5HashMap集合

HashMap是Map的实现类,HashMap可实现快速存储和检索,但缺点是包含的元素是无序的,适用于在Map中插入、删除和定位元素。常用方法参考Map集合。

到此这篇关于JAVA容器集合全面解析(Collection和Map)的文章就介绍到这了,更多相关JAVA容器内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java ConcurrentHashMap用法案例详解

    一.概念 哈希算法(hash algorithm):是一种将任意内容的输入转换成相同长度输出的加密方式,其输出被称为哈希值. 哈希表(hash table):根据设定的哈希函数H(key)和处理冲突方法将一组关键字映象到一个有限的地址区间上,并以关键字在地址区间中的象作为记录在表中的存储位置,这种表称为哈希表或散列,所得存储位置称为哈希地址或散列地址. 二.HashMap与HashTable 1,线程不安全的HashMap 因为多线程环境下,使用HashMap进行put操作会引起死循环,导致CP

  • Java如何实现实体类转Map、Map转实体类

    实体类转Map.Map转实体类 1.创建entity(User.java) package com.jeff.entity; public class User { private String userName; private String password; private Integer age; public User() { super(); } public User(String userName, String password, Integer age) { super();

  • Java将json对象转换为map键值对案例详解

    本文的目的是把json串转成map键值对存储,而且只存储叶节点的数据 比如json数据如下: {responseHeader:{status:0,QTime:0},spellcheck:{suggestions:{中国:{numFound:9,startOffset:0,endOffset:2,suggestion:[中国工商银行, 中国人民, 中国国际, 中国农业, 中国市场, 中国经济, 中国人, 中国广播, 中国文化]}},collations:{collation:中国工商银行}}} 如

  • MySql多表查询 事务及DCL

    目录 一.多表查询 1.查询语法 2. 准备sql 3. 笛卡尔积 4.多表查询的分类 4.1 内连接查询 4.2 外链接查询 4.3 子查询 4.4 子查询不同情况 5.多表查询练习 二.事务 1. 事务的基本介绍 2. 操作 2.MySQL数据库中事务默认自动提交 3. 事务的四大特征 一.多表查询 1.查询语法 select   列名列表  from   表名列表  where.... 2. 准备sql # 创建部门表 CREATE TABLE dept( id INT PRIMARY K

  • Java使用Semaphore对单接口进行限流

    目录 一.实战说明 1.1 效果说明 1.2 核心知识点 二. 环境搭建 三.限流演示 3.1 并发请求工具 3.2 效果示例图 一.实战说明 1.1 效果说明 本篇主要讲如何使用Semaphore对单接口进行限流,例如有如下场景 a. A系统的有a接口主要给B系统调用,现在希望对B系统进行限流,例如处理峰值在100,超过100的请求快速失败 b. 接口作为总闸入口,希望限制所有外来访问,例如某个房间只能同时100个玩家在线,只有前面的处理完后面的才能继续请求 c. 其他类型场景,也就是资源固定

  • 解决mybatis-plus自动配置的mapper.xml与java接口映射问题

    目录 mybatis-plus自动配置mapper.xml与java接口映射 其中核心功能就是下面这个方法 mybatis-plus3 配置mapper和xml映射关系 原因就是mapper接口与xml映射文件没有配置成功 mybatis-plus自动配置mapper.xml与java接口映射 本来没有mybatis-plus的话,这个工作是通过mybatis-spring的MapperScan来完成的. Mybatis-plus中的自动配置类MybatisPlusAutoConfigurati

  • Java中详细解析Map接口

    目录 Map详解: Map基本操作: hashMap原理: Put方法: Get方法: Map的遍历: TreeMap LinkedHashMap: 对比下Hashmap.Hashtable和ConcurrentHashmap: 总结 Map详解: 先看图,便于宏观了解Map的地位. Map接口中键和值一一映射. 可以通过键来获取值. 给定一个键和一个值,你可以将该值存储在一个Map对象. 之后,你可以通过键来访问对应的值. 当访问的值不存在的时候,方法就会抛出一个NoSuchElementEx

  • java map中相同的key保存多个value值方式

    目录 map中相同的key保存多个value值 如下代码 Map中相同的键Key不同的值Value实现原理 实现原理 总结 map中相同的key保存多个value值 在java中,Map集合中只能保存一个相同的key,如果再添加相同的key,则之后添加的key的值会覆盖之前key对应的值,Map中一个key只存在唯一的值. 如下代码 package test; import org.junit.Test; import java.util.HashMap; import java.util.Id

  • JAVA容器集合全面解析(Collection和Map)

    目录 前言 一.Collection集合 1.1List集合 1.1.1ArrayList集合 1.1.2LinkedList集合 1.2Set集合 1.2.1HashSet集合 HashSet集合保证元素唯一性源码分析: 1.2.2TreeSet集合 比较器排序Comparator的使用: 二.Map集合 2.1Map集合的概述与特点 2.2Map集合的获取功能 2.3Map集合的遍历方式(方式一) 2.4Map集合的遍历方式(方式二) 2.5HashMap集合 前言 本次我将分享的是java

  • Java容器ArrayList原理解析

    这篇文章主要介绍了Java容器ArrayList原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 List是collection接口的实现类 List: 特点:有序,可重复 它有两个常用的实现类: 一.ArrayList: 特点:以数组的形式进行存储,因此随机访问速度较快,所有它适用于查询. 缺点:不适用于插入和删除的操作 因为每次操作都需要移动数组中的元素. 根据源码我们能得出以下几点: 1.ArrayList 在初始化的时候如果我们没

  • Java中集合List、Set和Map的入门详细介绍

    目录 一.Collection接口 二.List集合 2.1介绍 2.1.1 ArrayList(数组) 2.1.2 Vector(数组实现.线程同步) 2.1.3 LinkList(链表) 2.2 List特性 2.3 List常用方法 2.4 List总结 三.Set集合 3.1介绍 3.2 分类 3.2.1 HashSet(Hash表) 3.2.2 TreeSet(二叉树) 3.2.3 LinkHashSet(HashSet+LinkedHashMap) 四.Map集合 4.1 HashM

  • java容器详细解析

    前言:在java开发中我们肯定会大量的使用集合,在这里我将总结常见的集合类,每个集合类的优点和缺点,以便我们能更好的使用集合.下面我用一幅图来表示 其中淡绿色的表示接口,红色的表示我们经常使用的类. 1:基本概念 Java容器类类库的用途是保存对象,可以将其分为2个概念. 1.1:Collection 一个独立元素的序列,这些元素都服从一条或多条规则.其中List必须按照插入的顺序保存元素.Set不能有重复的元素.Queue按照排队规则来确定对象的产生顺序(通常也是和插入顺序相同) 1.2:Ma

  • Java集合教程之Collection实例详解

    前言 集合就是一组数的集合,就像是一个容器,但是我们应该清楚的是集合中存放的都是对象的引用,而不是真正的实体.而我们常说的集合中的对象其实指的就是对象的引用. 我们可以把集合理解为一个小型数据库,用于存放数据,我们对集合的操作也就是数据的增删改查,在 Java 中有两个顶层接口 Collection 和 Map 用于定义和规范集合的相关操作.这篇文章主要说一下集合框架中的 Collection 部分. Collection 表示一组对象,这些对象可以是有序也可以是无序的,它提供了不同的子接口满足

  • Java常用集合与原理解析

    目录 迭代器 集合框架中的接口 具体集合 散列码 树集 队列 优先队列 映射 基本映射 映射视图 弱散列映射 链接散列集合映射 枚举集与映射 标识散列映射 Java 最初版本只为常用的数据结构提供了很少的一组类:Vector.Stack.Hashtable.BitSet 与 Enumeration 接口 迭代器 public interface Collection<E> { boolean add(E element); Iterator<E> iterator(); ... }

  • 浅谈Java中常用数据结构的实现类 Collection和Map

    线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构.这些类均在java.util包中.本文试图通过简单的描述,向读者阐述各个类的作用以及如何正确使用这些类. Collection ├List │├LinkedList │├ArrayList │└Vector │ └Stack └Set Map ├Hashtable ├HashMap └WeakHashMap Collection接口 Collection是最基本的集合接口,一个C

  • Java集合Set、List、Map的遍历方法

    本文实例讲述了Java集合Set.List.Map的遍历方法,分享给大家供大家参考. 具体方法如下: package com.shellway.javase; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.uti

  • Java集合框架之Collection接口详解

    Java是一门面向对象的语言,那么我们写程序的时候最经常操作的便是对象了,为此,Java提供了一些专门用来处理对象的类库,这些类库的集合我们称之为集合框架.Java集合工具包位于Java.util包下,包含了很多常用的数据结构,如数组.链表.栈.队列.集合.哈希表等.学习Java集合框架下大致可以分为如下五个部分:List列表.Set集合.Map映射.迭代器(Iterator.Enumeration).工具类(Arrays.Collections). Java的集合类主要由两个接口派生而出:Co

  • Java集合基础知识 List/Set/Map详解

    一.List Set 区别 List 有序,可重复: Set 无序,不重复: 二.List Set 实现类间区别及原理 Arraylist 底层实现使用Object[],数组查询效率高 扩容机制 1.6采用(capacity * 3)/ 2 + 1,默认容量为10: 1.7采用(capacity >> 2 + capacity)实现,位移动效率高于数学运算,右移一位等于乘以2倍: 读取速度快,写入会涉及到扩容,所以相对较慢. LinkedList底层采用双向链表,只记录 first 和 las

随机推荐