10-集合（核心类库）

王宇辉

已于 2022-02-26 09:29:15 修改

阅读量685

点赞数 1

分类专栏： java知识体系文章标签： java 链表数据结构

于 2021-12-14 14:36:19 首次发布

本文链接：https://blog.csdn.net/weixin_42688085/article/details/121920027

版权

本文详细介绍了Java集合框架，包括集合、数据结构如链表、二叉树，以及List、Set、Map接口的特性和常用实现。重点讲解了链表、Map接口下的HashSet和HashMap，强调了Map的存储数据图、特点以及存储元素不重复的原理。此外，还提到了迭代器、增强for循环和Comparable接口的重要性。

摘要由CSDN通过智能技术生成

感谢你的路过，希望学生的笔记能给你一点微不足道的参考（2/100）
Java基础思维导图，完整Java体系的链接
在这里插入图片描述

目录标题

一，集合

1.1为什么要有集合？什么是集合？

我们在学习Java的时候始终在跟数据打交道，如何传输数据，如何接收数据，如何存储数据。在生活中我们有各种各样的容器，比如袋子，碗，水果篮，箱子，甚至车的后备箱都能看作是一个容器。同样的，在java中也存在各种各样的‘容器’，我们把java中所有的‘容器’的总称叫做集合。集合是Java对数据结构成熟的实现。

二，数据结构

2.1链表

   2.1.1什么是链表？
      链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
   2.1.2链表的特点？
      多个结点之间，通过地址进行连接。
      查找元素慢：
      增删元素快：只需要修改连接下个元素的地址即可。
   2.1.3链表共分几类？
      链表常用的有 3 类：单链表、双向链表、循环链表。在这里插入图片描述
      链表的核心操作集有 3 种：插入、删除、查找(遍历）

2.2二叉树

   2.2.1什么是二叉树
      二叉树是树的一种，每个节点最多可具有两个子树，即结点的度最大为 2（结点度：结点拥有的子树数）。
在这里插入图片描述
      例：二叉树.png 树的一些概念

      二叉树就是每个节点不能多于有两个儿子，上面的图就是一颗二叉树，而且还是一种特殊的二叉树：二叉查找树(binary search tree)。
         二叉树的遍历方式二叉树的遍历方式，一般分为先序遍历，中序遍历，后序遍历。
            • 先序遍历 o 先访问根节点，然后访问左节点，最后访问右节点(根->左->右)
            • 中序遍历 o 先访问左节点，然后访问根节点，最后访问右节点(左->根->右)
            • 后序遍历 o 先访问左节点，然后访问右节点，最后访问根节点(左->右->根)
在这里插入图片描述
            先序遍历(根-左-右):1-2-4-8-9-5-10-3-6-7
            中序遍历:(左-根-右):8-4-9-2-10-5-1-6-3-7
            后序遍历(左-右-根):8-9-4-10-5-2-6-7-3-1
     补充红黑树（本质还是二叉查找树）
        红黑树的约束:
            1. 节点可以是红色的或者黑色的
            2. 根节点是黑色的
            3. 叶子节点(特指空节点)是黑色的
            4. 每个红色节点的子节点都是黑色的
            5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同
        特点:
            速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍

2.3栈（联系一下内存）

栈（stack）是限定仅在表尾进行插入和删除操作的线性表。我们把允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈。栈又称为先进后出的线性表。
在这里插入图片描述

简单的说：采用该结构的集合，对元素的存取有如下的特点先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。
例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。栈的入口、出口的都是栈的顶端位置。
队列：

2.4queue

简称队，队列是一种特殊的线性表，是运算受到限制的一种线性表，只允许在表的一端进行插入，而在另一端进行删除元素的线性表。队尾(rear)是允许插入的一端。队头(front)是允许删除的一端。空队列是不含元素的空表。

三，集合框架

在这里插入图片描述

3.1Collection集合

   Collection 接口是在整个 Java 类集中保存单值的最大操作父接口，里面每次操作的时候都只能保存一个对象的数据。定义在 java.util 包中。
      此接口的常用方法如下所示：
在这里插入图片描述
         集合框架
            单列集合java.util.Collection
               java.util.List
               java.util.Set
            双列集合java.util.Map
代码：

package com.wyh;

import java.util.Collection;
import java.util.HashSet;

/*
    java.util.Collection接口
        所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法
        任意的单列集合都可以使用Collection接口中的方法
    共性的方法:
      public boolean add(E e)：  把给定的对象添加到当前集合中 。
      public void clear() :清空集合中所有的元素。
      public boolean remove(E e): 把给定的对象在当前集合中删除。
      public boolean contains(E e): 判断当前集合中是否包含给定的对象。
      public boolean isEmpty(): 判断当前集合是否为空。
      public int size(): 返回集合中元素的个数。
      public Object[] toArray(): 把集合中的元素，存储到数组中。
 */
public class Demo01_Collection {
   
    public static void main(String[] args) {
   
        //创建集合对象,可以使用多态
        //Collection<String> coll = new ArrayList<>();
        Collection<String> coll = new HashSet<>();
        System.out.println(coll);//重写了toString方法  []

        /*
            public boolean add(E e)：  把给定的对象添加到当前集合中 。
            返回值是一个boolean值,一般都返回true,所以可以不用接收
         */
        boolean b1 = coll.add("张三");
        System.out.println("b1:"+b1);//b1:true
        System.out.println(coll);//[张三]
        coll.add("李四");
        coll.add("李四");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll);//[张三, 李四, 赵六, 田七]

         /*
            public boolean remove(E e): 把给定的对象在当前集合中删除。
            返回值是一个boolean值,集合中存在元素,删除元素,返回true
                                集合中不存在元素,删除失败,返回false
         */
        boolean b2 = coll.remove("赵六");
        System.out.println("b2:"+b2);//b2:true

        boolean b3 = coll.remove("赵四");
        System.out.println("b3:"+b3);//b3:false
        System.out.println(coll);//[张三, 李四, 田七]

        /*
            public boolean contains(E e): 判断当前集合中是否包含给定的对象。
            包含返回true
            不包含返回false
         */
        boolean b4 = coll.contains("李四");
        System.out.println("b4:"+b4);//b4:true

        boolean b5 = coll.contains("赵四");
        System.out.println("b5:"+b5);//b5:false

        //public boolean isEmpty(): 判断当前集合是否为空。 集合为空返回true,集合不为空返回false
        boolean b6 = coll.isEmpty();
        System.out.println("b6:"+b6);//b6:false

        //public int size(): 返回集合中元素的个数。
        int size = coll.size();
        System.out.println("size:"+size);//size:3

        //public Object[] toArray(): 把集合中的元素，存储到数组中。
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
   
            System.out.println(arr[i]);
        }

        //public void clear() :清空集合中所有的元素。但是不删除集合,集合还存在
        coll.clear();
        System.out.println(coll);//[]
        System.out.println(coll.isEmpty());//true
    }
}

四，List 接口

4.1什么是List接口？

java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了 List 接口的对象称为List集合。
在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

4.2List接口特点：

   1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、 22、33的顺序完成的）。
   2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
   3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
代码：

package com.wyh.List;
import java.util.ArrayList;
//import java.util.Iterator;
import java.util.List;

/*  List接口中常用方法
    java.util.List接口 extends Collection接口
    List接口的特点:
        1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)
        2.有索引,包含了一些带索引的方法
        3.允许存储重复的元素

    List接口中带索引的方法(特有)
        - public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
        - public E get(int index):返回集合中指定位置的元素。
        - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
        - public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
    注意:
        操作索引的时候,一定要防止索引越界异常
        IndexOutOfBoundsException:索引越界异常,集合会报
        ArrayIndexOutOfBoundsException:数组索引越界异常
        StringIndexOutOfBoundsException:字符串索引越界异常
 */
public class Demo02_List {
   
    public static void main(String[] args) {
   
        //创建一个List集合对象,多态
        List<String> list = new ArrayList<>();
        //使用add方法往集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        //打印集合
        System.out.println(list);//[a, b, c, d, a]  不是地址，重写了toString

        //public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
        //在c和d之间添加一个itheima
        list.add(3,"itheima");//[a, b, c, itheima, d, a]
        System.out.println(list);

        //public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
        //移除元素
        String removeE = list.remove(2);
        System.out.println("被移除的元素:"+removeE);//被移除的元素:c
        System.out.println(list);//[a, b, itheima, d, a]

        //public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
        //把最后一个a,替换为A
        String setE = list.set(4, "A");
        System.out.println("被替换的元素:"+setE);//被替换的元素:a
        System.out.println(list);//[a, b, itheima, d, A]

        //List集合遍历有3种方式
        //使用普通的for循环
        for(int i=0; i<list.size(); i++){
   
            //public E get(int index):返回集合中指定位置的元素。
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("-----------------");
       /* //使用迭代器
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }*/
        System.out.println("-----------------");
        //使用增强for
        for (String s : list) {
   
            System.out.println(s);
        }

        String r = list.get(5);//IndexOutOfBoundsException: Index 5 out-of-bounds for length 5
        System.out.println(r);
    }
}

4.3List功能及其子类：

在这里插入图片描述
代码：

package com.wyh.List;
import java.util.LinkedList;

/*  LinkedList集合中的方法（与List特性相对）
    java.util.LinkedList集合 implements List接口
    LinkedList集合的特点:
        1.底层是一个链表结构:查询慢,增删快
        2.里边包含了大量操作首尾元素的方法
        注意:使用LinkedList集合特有的方法,不能使用多态

        - public void addFirst(E e):将指定元素插入此列表的开头。
        - public void addLast(E e):将指定元素添加到此列表的结尾。
        - public void push(E e):将元素推入此列表所表示的堆栈。

        - public E getFirst():返回此列表的第一个元素。
        - public E getLast():返回此列表的最后一个元素。

        - public E removeFirst():移除并返回此列表的第一个元素。
        - public E removeLast():移除并返回此列表的最后一个元素。
        - public E pop():从此列表所表示的堆栈处弹出一个元素。

        - public boolean isEmpty()：如果列表不包含元素，则返回true。

 */
public class Demo03_LinkedList {
   
    public static void main(String[] args) {
   
        show03();
    }

    /*
        - public E removeFirst():移除并返回此列表的第一个元素。
        - public E removeLast():移除并返回此列表的最后一个元素。
        - public E pop():从此列表所表示的堆栈处弹出一个元素。此方法相当于 removeFirst
     */
    private static void show03() {
   
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);//[a, b, c]

        //String first = linked.removeFirst();
        String first = linked.pop();
        System.out.println("被移除的第一个元素:"+first);
        String last = linked.removeLast();
        System.out.println("被移除的最后一个元素:"+last);
        System.out.println(