Java核心编程总结(六、常用API与集合）

修饰符 class 类名<泛型变量>{}

• 泛型类的核心思想: 是把出现泛型变量的地方全部替换成传输的真实数据类型

– 需求：模拟ArrayList集合自定义一个集合MyArrayList集合

public static void main(String[] args) {

MyArrayList lists = new MyArrayList();

MyArrayList lists1 = new MyArrayList<>();

lists1.add(“java”);

lists1.add(“mysql”);

// list1.add(12.3); 报错,把出现泛型变量的地方全部替换成传输的String类型

lists1.remove(“java”);

System.out.println(lists1);

}

}

class MyArrayList{

private ArrayList lists = new ArrayList();

public void add(E e){

lists.add(e);

}

public void remove(E e){

lists.remove(e);

}

@Override

public String toString() {

return lists.toString();

}

}

3.3 自定义泛型方法

---

什么是泛型方法？

• 定义了泛型的方法就是泛型方法

泛型方法的定义格式

• 修饰符 <泛型变量> 返回值类型 方法名称(形参列表){}

• 注意：方法定义了什么是泛型变量，后面就只能用什么泛型变量

– 需求：给你任何一个类型的数组，都能返回它的内容

public class GenericDemo {

public static void main(String[] args) {

Integer[] nums = {10 , 20 , 30 , 40 , 50};

String rs1 = arrToString(nums);

System.out.println(rs1);

String[] names = {“贾乃亮”,“王宝绿”,“陈羽凡”};

String rs2 = arrToString(names);

System.out.println(rs2);

}

public static String arrToString(T[] nums){

StringBuilder sb = new StringBuilder();

sb.append(“[”);

if(nums!=null && nums.length > 0){

for(int i = 0 ; i < nums.length ; i++ ){

T ele = nums[i];

sb.append(i == nums.length-1 ? ele : ele+", ");

}

}

sb.append(“]”);

return sb.toString();

}

}

3.4 自定义泛型接口

---

什么是泛型接口？

• 使用了泛型定义的接口就是泛型接口

泛型接口的格式

• 修饰符 interface 接口名称<泛型变量> {}

3.5 泛型的通配符

---

通配符：？

?可以用在使用泛型的时候代表一切类型

E T K V 是在定义泛型的时候使用代表一切类型

泛型的上下限：

<? extends Car>: 那么?必须是Car或者其子类(泛型的上限)

<?super Car>: 那么？必须是Car或者其父类(泛型的下限，不是很常见)

---

---

---

---

---

---

---

---

---

集合重点

4.Collection集合

================================================================================

什么是集合？

• 集合是一个大小可变的容器

• 容器中的每个数据称为一个元素。 数据 == 元素

集合与数组的区别

• 集合中类型可以不确定，大小可以不固定

• 数组中类型和长度一旦定义出来就都固定了

集合的作用

• 在开发中，很多时候元素的个数是不确定的

• 而且要经常进行元素的增删改查操作，集合都是非常合适的

• Collection 集合 是Java中集合的祖宗类，Collection集合的功能是一切集合都可以直接使用的

• 包：import java.util.Collection

4.1 Coleection集合API

---

• public boolean add(E e): 把给定的元素添加到当前集合中

• public void clear(): 清空集合中所有的元素

• public boolean remove(E e)： 把给定的对象在当前集合中删除

• public boolean contains(Object obj): 判断当前集合中是否包含给定的对象

• public boolean isEmpty(): 判断当前集合是否为空

• public int size(): 返回集合中元素的个数

• public Object[] toArray(): 把集合中的元素，储存到数组中

public class CollectionDemo {

public static void main(String[] args) {

// HashSet:添加的元素是无序，不重复，无索引。

Collection sets = new HashSet<>();

// 1.添加元素，添加成功返回true.

System.out.println(sets.add(“贾乃亮”)); // true

System.out.println(sets.add(“贾乃亮”)); // false

System.out.println(sets.add(“王宝强”)); // true

sets.add(“陈羽凡”);

System.out.println(sets); // 集合重写了toString()方法，默认打印出内容信息

// [贾乃亮, 王宝强, 陈羽凡]

// 2.清空集合的元素。

//sets.clear();

//System.out.println(sets);

// 3.判断集合是否为空 是空返回true 反之

System.out.println(sets.isEmpty()); // false

// 4.获取集合的大小

System.out.println(sets.size()); // 3

// 5.判断集合中是否包含某个元素 。

System.out.println(sets.contains(“贾乃亮”));

// 6.删除某个元素:如果有多个重复元素默认删除前面的第一个！

sets.remove(“陈羽凡”);

System.out.println(sets);

// 7.把集合转换成数组

Object[] arrs = sets.toArray();

System.out.println(“数组：”+ Arrays.toString(arrs));

String[] arrs1 = sets.toArray(String[]::new); // 以后再了解，指定转换的数组类型！

System.out.println(“数组：”+ Arrays.toString(arrs1));

System.out.println(“---------------------拓展---------------------------”);

Collection c1 = new ArrayList<>();

c1.add(“李小璐”);

c1.add(“马蓉”);

Collection c2 = new ArrayList<>();

c2.add(“白百合”);

c1.addAll(c2); // 把c2集合的元素全部倒入到c1

System.out.println(c1);

}

}

4.2 Collection集合遍历

---

– Collection 集合的遍历方式有三种：

• 迭代器

• foreach(增强for循环)

• JDK 1.8 开始的新技术 Lambda 表达式(了解)

迭代器遍历集合

• 方法

• public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的

• E next(): 获取下一个元素值

• boolean hasNext(): 判断是否有下一个元素，有返回true,反之

• 流程

1. 先获取当前集合的迭代器

Iterator<String> it = lists.iterator()

2. 定义一个 while 循环， 问一次取一次

• 通过 it.hasNext()询问是否有下一个元素，有就通过

• it.next() 取出下一个元素

public class CollectionDemo{

public static void main(String[] args) {

Collection lists = new ArrayList<>();

lists.add(“赵敏”);

lists.add(“小昭”);

lists.add(“殷素素”);

lists.add(“周芷若”);

System.out.println(lists);

// lists = [赵敏, 小昭, 殷素素, 周芷若]

// 1.得到集合的迭代器对象。

Iterator it = lists.iterator();

// System.out.println(it.next());

// System.out.println(it.next());

// System.out.println(it.next());

// System.out.println(it.next());

// System.out.println(it.next()); // 出现异常NoSuchElementException，出现没有此元素异常！

// 2.使用while循环遍历。

while(it.hasNext()){

String ele = it.next();

System.out.println(ele);

}

}

}

foreach 遍历

• foreach 是一种遍历形式，可以遍历集合或者数组

• foreach 遍历集合实际上是迭代器遍历的简化写法

• foreach 遍历的关键是记住格式

for(被遍历集合或者数组中元素的类型 变量名称:被遍历集合或者数组){

}

public class CollectionDemo{

public static void main(String[] args) {

Collection lists = new ArrayList<>();

lists.add(“赵敏”);

lists.add(“小昭”);

lists.add(“殷素素”);

lists.add(“周芷若”);

System.out.println(lists);

// lists = [赵敏, 小昭, 殷素素, 周芷若]

for (String ele : lists) {

System.out.println(ele);

}

int[] ages = new int[]{17 , 18 , 38 , 21};

for (int age : ages) {

System.out.println(age);

}

}

}

– 缺点：foreach 遍历无法知道遍历到了哪个元素，因为没有索引

Lambda(暂时了解)

• jdk 1.8 开始之后的新技术

public class CollectionDemo03 {

public static void main(String[] args) {

Collection lists = new ArrayList<>();

lists.add(“赵敏”);

lists.add(“小昭”);

lists.add(“殷素素”);

lists.add(“周芷若”);

System.out.println(lists);

// [赵敏, 小昭, 殷素素, 周芷若]

// s

lists.forEach(s -> {

System.out.println(s);

});

// lists.forEach(s -> System.out.println(s));

// lists.forEach(System.out::println);

}

}

4.3 Set集合

---

– Set系列集合：添加的元素是无序，不重复，无索引

• HashSet：添加的元素是无序，不重复，无索引的

• LinkedHashSet: 添加的元素是有序，不重复，无索引的

• TreeSet: 不重复，无索引，按照大小默认升序排列

public class CollectionDemo01 {

public static void main(String[] args) {

// HashSet:添加的元素是无序，不重复，无索引的。

// 多态写法

Collection sets = new HashSet<>();

sets.add(“MyBatis”);

sets.add(“Java”);

sets.add(“Java”);

sets.add(“Spring”);

sets.add(“MySQL”);

sets.add(“MySQL”);

// [Java, MySQL, MyBatis, Spring]

System.out.println(sets);

}

}

4.3.1 HashSet

• HashSet：添加的元素是无序，不重复，无索引的

public class CollectionDemo01 {

public static void main(String[] args) {

// 无序，不重复，无索引的。

Set sets = new HashSet<>(); // 一行经典代码！！

sets.add(“Mybatis”);

sets.add(“Java”);

sets.add(“Java”);

sets.add(“MySQL”);

sets.add(“MySQL”);

sets.add(“Spring”);

// [Java, MySQL, Spring, Mybatis]

System.out.println(sets);

}

}

面试热点：Set 集合添加的元素是不重复的，是如何去重复的

• 对于有值特性的，Set 集合可以直接判断进行去重复

• 对于引用数据类型的类对象，Set 集合是按照如下流程进行是否重复的判断

• 引用数据类型：自己定义的类型，比如自己定义的苹果apple

• Set集合会让两对象先调用自己的hashCode()方法得到彼此的哈希值(所谓的内存地址)

• 然后比较两个对象的哈希值是否相同，如果不相同则直接认为两个对象不重复

• 如果哈希值相同，会继续让两个对象进行equals比较内容是否相同，如果相同认为重复，如果不相同认为不重复

面试热点：Set系列集合元素无序的根本原因(面试必考)

• Set 系列集合添加元素无序的根本原因是因为底层采用了哈希表存储元素

• JDK1.8 之前：哈希表 = 数组 + 链表 + （哈希算法）

• JDK1.8 之后：哈希表 = 数组 + 链表 + 红黑树 + （哈希算法）

• 当链表长度超过 8 时，将链表转换为红黑树，这样大大减少了查找时间

Set 系列集合是基于哈希表存储数据的，它的增删改查的性能都很好，但是它是无序不重复的。

4.4.2 LinkedHashSet

• 是HashSet的子类，元素是 有序，不重复，无索引

• LinkedHashSet底层依然是使用哈希表存储元素的，但是每个元素都额外带一个链来维护添加顺序

• 不光增删查快，还有序

• 缺点是多了一个存储顺序的链会占内存空间，而且不允许重复，无索引

public static void main(String[] args) {

// 有序不重复无索引

Set sets = new LinkedHashSet<>();

sets.add(“Mybatis”);

sets.add(“Java”);

sets.add(“Java”);

sets.add(“MySQL”);

sets.add(“MySQL”);

sets.add(“Spring”);

// [Java, MySQL, Spring, Mybatis]

System.out.println(sets);

}

}

4.4.3 TreeSet

– TreeSet: 不重复，无索引，按照大小默认升序排序

– TreeSet 集合称为排序不重复集合，可以对元素进行默认的升序排序

TreeSet 集合自排序的方式

1. 有值特性的元素直接可以升序排序(整型，浮点型)

2. 字符串类型的元素会按照首字符的编号排序

3. 对于自定义的引用数据类型，TreeSet 默认无法排序，执行的时候直接报错，因为人家不知道排序规则

自定义的引用数据类型的排序实现

– 对于自定义的引用数据类型，TreeSet 默认无法排序

– 所以我们需要定制排序的大小规则，方案有两种

• 直接为对象的类实现比较器规则接口 Comparable，重写比较方法

• 直接为集合设置比较器Comparator对象，重写比较方法

• 如果类和集合都存在大小规则，默认使用集合自带的规则进行大小排序！

4.4 List集合

---

– List系列集合：添加的元素是有序，可重复，有索引

• ArrayList: 添加的元素是有序，可重复，有索引

• LinkedList: 添加的元素是有序，可重复，有索引

• Vector 是线程安全的，速度慢，开发中很少使用

---

• List 集合继承了 Collection 集合的全部功能，同时因为 List 系列集合有索引，所以多了很多按照索引操作元素的功能

• 开发中ArrayList集合用的最多，查询快，增删慢，是基于数组储存数据的

4.4.1 ArrayList 集合

开发中ArrayList集合用的最多！

方法：

• public void add(int index,E element)： 将指定的元素，添加到该集合中的指定位置上

• public E get(int index): 返回集合中指定位置的元素

• public E remove(int index): 移除列表中指定位置的元素，返回的是被移除的元素

• public E set(int index,E element): 用指定元素替换集合中指定位置的元素，返回更新前的元素值

public class ListDemo01 {

public static void main(String[] args) {

// 1.创建一个ArrayList集合对象：这是一行经典代码！

// List:有序，可重复，有索引的。

// 多态写法: 将子类对象给父类类型的接口

List lists = new ArrayList<>();

lists.add(“java1”);

lists.add(“java1”);

lists.add(“java2”);

lists.add(“java2”);

System.out.println(lists);

// [java1, java1, java2, java2]

// 2.在某个索引位置插入元素。

lists.add(2,“MySQL”);

System.out.println(lists);

// [java1, java1, MySQL, java2, java2]

// 3.根据索引删除元素,返回被删除元素

System.out.println(lists.remove(2));

// MySQL

System.out.println(lists);

// [java1, java1, java2, java2]

// 4.根据索引获取元素

System.out.println(lists.get(2));

// java2

// 5.修改索引位置处的元素

lists.set(3,“Mybatis”);

System.out.println(lists);

// [java1, java1, java2, Mybatis]

}

}

4.4.2 List集合的遍历方式

• 4种

• List 系列集合多了索引，所以多了一种按照索引遍历集合的 for 循环

• for循环

• 迭代器

• foreach

• jdk 1.8 之后的 Lambda 表达式

public class ListDemo02 {

public static void main(String[] args) {

// 1.这是一行经典代码

// 将子类对象给父类接口，多态写法

List lists = new ArrayList<>();

lists.add(“java1”);

lists.add(“java2”);

lists.add(“java3”);

/** （1）for循环。 */

for(int i = 0 ; i < lists.size() ; i++ ) {

String ele = lists.get(i);

System.out.println(ele);

}

System.out.println(“-----------------------”);

/** （2）迭代器。 */

Iterator it = lists.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

System.out.println(“-----------------------”);

/** （3）foreach。 */

for(String ele : lists){

System.out.println(ele);

}

System.out.println(“-----------------------”);

/** （4）JDK 1.8开始之后的Lambda表达式*/

lists.forEach(s -> {

System.out.println(s);

});

}

}

4.4.3 LinkedList 集合

• LinkedList 也是List 的实现类,增删快，查询慢，底层是基于链表的

• LinkedList 是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的

• 所以LinkedList 除了拥有 List 集合的全部功能还多了很多操作首尾元素的特殊功能

方法：

• public void addFirst(E,e): 将指定元素插入此列表的开头

• public void addLast(E,e): 将指定元素添加到此列表的结尾

• public E getFirst(): 返回此列表的第一个元素

• public E getLast():返回此列表的最后一个元素

• public E removeFirst:移除并返回此列表的第一个元素

• public E removeLast:移除并返回此列表的最后一个元素

• public E pop():从此列表所表示的堆栈处弹出一个元素

• public void push(E e):将元素推入此列表所表示的堆栈

public class ListDemo03 {

public static void main(String[] args) {

// 1.用LinkedList做一个队列:先进先出，后进后出。

LinkedList queue = new LinkedList<>();

// 入队

queue.addLast(“1号”);

queue.addLast(“2号”);

queue.addLast(“3号”);

queue.addLast(“4号”);

System.out.println(queue); // [1号, 2号, 3号, 4号]

// 出队

System.out.println(queue.removeFirst());

System.out.println(queue.removeFirst());

System.out.println(queue);

// 做一个栈

LinkedList stack = new LinkedList<>();

// 压栈

stack.push(“第1颗子弹”);

stack.push(“第2颗子弹”);

stack.push(“第3颗子弹”);

stack.push(“第4颗子弹”);

System.out.println(stack); // [第4颗子弹, 第3颗子弹, 第2颗子弹, 第1颗子弹]

// 弹栈

System.out.println(stack.pop());

System.out.println(stack.pop());

System.out.println(stack);

}

}

4.4.4 总结

• 查询多而增删少 用ArrayListt集合

• 查询少而增删首尾多 用LinkedList集合

4.5 总结

---

• 如果希望元素可以重复，又有索引，查询要快，用ArrayList集合（用的最多）

• 如果希望元素可以重复，又有索引，增删要快，用LinkedList集合(适合查询元素比较少，经常要首尾操作元素的情况)

• 如果希望增删改查都很快，但是元素不重复以及无序无索引，那么用HashSet集合

• 如果希望增删改查都很快且有序，但是元素不重复无索引，那么用LinkedHashSet集合

4.6 Collections工具类

---

• 包：java.util.Collections

• Collections 并不属于集合，而是用来操作集合的工具类

• 常用API:

• addAll(被添加元素的集合,可变参数) 给集合对象批量添加元素

• public static void shuffle(<?> list):打乱集合顺序(只能打乱有序的List集合)

• public static <T> void sort(List<T> list):将集合中元素按照默认规则排序

• public static <T> void sort(List<T> list,comparator(<? super T>))： 将集合中元素按照指定规则排序

public class CollectionsDemo01 {

public static void main(String[] args) {

// 1.给集合批量添加元素

Collection names = new ArrayList<>();

/**

• 参数一：被添加元素的集合

• 参数二：可变参数，一批元素

*/

Collections.addAll(names,“曹操”,“贾乃亮”,“王宝强”,“陈羽凡”);

System.out.println(names);

//[曹操, 贾乃亮, 王宝强, 陈羽凡]

// 2.打乱集合的顺序：public static void shuffle(List<?> list)

// 注意:只能打乱有序的List集合。

List newnames = new ArrayList<>();

Collections.addAll(newnames,“曹操”,“贾乃亮”,“王宝强”,“陈羽凡”);

Collections.shuffle(newnames); // 打乱顺序

System.out.println(newnames);

//[陈羽凡, 王宝强, 曹操, 贾乃亮]

// 3.public static void sort(List list)：给List集合升序排序。

List scores = new ArrayList<>();

Collections.addAll(scores, 98.5, 66.5 , 59.5 , 66.5 , 99.5 );

Collections.sort(scores); // 默认升序排序！

System.out.println(scores);

//[59.5, 66.5, 66.5, 98.5, 99.5]

}

}

4.7 可变参数

---

• 可变参数用在形参中可以接收多个数据

• 可变参数的格式：数据类型....参数名称

可变参数的作用

• 传输参数非常灵活，方便

• 可以不传输参数

• 可以传输多个参数

• 可以传输一个数组

– 可变参数在方法内部本质上就是一个数组

public static void main(String[] args) {

sum(); // 可以不传输参数。

sum(10); // 可以传输一个参数。

sum(10,20,30); // 可以传输多个参数。

sum(new int[]{10,30,50,70,90}); // 可以传输一个数组。

}

public static void sum(int… nums){

// nums 就是可变参数

// 可变参数在方法内部本质上就是一个数组。

System.out.println(“元素个数：”+nums.length);

System.out.println(“元素内容：”+ Arrays.toString(nums));

System.out.println(“--------------------------”);

}

}

注意：

• 一个形参列表中可变参数只能有一个

• 可变参数必须放在形参列表的最后面

5.Map集合

=========================================================================

• Map集合是一种双列集合，每个元素包含两个值

• Map集合是另一个集合体系，Collection 是单值集合体系

• Map集合的每个元素的格式：key = value(键值对元素)

• Map集合也被称为“键值对集合”

Map集合的作用

1. Map 集合存储的信息更加的具体丰富

2. Map集合的完整格式：{key1 = value1，key2 = value2，key3 = value3，…}

Collection：[“张三”，“中国”，“男”，“法外狂徒”，“23”]

Map：{name = “张三”，jiaxiang = “中国”，sex = “男”，age = “23”}

Map集合的特点：

1. Map 集合的特点都是由键决定的

2. Map 集合的键是无序，不重复，无索引的

• Map 集合后面重复的键对应的元素会覆盖前面的整个元素

3. Map 集合的值无要求

4. Map 集合的键值对都可以为null

• HashMap: 元素按照键是无序，不重复，无索引，值不做要求

• LinkedHashMap: 元素按照键是有序，不重复，无索引，值不做要求

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

我的面试宝典：一线互联网大厂Java核心面试题库

以下是我个人的一些做法，希望可以给各位提供一些帮助：

整理了很长一段时间，拿来复习面试刷题非常合适，其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等，且还会持续的更新…可star一下！

283页的Java进阶核心pdf文档

Java部分：Java基础，集合，并发，多线程，JVM，设计模式

数据结构算法：Java算法，数据结构

开源框架部分：Spring，MyBatis，MVC，netty，tomcat

分布式部分：架构设计，Redis缓存，Zookeeper，kafka，RabbitMQ，负载均衡等

微服务部分：SpringBoot，SpringCloud，Dubbo，Docker

还有源码相关的阅读学习

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
合后面重复的键对应的元素会覆盖前面的整个元素

3. Map 集合的值无要求

4. Map 集合的键值对都可以为null

• HashMap: 元素按照键是无序，不重复，无索引，值不做要求

• LinkedHashMap: 元素按照键是有序，不重复，无索引，值不做要求

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-Q6i3yjLD-1712053161964)]

[外链图片转存中…(img-ViIJYSST-1712053161964)]

[外链图片转存中…(img-Xob0y8eT-1712053161964)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

我的面试宝典：一线互联网大厂Java核心面试题库

以下是我个人的一些做法，希望可以给各位提供一些帮助：

整理了很长一段时间，拿来复习面试刷题非常合适，其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等，且还会持续的更新…可star一下！

[外链图片转存中…(img-aU94q5mN-1712053161965)]

283页的Java进阶核心pdf文档

Java部分：Java基础，集合，并发，多线程，JVM，设计模式

数据结构算法：Java算法，数据结构

开源框架部分：Spring，MyBatis，MVC，netty，tomcat

分布式部分：架构设计，Redis缓存，Zookeeper，kafka，RabbitMQ，负载均衡等

微服务部分：SpringBoot，SpringCloud，Dubbo，Docker

[外链图片转存中…(img-f20rDVbd-1712053161965)]

还有源码相关的阅读学习

[外链图片转存中…(img-3Nzoplhd-1712053161965)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！