Java集合框架2024最通俗易懂（图片超全）

集合

1.1、定义

集合就是类型统一的数据组合而成的数据结构，该数据结构可以任意的改变长度。

1.3、Set

Set数据存储结构，无序，且不可以重复，元素可以为null，但是也只能出现一次，如下图:

1.3.1、HashSet

HashSet是无序且不可重复元素的Set集合。

package com.wlx.day13;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo
{

    public static void main(String[] args)
    {
        //创建一个集合对象
        HashSet<Object>  hs = new HashSet<>();
        //此处表示hs集合中只能存放String字符串类型的元素
//        HashSet<String>  hs = new HashSet<>();
        //向Set集合中添加元素
        hs.add("tom");
        hs.add(123);
        hs.add(3.14);
        hs.add(true);
        hs.add('c');
        hs.add(new HashSetDemo());
        //输出集合hs中的元素
        System.out.println(hs);
        //获取集合hs中的元素个数
        System.out.println(hs.size());
        //删除集合hs中指定的元素
        hs.remove(123);
        System.out.println(hs);
        //使用循环遍历集合
        for(Object obj : hs)
        {
            System.out.println(obj);
        }
        System.out.println("-------------");
        //获取hs的迭代器对象
        Iterator  it =  hs.iterator();
        while (it.hasNext())
        {
            System.out.println(it.next());
        }


    }
}

1.3.2、TreeSet

TreeSet可以对Set集合进行排序，默认情况下是自然排序（从小到大排序）。

package com.wlx.day13;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo
{
    public static void main(String[] args)
    {
        TreeSet<Integer>  ts = new TreeSet<>();
        ts.add(123);
        ts.add(23);
        ts.add(12);
        ts.add(321);
        ts.add(13);
        System.out.println(ts);
        //获取集合ts中的元素个数
        System.out.println(ts.size());
        //删除集合ts中指定的元素
        ts.remove(123);
        System.out.println(ts);
        //使用循环遍历集合
        for(Integer ite : ts)
        {
            System.out.println(ite);
        }
        System.out.println("-------------");
        //获取ts的迭代器对象
        Iterator<Integer> it =  ts.iterator();
        while (it.hasNext())
        {
            //当迭代时使用集合对象中的删除方法删除指定元素时,会出现快速失败机制
            //ts.remove(321);
            Integer ig = it.next();
            /*if(ig == 13)
            {
                it.remove();
            }*/
            System.out.println(ig);
        }
    }
}

1.4、List

List数据存储结构，有序，且可以重复，元素可以为null，允许出现多次null值，如下图:

1.4.1、ArrayList

ArrayList底层是数组，在进行查询(遍历/迭代)时，速度仅次于数组，这个集合是有下标的，并且该集合中的元素是可以重复的，推荐在查询功能上使用该集合，不推荐用于删除、增加功能，性能不佳，此时推荐另一个List集合，LinkedList。

package com.wlx.day13;

import java.util.ArrayList;
import java.util.List;

public class ListDemo
{
    public static void main(String[] args)
    {
        //创建List集合对象
        List<Object>  list = new ArrayList<>();
        list.add("tom");
        list.add(123);
        list.add(3.16);
        list.add(new ListDemo());
        list.add(true);
        System.out.println(list);
        //获取下标为1处的元素
        System.out.println(list.get(1));
        //将一个新的元素插入到下标为3处,并替换此处的元素
//        list.set(3,"jim");
        //将一个新的元素插入到下标为3处,不替换原有数据
        list.add(3,"jim");
        System.out.println(list);
        //遍历集合list
        for(int i = 0;i < list.size();i++)
        {
            System.out.println(list.get(i));
        }
        System.out.println("---------------------");
        for(Object obj : list)
        {
            System.out.println(obj);
        }
        //使用迭代器迭代list集合和前面Set一样,此处省略。

    }
}

1.4.2、LinkedList

package com.wlx.day13;

import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListDemo
{
    public static void main(String[] args)
    {
        //创建LinkedList对象
        LinkedList<String>  linkedList = new LinkedList<>();
        linkedList.add("jim");
        linkedList.add("tom");
        linkedList.add("lilei");
        linkedList.add("lucy");
       /* System.out.println(linkedList);
        System.out.println(linkedList.size());*/
        //堆栈
       /* linkedList.push("jim");
        linkedList.push("tom");
        linkedList.push("lilei");
        //从堆栈弹出一个元素,并移除
//        System.out.println("pop---"+linkedList.pop());
        //从堆栈弹出一个元素,不移除该元素
        System.out.println("peek---"+linkedList.peek());
        System.out.println(linkedList);*/
        //队列
        /*System.out.println(linkedList);
        //获取并移除队列中队头的元素
        System.out.println("poll---"+linkedList.poll());
        System.out.println(linkedList);
        //获取不移除队列中队头的元素
        System.out.println("peek---"+linkedList.peek());
        System.out.println(linkedList);*/
        //双端队列

        //创建双向迭代器
        ListIterator<String> li = linkedList.listIterator();
        //正向迭代
        System.out.println("正向迭代");
        /*while(li.hasNext())
        {
            System.out.println(li.next());
        }*/
        System.out.println("--------------");
        System.out.println("反向迭代");
        while (li.hasPrevious())
        {
            System.out.println(li.previous());
        }
    }
}

1.5、Map

Map数据存储结构，键值对，即key—value 一对，其中key是无序，且不可以重复的，而value是相当于有序，且可以重复的，如下图：