AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

JavaSE集合类

2022-06-08 126
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java中集合类是用来存放对象的，集合相当于一个容器，里面包容着一组对象 —— 容器类，其中的每个对象作为集合的一个元素出现，Java API提供的集合类位于java.util包内

概述


Java中集合类概述


Java中集合类是用来存放对象的

集合相当于一个容器，里面包容着一组对象 —— 容器类

其中的每个对象作为集合的一个元素出现

Java API提供的集合类位于java.util包内


Java中数组与集合的比较


数组也是容器，它是定长的，访问较快，但是数组不会自动扩充

数组可以包含基本数据类型或引用类型的对象，而集合中只能包含引用类型的对象


Java中集合框架层次结构

15.png


Collection接口


· 一组称为元素的对象

· 一个Collection中可以放不同类型的数据

· 是Set接口和List接口的父类

· 是否有特定的顺序以及是否允许重复，取决于它的实现

Set － 无序的集合；不允许重复（HashSet）

List － 有序的集合；允许重复（ArrayList，LinkedList）


Collection接口常用方法


image.png


Set接口


Set接口

 · Collection的子接口

 · 用来包含一组 无序无重复 的对象

       无序 — 是指元素存入顺序和集合内存储的顺序不同；

       无重复 — 两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复，在set中只保留一个。

Set接口的实现类

 · HashSet — HashSet的特性在于其内部对象的散列存取，即采用哈希技术

 · TreeSet — TreeSet存入的顺序跟存储的顺序不同，但是存储是按照排序存储的

使用foreach方式遍历Set集合


样例代码：


package com.training.csdn;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
 * Keafmd
 *
 * @ClassName: MySet
 * @Description: Set讲解
 * @author: 牛哄哄的柯南
 * @date: 2020-11-26 19:23
 */
public class MySet {
    public static void main(String[] args) {
        //类的构造
        Set set =  new HashSet(); //面向接口编程
        //add
        set.add(50);
        set.add(60); //int     Integer
        set.add(200);
        set.add(new Integer(200));
        //size() 获取集合长度
        System.out.println("set.size()： "+set.size());
        //使用另外一个集合构造set对象
        Set set2 = new HashSet();
        set2.addAll(set);  // 全部添加进去
        // 打印元素个数
        System.out.println("set2.size()： "+set2.size());
        //isEmpty 是否为空
        System.out.println("set2.isEmpty()： "+set2.isEmpty());
        //判断是否包含某个元素
        System.out.println( "set2.contains(60)： "+set2.contains(60));
        System.out.println( "set2.contains(200)： "+set2.contains(new Integer(200)));
        //迭代器 遍历Set
        Iterator it = set2.iterator();
        while(it.hasNext()){
            Object item = it.next();
            System.out.println("元素： "+item);
        }
        //移除元素， 通过equals 和hashcode 判断是否存在元素
        set.remove(50);
        System.out.println("移除后的元素个数： "+set.size());
        Set set3 = new HashSet();
        set3.add("abc");
        set3.add("def");
        set3.add("ghi");
        set3.add("aaa");
        Set set4 = new HashSet();
        set4.add("abc");
        set4.add("def");
        set4.add("kkk");
        set4.add("aaa");
        System.out.println("set3.size： "+set3.size());
        //  从set3中移除set3和set4的 交集元素
//        set3.removeAll(set4);
//        System.out.println("移除后的集合长度： "+set3.size());
//
//
//        for (Object o : set3) {
//            System.out.println("set3的元素有： "+o);
//        }
        // 保留 set3 和 set4 的交集元素
        set3.retainAll(set4);
        System.out.println("retainAll.size： "+set3.size());
        for (Object o : set3) {
            System.out.println("set3的元素有： "+o);
        }
        //清空set集合
        set3.clear();
        System.out.println(set3.size()); //0
    }
}

运行效果：


set.size()： 3
set2.size()： 3
set2.isEmpty()： false
set2.contains(60)： true
set2.contains(200)： true
元素： 50
元素： 200
元素： 60
移除后的元素个数： 2
set3.size： 4
retainAll.size： 3
set3的元素有： aaa
set3的元素有： abc
set3的元素有： def
0
Process finished with exit code 0

List接口


List接口常用方法

image.png


ArrayList与LinkedList的比较:

存储结构：

ArrayList是线性顺序存储。

LinkedList对象间彼此串连起来的一个链表。

操作性能：

ArrayList适合随机查询的场合。

LinkedList元素的插入和删除操作性高。

LinkedList功能要多一些。


ArrayList


讲解代码：


package com.CSDN.day26;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
 * Keafmd
 *
 * @ClassName: MyArrayList
 * @Description: ArrayList
 * @Author: 牛哄哄的柯南
 * @Date: 2020/11/26 21:01
 **/
public class MyArrayList {
    public static void main(String[] args) {
        //
        List list1 = new ArrayList();
        list1.add("张三");
        list1.add("李四");
        list1.add("李四");
        list1.add("王五");
        System.out.println("list1.size()\t"+list1.size());
        List list2 = new ArrayList(list1);
        System.out.println("list2.size()\t"+list2.size());
        System.out.println("========================================================");
        //通过下标的形式访问每一个元素
//        System.out.println("list1.get(0)\t"+list1.get(0));
//        System.out.println("list1.get(1)\t"+list1.get(1));
//        System.out.println("list1.get(2)\t"+list1.get(2));
        for (int i = 0; i < list1.size(); i++) {
            System.out.println("list1.get("+i+")\t"+list1.get(i));
        }
        System.out.println("=======================增强for遍历=================================");
        for (Object o : list2) {
            System.out.println("item\t"+o);
        }
        System.out.println("=======================Iterator遍历=================================");
        for(Iterator it = list2.iterator(); it.hasNext() ; ){
            System.out.println("iterator Item \t"+it.next());
        }
        System.out.println("=======================forEach遍历=================================");
//        list2.forEach(System.out::println);
        list2.forEach(x->System.out.println("forEach item\t"+x));
        System.out.println("=======================add(index,Object el)=================================");
        List list3 =new  ArrayList();
        list3.add("abc");
        list3.add("def");
        list3.add("jqk");
        //list3 add(index ,el)
        list3.add(1,"insert");
        list3.forEach(x->System.out.println("list3 item\t"+x));
        System.out.println("=======================add(index,Object el)=================================");
        //list3 update(index ,el)
        list3.set(1,"update");
        list3.forEach(x->System.out.println("list3 item\t"+x));
        //indexOf/lastIndexOf ,返回索引位置，如果找不到则返回-1
        System.out.println("list3.indexOf(\"def\")\t"+list3.indexOf("def"));
        //判断def是否重复
        if(list3.indexOf("def") != list3.lastIndexOf("def")){
            System.out.println("def重复了");
        }
        //listIterator
        ListIterator listIter = list3.listIterator(list3.size()-1);
        while (listIter.hasPrevious()){
            System.out.println("listIter.previous()\t"+listIter.previous());
        }
    }
}

运行结果：


list1.size()  4
list2.size()  4
========================================================
list1.get(0)  张三
list1.get(1)  李四
list1.get(2)  李四
list1.get(3)  王五
=======================增强for遍历=================================
item  张三
item  李四
item  李四
item  王五
=======================Iterator遍历=================================
iterator Item   张三
iterator Item   李四
iterator Item   李四
iterator Item   王五
=======================forEach遍历=================================
forEach item  张三
forEach item  李四
forEach item  李四
forEach item  王五
=======================add(index,Object el)=================================
list3 item  abc
list3 item  insert
list3 item  def
list3 item  jqk
=======================add(index,Object el)=================================
list3 item  abc
list3 item  update
list3 item  def
list3 item  jqk
list3.indexOf("def")  2
listIter.previous() def
listIter.previous() update
listIter.previous() abc
Process finished with exit code 0

LinkedList


讲解代码：


package com.CSDN.day26;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
/**
 * Keafmd
 *
 * @ClassName: MyLinkedList
 * @Description: LinkedList
 * @Author: 牛哄哄的柯南
 * @Date: 2020/11/26 21:06
 **/
public class MyLinkedList {
    public static void main(String[] args) {
        //
        List list1 = new LinkedList();
        list1.add("张三");
        list1.add("李四");
        list1.add("李四");
        list1.add("王五");
        System.out.println("list1.size()\t"+list1.size());
        List list2 = new LinkedList(list1);
        System.out.println("list2.size()\t"+list2.size());
        System.out.println("========================================================");
        //通过下标的形式访问每一个元素
//        System.out.println("list1.get(0)\t"+list1.get(0));
//        System.out.println("list1.get(1)\t"+list1.get(1));
//        System.out.println("list1.get(2)\t"+list1.get(2));
        for (int i = 0; i < list1.size(); i++) {
            System.out.println("list1.get("+i+")\t"+list1.get(i));
        }
        System.out.println("=======================增强for遍历=================================");
        for (Object o : list2) {
            System.out.println("item\t"+o);
        }
        System.out.println("=======================Iterator遍历=================================");
        for(Iterator it = list2.iterator(); it.hasNext() ; ){
            System.out.println("iterator Item \t"+it.next());
        }
        System.out.println("=======================forEach遍历=================================");
//        list2.forEach(System.out::println);
        list2.forEach(x->System.out.println("forEach item\t"+x));
        System.out.println("=======================add(index,Object el)=================================");
        List list3 =new  LinkedList();
        list3.add("abc");
        list3.add("def");
        list3.add("jqk");
        //list3 add(index ,el)
        list3.add(1,"insert");
        list3.forEach(x->System.out.println("list3 item\t"+x));
        System.out.println("=======================add(index,Object el)=================================");
        //list3 update(index ,el)
        list3.set(1,"update");
        list3.forEach(x->System.out.println("list3 item\t"+x));
        //indexOf/lastIndexOf ,返回索引位置，如果找不到则返回-1
        System.out.println("list3.indexOf(\"def\")\t"+list3.indexOf("def"));
        //判断def是否重复
        if(list3.indexOf("def") != list3.lastIndexOf("def")){
            System.out.println("def重复了");
        }
        System.out.println("================================================");
        ListIterator listIter = list3.listIterator();
        while (listIter.hasNext()){
            System.out.println("listIter.next()\t"+listIter.next());
        }
        System.out.println("=============================");
        //listIterator
//        ListIterator listIter2 = list3.listIterator(list3.size());
//        while (listIter2.hasPrevious()){
//            System.out.println("listIter2.previous()\t"+listIter2.previous());
//        }
        LinkedList lList = new LinkedList();
        lList.addAll(list3);
        Object popItem = lList.pop(); //如果没有元素会抛异常
        Object pollItem = lList.poll();
        System.out.println(pollItem);
    }
}

运行结果：


list1.size()  4
list2.size()  4
========================================================
list1.get(0)  张三
list1.get(1)  李四
list1.get(2)  李四
list1.get(3)  王五
=======================增强for遍历=================================
item  张三
item  李四
item  李四
item  王五
=======================Iterator遍历=================================
iterator Item   张三
iterator Item   李四
iterator Item   李四
iterator Item   王五
=======================forEach遍历=================================
forEach item  张三
forEach item  李四
forEach item  李四
forEach item  王五
=======================add(index,Object el)=================================
list3 item  abc
list3 item  insert
list3 item  def
list3 item  jqk
=======================add(index,Object el)=================================
list3 item  abc
list3 item  update
list3 item  def
list3 item  jqk
list3.indexOf("def")  2
================================================
listIter.next() abc
listIter.next() update
listIter.next() def
listIter.next() jqk
=============================
update
Process finished with exit code 0

Map接口


Map内存储的是键/值对这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象。

Map是不同于Collection的另外一种集合接口。

Map中，key值是唯一的(不能重复)，而key对象是与value对象关联在一起的。

Map接口有两个实现：

HashMap — key/value对 是按照Hash算法存储的。

TreeMap — key/value对是排序 (按key排序)存储的。


Map接口常用方法

image.png


HashMap类


HashMap类是Map接口的实现类 基于哈希表的 Map 接口的实现


Student 类：


package com.CSDN.day26;
/**
 * Keafmd
 *
 * @ClassName: Student
 * @Description:
 * @Author: 牛哄哄的柯南
 * @Date: 2020/11/26 21:16
 **/
public class Student {
    String name;
    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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

讲解代码：


package com.CSDN.day26;
import java.util.*;
/**
 * Keafmd
 *
 * @ClassName: MyMap
 * @Description: Map
 * @Author: 牛哄哄的柯南
 * @Date: 2020/11/26 21:15
 **/
public class MyMap {
    public static void main(String[] args) {
        //对象的创建
        Map<String,Student> map = new HashMap<>();
        List<Student> stuList = new ArrayList();
        stuList.add(new Student("张飞",50));
        stuList.add(new Student("张飞1",36));
        stuList.add(new Student("张飞2",20));
        stuList.add(new Student("张飞3",58));
        //如果要查找某一个元素的属性，需要遍历集合后查找元素才能获取舒心
        for (Student student : stuList) {
            if("张飞3".equals(student.getName())){
                System.out.println("student.age\t"+student.getAge());
                break;
            }
        }
        //put key不可以重复
        map.put("张飞",new Student("张飞",50));
        map.put("张飞1",new Student("张飞1",36));
        map.put("张飞2",new Student("张飞2",20));
        map.put("张飞3",new Student("张飞3",58));
        //get根据key获取指定的元素,底层使用hash计算索引，快速查找元素
        Student stu = (Student) map.get("张飞3");
        System.out.println(stu.getAge());
        /**
         * int size()
         * void clear()
         * boolean isEmpty()
         */
//        map.clear();
        System.out.println("map.size\t"+map.size());
        System.out.println("map.isEmpty\t"+map.isEmpty());
        Map map2 = new HashMap();
        map2.put("张飞3",new Student("张飞3",999));
        map2.put("张飞4",new Student("张飞4",20));
        Student zf5 = new Student("张飞5", 58);
        map2.put("张飞5",zf5);
        map.putAll(map2);
        System.out.println("map.size\t"+map.size());
        System.out.println("map.get(\"张飞3\")\t"+map.get("张飞3").getAge());
        System.out.println("map.containsKey(\"张飞\")\t"+map.containsKey("张飞"));
        System.out.println("map.containsKey(\"张飞99\")\t"+map.containsKey("张飞99"));
        System.out.println("map.containsValue(new Student(\"张飞5\",58)\t"+map.containsValue(zf5));
        System.out.println("========================size==============================");
        System.out.println("map.size\t"+map.size());
        map.remove("张飞3");
        System.out.println("map.size\t"+map.size());
        //HashMap的遍历
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.printf("key:%s\tvalue:%s\r\n",key,map.get(key).toString());
        }
        System.out.println("================================================");
        Set<Map.Entry<String, Student>> entrySet = map.entrySet();
        for (Map.Entry<String, Student> stringStudentEntry : entrySet) {
            String key = stringStudentEntry.getKey();
            Student value = stringStudentEntry.getValue();
            System.out.printf("key:%s\tvalue:%s\r\n",key,value.toString());
        }
    }
}

运行结果：


student.age 58
58
map.size  4
map.isEmpty false
map.size  6
map.get("张飞3")  999
map.containsKey("张飞") true
map.containsKey("张飞99") false
map.containsValue(new Student("张飞5",58) true
========================size==============================
map.size  6
map.size  5
key:张飞5 value:Student{name='张飞5', age=58}
key:张飞4 value:Student{name='张飞4', age=20}
key:张飞  value:Student{name='张飞', age=50}
key:张飞2 value:Student{name='张飞2', age=20}
key:张飞1 value:Student{name='张飞1', age=36}
================================================
key:张飞5 value:Student{name='张飞5', age=58}
key:张飞4 value:Student{name='张飞4', age=20}
key:张飞  value:Student{name='张飞', age=50}
key:张飞2 value:Student{name='张飞2', age=20}
key:张飞1 value:Student{name='张飞1', age=36}
Process finished with exit code 0

HashMap与TreeMap的比较


HashMap基于哈希表实现。

TreeMap基于树实现。

HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用。

TreeMap没有调优选项，因为该树总处于平衡状态

HashMap性能优于TreeMap。


HashMap与Hashtable的比较


Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许用null。


文章标签：
Java
容器
安全
API
算法
存储
牛哄哄的柯南8151
目录
相关文章
众所周知
|
5月前
|
存储 Java 开发者
Java集合框架：Java中的集合框架有哪些？
Java集合框架：Java中的集合框架有哪些？
众所周知
47 0
一颗小谷粒
|
3月前
|
Java 索引
JavaSE—常用类 (全)（一）
JavaSE—常用类 (全)（一）
一颗小谷粒
29 3
一颗小谷粒
|
3月前
|
安全 Java 测试技术
JavaSE—常用类 (全)（二）
JavaSE—常用类 (全)（二）
一颗小谷粒
22 1
请回答1024
|
5月前
|
存储 安全 算法
JavaSE&集合框架
JavaSE&集合框架
请回答1024
30 1
游客6z2krsj5iqmue
|
5月前
|
存储 安全 Java
Java的集合类
Java的集合类
游客6z2krsj5iqmue
23 0
请回答1024
|
5月前
|
存储
JavaSE&泛型
JavaSE&泛型
请回答1024
18 1
遇事问春风乄
|
5月前
|
安全 Java 编译器
【JavaEE初阶】 线程安全的集合类
【JavaEE初阶】 线程安全的集合类
遇事问春风乄
35 0
小刘抒001
|
Java
java常见的集合类有哪些
删除 重试 复制 Java中常见的集合类有以下几种： ArrayList：基于动态数组实现，可以动态地增加和删除元素。它提供了快速的随机访问和遍历，但在插入和删除元素时需要移动其他元素，效率较低。 LinkedList：基于链表实现，每个元素都包含一个指向前一个和后一个元素的引用。它适用于频繁地插入和删除元素的场景，但访问元素的效率较低。 HashSet：基于哈希表实现，不允许重复元素。它提供了常数时间的插入和查找操作，但不保证元素的顺序。 TreeSet：基于红黑树实现，保持元素有序。它提供了有序的集合视图，可以进行范围查找和遍历操作。 HashMap：基于哈希表实现，使用键
小刘抒001
91 0
不能再留遗憾了
|
5月前
|
安全 Java 容器
【JavaEE】线程安全的集合类
【JavaEE】线程安全的集合类
不能再留遗憾了
63 0
游客kczqmpfyby5aa
|
5月前
|
Java
java常见的集合类
java常见的集合类
游客kczqmpfyby5aa
25 0