【连载】Java笔记——你所不知道的集合框架

我是灼灼，一只初学Java的大一金渐层。
向往余秀华和狄兰·托马斯的疯狂，时常沉溺于将情感以诗相寄；追逐过王尔德、王小波的文字，后陷于毛姆和斯蒂芬·金不可自拔；热爱文学的浪潮，白日梦到底却总在现实里清醒；艳羡平静又极度渴盼奔跑的力量。
欢迎与我交流鸭· QQ:1517526827；
个人博客：https://blog.csdn.net/weixin_52777510?spm=1001.2101.3001.5343

Java笔记——集合

Java笔记正在连载中，欢迎来其他内容逛逛哟~

相关内容如下：
【连载1】Java笔记——基本结构与流程控制
【连载2】Java笔记——数组操作
【连载3】Java笔记——面向对象编程
【连载4】Java笔记——Java核心类
【连载5】Java笔记——异常处理
【连载6】Java笔记——反射和注解
【连载7】Java笔记——泛型
【连载8】Java笔记——集合
【连载9】MySQL学习笔记
【连载10】JDBC学习笔记
【连载11】Git和GitHub的使用笔记

---

笔记内容来源于廖雪峰官方网站~

Java集合简介

思维导图如下：

迭代器

迭代器用法简介：

迭代器简介（Iterator）

迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

Java中的Iterator功能比较简单，并且只能单向移动：

(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

(2) 使用next()获得序列中的下一个元素。

(3) 使用hasNext()检查序列中是否还有元素。

(4) 使用remove()将迭代器新返回的元素删除。

Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

使用List

思维导图如下：

ArrayList和LinkedList对比：

ArrayList	LinkedList
获取指定元素	速度很快	需要从头开始查找元素
添加元素到末尾	速度很快	速度很快
在指定位置添加/删除	需要移动元素	不需要移动元素
内存占用	少	较大

使用equals方法

思维导图如下：

使用Map

思维导图如下：

用Map来实现根据name查询某个Student的代码如下：

import java.util.HashMap;
import java.util.Map; 

public class Main {
    public static void main(String[] args) {
        Student s = new Student("Xiao Ming", 99);
        Map<String, Student> map = new HashMap<>();
        map.put("Xiao Ming", s); // 将"Xiao Ming"和Student实例映射并关联
        Student target = map.get("Xiao Ming"); // 通过key查找并返回映射的Student实例
        System.out.println(target == s); // true，同一个实例
        System.out.println(target.score); // 99
        Student another = map.get("Bob"); // 通过另一个key查找
        System.out.println(another); // 未找到返回null
    }
}

class Student {
    public String name;
    public int score;
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
}

编写equals和hashCode

思维导图如下：

正确覆写hashCode方法举例：

public class Person {
    String firstName;
    String lastName;
    int age;

    @Override
    int hashCode() {
        int h = 0;
        h = 31 * h + firstName.hashCode();
        h = 31 * h + lastName.hashCode();
        h = 31 * h + age;
        return h;
    }
}

这里的String类已经正确实现了hashCode()方法；

在计算Person的hashCode()时，反复使用31*h，这样做的目的是为了尽量把不同的Person实例的hashCode()均匀分布到整个int范围；

EnumMap和TreeMap的使用

思维导图如下：

Properties的使用

思维导图如下：

Set使用

思维导图如下：

HashSet是对HashMap的一个简单封装，核心代码如下：

public class HashSet<E> implements Set<E> {
    // 持有一个HashMap:
    private HashMap<E, Object> map = new HashMap<>();

    // 放入HashMap的value:
    private static final Object PRESENT = new Object();

    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }

    public boolean contains(Object o) {
        return map.containsKey(o);
    }

    public boolean remove(Object o) {
        return map.remove(o) == PRESENT;
    }
}

队列

思维导图如下：

使用Deque

比较Queue和Deque出队和入队的方法：

	Queue	Deque
添加元素到队尾	add(E e) / offer(E e)	addLast(E e) / offerLast(E e)
取队首元素并删除	E remove() / E poll()	E removeFirst() / E pollFirst()
取队首元素但不删除	E element() / E peek()	E getFirst() / E peekFirst()
添加元素到队首	无	addFirst(E e) / offerFirst(E e)
取队尾元素并删除	无	E removeLast() / E pollLast()
取队尾元素但不删除	无	E getLast() / E peekLast()

使用Stack

思维导图如下：

把一个int整数12500转换为十六进制表示的字符串功能实现？

首先准备一个空栈：

│   │
│   │
│   │
│   │
│   │
│   │
│   │
│   │
└───┘

然后计算12500÷16=781…4，余数是4，把余数4压栈：

│   │
│   │
│   │
│   │
│   │
│   │
│   │
│ 4 │
└───┘

然后计算781÷16=48…13，余数是13，13的十六进制用字母D表示，把余数D压栈：

│   │
│   │
│   │
│   │
│   │
│ D │
│   │
│ 4 │
└───┘

然后计算48÷16=3…0，余数是0，把余数0压栈：

│   │
│   │
│   │
│ 0 │
│   │
│ D │
│   │
│ 4 │
└───┘

最后计算3÷16=0…3，余数是3，把余数3压栈：

│   │
│ 3 │
│   │
│ 0 │
│   │
│ D │
│   │
│ 4 │
└───┘

当商是0的时候，计算结束，我们把栈的所有元素依次弹出，组成字符串30D4，这就是十进制整数12500的十六进制表示的字符串。

如何通过栈计算后缀表达式：

中缀1 + 2 * (9 - 5)，转换为后缀：1 2 9 5 - * +，运算如下：

计算后缀表达式不考虑优先级，直接从左到右依次计算，因此计算起来简单。首先准备一个空的栈：

│   │
│   │
│   │
│   │
│   │
│   │
│   │
│   │
└───┘

然后依次扫描后缀表达式1 2 9 5 - * +，遇到数字1，就直接扔到栈里：

│   │
│   │
│   │
│   │
│   │
│   │
│   │
│ 1 │
└───┘

紧接着，遇到数字2，9，5，也扔到栈里：

│   │
│ 5 │
│   │
│ 9 │
│   │
│ 2 │
│   │
│ 1 │
└───┘

接下来遇到减号时，弹出栈顶的两个元素，并计算9-5=4，把结果4压栈：

│   │
│   │
│   │
│ 4 │
│   │
│ 2 │
│   │
│ 1 │
└───┘

接下来遇到*号时，弹出栈顶的两个元素，并计算2*4=8，把结果8压栈：

│   │
│   │
│   │
│   │
│   │
│ 8 │
│   │
│ 1 │
└───┘

接下来遇到+号时，弹出栈顶的两个元素，并计算1+8=9，把结果9压栈：

│   │
│   │
│   │
│   │
│   │
│   │
│   │
│ 9 │
└───┘

扫描结束后，没有更多的计算了，弹出栈的唯一一个元素，得到计算结果9。

迭代器Iterator使用

思维导图如下：

Collections使用

思维导图如下：

集合整章复习

思维导图如下：

这个总结的比较杂乱，还是有点冗杂；

集合的笔记到这里就结束啦~

如果对你有帮助的话不要忘记一键三连噢~
谢谢鸭~

初次编写于2021//16日；

一改于2021/1/25日。