大家好，我是程序猿小马，沪漂一族！
写文章就是对于平时的总结以及大家共同学习进步，早日码出各自的梦想😊
坐标：飞机上的上海
文章目录
1、集合的理解和好处
集合框架：用于存储数据的容器。
集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。
任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。
接口：表示集合的抽象数据类型。接口允许我们操作集合时不必关注具体实现，从而达到“多态”。在面向对象编程语言中，接口通常用来形成规范。
实现：集合接口的具体实现，是重用性很高的数据结构。
算法：在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算的方法，例如查找、排序等。这些算法通常是多态的，因为相同的方法可以在同一个接口被多个类实现时有不同的表现。事实上，算法是可复用的函数。
它减少了程序设计的辛劳。
上面是集合得一些概念，其实小马觉得你记住下面几点特点就行了
- 可以动态保存任意多个对象，使用比较方便！
- 提供了一系列方便的操作对象的方法：add、remove、set、get等
- 使用集合添加,删除新元素的示意代码- 简洁了
- 可以方便地扩展或改写集合，提高代码复用性和可操作性。
- 通过使用JDK自带的集合类，可以降低代码维护和学习新API成本。
集合的框架体系
注：这并不是全部的，只是日常开发中常用的一些集合，最常用的还是ArrayList和HashMap
2、单列集合（Collection）
- 有很多方法，是抽象，需要子类来实现…
- collection可以存放多个元素，每个元素可以是Object
- 有些Collection的实现类，可以存放重复的元素，有些不可以
- 有些Collection的实现类，是有序的，有些不是有序
- Collection接口没有直接的实现子类，通过它的子接口Set 和 List 来实现Collection即可
- List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。
- Set：无序(存入和取出顺序有可能不一致)，不可以存储重复元素。必须保证元素唯一性。
Collection的常用方法这里就不举例了，因为日常开发中基础都是用它的子类来完成的（下面子类会详细的讲一下他的方法使用），下面就说一下它的遍历方式
Collection的遍历方式：
- Iterator(迭代器)
代码演示：
Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中",10.1));
col.add(new Book("小李飞刀", "古龙",5.1));
col.add(new Book("红楼梦", "曹雪芹",34.6));
col.add(new Book("十万个为什么", "佚名",16.7));
Iterator iterator = col.iterator();
while(iterator.hasNext()) { //判断是否还有下一个对象
//object 编译类型 Object 运行类型 Book
Book book = (Book)iterator.next(); //1. 导致迭代器指针下移,同时把它指向的对象返回
System.out.println(book);
}
- for循环增强
代码演示：
Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中",10.1));
col.add(new Book("小李飞刀", "古龙",5.1));
col.add(new Book("红楼梦", "曹雪芹",34.6));
col.add(new Book("十万个为什么", "佚名",16.7));
for (Object o : col) {
System.out.println(o);
}
2.1 List
简述：
- List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
- List集合中的每个元素都有其对应的顺序索引，即支持索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
- JDK API中List接口的常用的实现类有：ArrayList、Vector、LinkedList
验证1和2的代码演示：
List list = new ArrayList();
list.add("五五开");
list.add("微笑");
list.add("meiko");
list.add("厂长");
list.add("厂长");
list.add("The Shy");
System.out.println(list);
System.out.println(list.get(1));// 微笑
System.out.println(list.get(4));// 厂长
常用方法：
| api | 解释 |
|---|---|
| void add(int index, Object ele) | 在index位置插入ele元素 |
| boolean addAll(int index, Collection eles) | 从index位置开始将eles中的所有元素添加进来 |
| Object get(int index) | 获取指定index位置的元素 |
| int indexOf(Object obj) | 返回obj在集合中首次出现的位置 |
| int lastIndexOf(Object obj) | 返回obj在当前集合中末次出现的位置 |
| Object remove(int index) | 移除指定index位置的元素，并返回此元素 |
| Object set(int index, Object ele) | 设置指定index位置的元素为ele , 相当于是替换 |
| List subList(int fromIndex, int toIndex) | 返回从fromIndex到toIndex位置的子集合 |
代码演示：
// 初始值
List list = new ArrayList();
list.add("北京");
list.add("天津");
list.add("上海");
list.add("重庆");
//1.void add(int index, Object ele):在index位置插入ele元素
//希望在上海后插入杭州
list.add(3, "杭州");
System.out.println("list=" + list);// [北京, 天津, 上海, 杭州, 重庆]
//2.boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Collection c = new ArrayList();
c.add("五五开");
c.add("约德尔人");
// 在北京后插入五五开,约德尔人
list.addAll(1, c);
System.out.println("list=" + list); // [北京, 五五开, 约德尔人, 天津, 上海, 杭州, 重庆]
//3.Object get(int index):获取指定index位置的元素
//希望获取到约德尔人
System.out.println(list.get(2));//约德尔人
//4. int indexOf(Object obj):返回obj在集合中首次出现的位置, 如果没有返回 -1
System.out.println("五五开的位置=" + list.indexOf("五五开"));//1
//5. int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置, 如果没有返回 -1
list.add("五五开");
list.add("沫子");
System.out.println("最后的五五开位置=" + list.lastIndexOf("五五开"));//7
//6. Object remove(int index):移除指定index位置的元素，并返回此元素
//希望删除最后的最后的五五开
list.remove(list.lastIndexOf("五五开"));
System.out.println("删除后list=" + list);//[北京, 五五开, 约德尔人, 天津, 上海, 杭州, 重庆]
//7.Object set(int index, Object ele):设置指定index位置的元素为ele , 相当于是替换, 索引不对，提示越界
//希望： 约德尔人 改成 智勋
list.set(list.indexOf("约德尔人"), "智勋");
System.out.println("修改后list=" + list);//[北京, 五五开, 智勋, 天津, 上海, 杭州, 重庆, 沫子]
//8. List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
List subList = list.subList(list.indexOf("五五开"), list.indexOf("沫子") + 1);
System.out.println("subList=" + subList);//[五五开, 智勋, 天津, 上海, 杭州, 重庆, 沫子]
2.1.1 ArrayList
简述：
- ArrayList实现了List的接口，底层是一个数组，并实现可变的功能
- ArrayList实现了List所有的操作
- ArrayList 可以加入null,并且多个
- ArrayList 是由数组来实现数据存储的
- ArrayList 基本等同于 Vector , 除了 ArrayList 是线程不安全，但是执行效率高
ArrayList的底层操作机制分析：
- ArrayList 中维护了一个 Object 类型的数组 elementData.
transient Object[] elementData; - 当创建对象时，如果使用的是无参构造器，则初始 elementData 容量为 0（jdk7
是 10） - 当添加元素时：先判断是否需要扩容，如果需要扩容，则调用 grow 方法，
否则直接添加元素到合适位置 - 如果使用的是无参构造器，如果第一次添加，需要扩容的话，则扩容
elementData 为 10，如果需要再次扩容的话，则扩容 elementData 为 1.5 倍。 - 如果使用的是指定容量 capacity 的构造器，则初始 elementData 容量为
capacity，如果需要扩容，则直接扩容 elementData 为 1.5 倍。
翻看当时总结这个扩容机制的流程图，当时小马总结了好久🧐 感兴趣的小伙伴可以尝试的追一下源码
总结的来讲：
- 如果是有参构造每次扩容就是1.5倍
- 如果是无参构造
- 第一次扩容为10
- 从第二次开始按1.5倍扩容
2.1.2 Vector
简述：
- Vector 类的定义说明
- The Vector class implements a growable array of objects [Vector 底层也是一个
可变对象数组] protected Object[] elementData; - Vector 是线程同步的，即线程安全, Vector 类的操作方法带有 synchronized
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
- 在开发中，主要使用 ArrayList ,只有在确实需要线程同步安全时，才考虑使
用 Vector
Vector的底层操作机制分析：
由于Vector在日常中用的不是很多，这里小马觉得只需要记住概念即可：
- 如果是无参构造，默认大小为10，满了之后，每次扩容按2倍大小扩容
- 如果是有参构造，则每次直接按照两倍大小扩容
2.1.3 LinkedList
简述：
- LinkedList实现了双向链表(数据结构)和双端队列特点
- 实现了List接口的所有操作
- 可以添加任意元素(元素可以重复)，包括null
- 线程不安全，没有实现同步
LinkedList的底层操作机制
- LinkedList底层维护了一个双向链表.
- LinkedList中维护了两个属性first和last分别指向 首节点和尾节点
- 每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表.
- 所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。
LinkedList的增删改查案例
//说明
//1. LinkedList 底层是使用双向链表来实现
//2. 因此它的增加数据，比较简单, 基于链表
//3. 可以添加重复的数据，而且是有序
LinkedList linkedList = new LinkedList();
for (int i = 0; i < 5; i++) {
linkedList.add("Gork" + i);
}
System.out.println(linkedList);// [Gork0, Gork1, Gork2, Gork3, Gork4]
String s = "五五开";
linkedList.add(s);
linkedList.add(s);
//遍历
for (Object object : linkedList) {
System.out.print(object + " ");//Gork0 Gork1 Gork2 Gork3 Gork4 五五开 五五开
}
//删除, 根据 索引
linkedList.remove(0);
System.out.println("删除后=" + linkedList);// [Gork1, Gork2, Gork3, Gork4, 五五开, 五五开]
linkedList.remove(s);//这里只删除一个，就结束
System.out.println("删除后=" + linkedList);// [Gork1, Gork2, Gork3, Gork4, 五五开]
//修改, set 方法
linkedList.set(0, "卢本伟");
System.out.println(linkedList);//[卢本伟, Gork2, Gork3, Gork4, 五五开]
//查找的方法
//1. 根据索引来获取
Object object = linkedList.get(0);
System.out.println(object);//卢本伟
//2.因为LinkedList 是双向链表，因此支持 getFirst 和 getLast 获取第一个和最后一个元素
System.out.println(linkedList.getFirst());//卢本伟
System.out.println(linkedList.getLast());//五五开
//遍历方法
//1.增强for
for (Object ob : linkedList) {
System.out.print(ob + " ");//卢本伟 Gork2 Gork3 Gork4 五五开
}
//2.迭代器
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");//卢本伟 Gork2 Gork3 Gork4 五五开
}
//3.可以普通
for (int i = 0; i < linkedList.size(); i++) {
System.out.print(linkedList.get(i) + " ");//卢本伟 Gork2 Gork3 Gork4 五五开
}
2.1.4 ArrayList、LinkedList、Vector 的区别
| 底层结构 | 同步性 | 效率 | 扩容机制 | |
|---|---|---|---|---|
| ArrayList | 可变数组 | 不同步 | 增删慢，查询快 | 有参1.5倍；无参默认10，第二次按照1.5倍扩容 |
| LinkedList | 双向链表 | 不同步 | 增删快，查询慢 | / |
| Vector | 可变数组 | 同步 | 增删慢，查询快 | 有参2倍，无参默认10，第二次按2倍扩容 |
如何选择他们：
- 如果我们改查的操作多，选择 ArrayList
- 如果我们增删的操作多，选择 LinkedList
- 一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择 ArrayList
- 在一个项目中，根据业务灵活选择，也可能这样，一个模块使用的是 ArrayList,
另外一个模块是 LinkedList. - 保证同步才选择Vector，但日常开发中使用的频率相对较低
2.2 Set
简述：
- 无序（添加和取出的顺序不一致），没有索引
- 不允许重复元素(hashCode+equals)，所以最多包含一个null
- JDK API中Set接口的实现类有：
Set接口的遍历方式
- 由于Set没有索引所以它只有两种遍历方式
- Iterator迭代器
- 增强for循环
代码演示：
Set<String> set = new HashSet<>();
set.add("Gork");
set.add("五五开");
set.add("五五开");// 重复, 加入不了
set.add("微笑");
set.add(null);
set.add(null); // 重复, 加入不了
//遍历
//遍历方式1 迭代器
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Object object = iterator.next();
System.out.print(object + " ");// Gork 五五开 null 微笑
}
//遍历方式2 增强for
for(Object obj: set) {
System.out.print(obj + " ");// Gork 五五开 null 微笑
}
常用方法：
和List接口一样, Set接口也是Collection接口的子接口，因此，常用方法和Collection接口一样，下面简单的举例说明一下
| api | 解释 |
|---|---|
| add | 添加单个元素 |
| remove | 删除指定元素 |
| contains | 查找元素是否存在 |
| size | 获取元素个数 |
| isEmpty | 判断是否为空 |
| clear | 清空 |
| addAll | 添加多个元素 |
| containsAll | 查找多个元素是否都存在 |
| removeAll | 删除多个元素 |
代码演示：
Set c = new HashSet();
//1.add:添加单个元素
c.add("Gork");
c.add("五五开");
c.add(999);
c.add(true);
System.out.println(c);// [Gork, 五五开, 999, true]
//2.remove:删除指定元素
c.remove(999);
System.out.println(c);// [Gork, 五五开, true]
//3.contains:查找元素是否存在
System.out.println(c.contains("Gork")); //true
//4.size:获取元素个数
System.out.println("c的size=" + c.size());//3
//5.isEmpty:判断是否为空
System.out.println(c.isEmpty());//false
//6.clear:清空 把当前集合的所有的元素都删除
c.clear();
System.out.println(c); //[]
//7.addAll:添加多个元素, 注意，将结合的所有元素取出，加入,add 作为整体添加
Set c2 = new HashSet();
c2.add("卢本伟");
c2.add("The Shy");
c2.add(888);
c2.add(true);
c.addAll(c2);
System.out.println(c); //[卢本伟, The Shy, 888, true]
//8.containsAll:查找多个元素是否都存在
Set c3 = new HashSet();
c3.add(888);
c3.add(true);
System.out.println(c.containsAll(c3));//true
//9.removeAll：删除多个元素, 注意，如果c中有多个相同值，会一起删除
c.removeAll(c3);
System.out.println(c);//[卢本伟, The Shy]
2.2.1 HashSet
简述：
- HashSet实现了Set接口
- HashSet实际上是HashMap , 看下源码.
public HashSet() {
map = new HashMap<>();
}
- 可以存放null值，但是只能有一个null
- HashSet不保证元素是有序的，取决于 hash 后，再确定索引的结果。（即，不保证存放元素的顺序和取出顺序一致）
- 不能有重复元素
HashSet底层机制说明：
- HashSet 底层是 HashMap。
- 添加一个元素时，先得到 hash 值 -> 会转成 -> 索引值。
- 找到存储数据表 table，看这个索引位置是否已经存放的有元素。
- 如果没有，直接加入。
- 如果有，调用 equals 方法比较，如果相同，就放弃添加，如果不相同，则添加到最后。
- 在 Java8 中，如果一条链表的元素个数达到 TREEIFY_THRESHOLD（默认是8），并且 table 的大小 >= 2) MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树）。
2.2.2 LinkedHashSet
简述：
- LinkedHashSet 是 HashSet 的子类
- LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用链表维护元素的次序(图)，这使得元素看起来是以插入顺序保存的。
- LinkedHashSet添加性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。(因为底层维护了一个hash 表+ 双向链表)
- LinkedHashSet 不允许集合元素重复
- LinkedHashSet 底层是一个 LinkedHashMap，维护的链表是一个双向链表(后图)
HashSet、TreeSet、LinkedHashSet的区别
TreeSet小马这里没有整理，开发中基本没用过，但是面试懂得都懂，借用ThinkWon老哥总结的非常详细的一张图
总结：
- HashSet是一个通用功能的Set
- LinkedHashSet 提供元素插入顺序保证
- TreeSet是一个SortedSet实现，由Comparator 或者 Comparable指定的元素顺序存储元素。
3、双列集合（Map）
简述：
- Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value
- Map 中的 key 和 value 都可以是任何引用类型的数据
- Map 中的 key 用Set来存放，不允许重复[使用hashcode+equals]
- Map 中的 value 可以重复。是使用 Collection存放
- Map 的key 可以为 null, value 也可以为null
- 常用String类作为Map的“键”
- key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value
- Map元素是无序的，因为key是用Set来存放的。而Set 本身是无序的
- Map存放数据的key-value示意图, 把一对 k-v 称为 Entry
Map接口常用方法
| api | 解释 |
|---|---|
| put | 添加 |
| remove | 根据键删除映射关系 |
| get | 根据键获取值 |
| size | 获取元素个数 |
| isEmpty | 判断个数是否为0 |
| clear | 清除 |
| containsKey | 查找键是否存在 |
代码演示：
Map map = new HashMap();
//1. put:添加
map.put("五五开", "卢本伟");
map.put("Gork", "小马");
map.put("微笑", "高学成");
map.put("The Shy", "上路天花板");
map.put("Faker", "大魔王");
System.out.println(map);//{五五开=卢本伟, Gork=小马, Faker=大魔王, The Shy=上路天花板, 微笑=高学成}
//2.remove:根据键删除映射关系
//说明，如果remove 的 key 不存在，也不会报错.
map.remove("Faker");
System.out.println(map);//{五五开=卢本伟, Gork=小马, The Shy=上路天花板, 微笑=高学成}
//3.get：根据键获取值
System.out.println(map.get("五五开"));//卢本伟
//4.size:获取key-value 的个数
System.out.println(map.size());//4
//5.isEmpty:判断个数是否为0
System.out.println(map.isEmpty());//false
//7.containsKey:判断 查找键是否存在
System.out.println(map.containsKey("The Shy"));//true
System.out.println(map.containsKey("Faker"));//false
//6.clear:清除
map.clear();
System.out.println(map);//{}
3.1 HashMap
简述：
- HashMap是 Map 接口使用频率最高的实现类。
- HashMap 是以 key-val 对的方式来存储数据
- key 不能重复，但是是值可以重复,允许使用null键和null值。
- 如果添加相同的key , 则会覆盖原来的key-val ,等同于修改.(key不会替换，val会替换)
- 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的.
- HashMap没有实现同步，因此是线程不安全的
HashMap底层机制说明
在JDK1.6，JDK1.7中，HashMap采用位桶（数组）+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。
-
HashMap在jdk7与8两个版本中有什么区别？
-
数据结构不同：
1.7中的HashMap是数组+链表的结构
1.8中的HashMap是数组+链表+红黑树的结构 -
链表插入方式不同：
1.7使用的是头插法,头插法在进行扩容时存在线程安全问题导致链表死循环
1.8使用的是尾插法 -
扩容后重新计算索引的方式不同：
1.7将会使用扩容后的大小重新与hash计算索引
1.8会判断之前hash中需要加入计算索引位置是0还是1，是0则保持原位，1则在现在索引的基础上加上新增的容量则是计算后的索引
-
-
HashMap的工作原理
HashMap主要用于存放键值对，由数组、链表、红黑树构成，他会对键的值进行Hash运算获得对应的索引去数组中存取节点，如果发生哈希冲突则会形成链表，新的元素将会放在最后，当链表长度大于8，数组容量大于64时会根据当前链表形成红黑树。当红黑树中节点小于6时会转换回链表。
3.2 Hashtable
简述：
- 该类实现hashtable
- 元素是键值对
- hashtable的键和值都不能为null
- hashTable 基本上和hashMap一样的
- 但是hashTable是线程安全的，hashMap是线程不安全的
3.3 TreeMap
简述：
- 不允许出现重复的key
- 可以插入null键，null值
- 可以对元素进行排序
- 无序集合（插入和遍历顺序不一致）
Hashtable、TreeMap这两个开发中小马用的并不多，所以哪里写的不到位大家可以在评论区提出不同的见解！
3.4 HashMap、HashTable、TreeMap的区别
4、开发中如何选择集合实现类
5、 Collections工具类
简述：
- Collections 是一个操作 Set、List 和 Map 等集合的工具类
- Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
常用方法：
| api | 解释 |
|---|---|
| reverse(List) | 反转 List 中元素的顺序 |
| shuffle(List) | 对 List 集合元素进行随机排序 |
| sort(List) | 根据元素的自然顺序对指定 List 集合元素按升序排序 |
| sort(List，Comparator) | 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序 |
| swap(List，int i， int j) | 将指定 list 集合中的 i 处元素和 j 处元素进行交换 |
| Object max(Collection) | 根据元素的自然顺序，返回给定集合中的最大元素 |
| Object max(Collection，Comparator) | 根据 Comparator 指定的顺序，返回给定集合中的最大元素 |
| Object min(Collection) | 根据元素的自然顺序，返回给定集合中的最小元素 |
| Object min(Collection，Comparator) | 根据 Comparator 指定的顺序，返回给定集合中的最小元素 |
| int frequency(Collection，Object) | 返回指定集合中指定元素的出现次数 |
| void copy(List dest,List src) | 将src中的内容复制到dest中 |
| boolean replaceAll(List list，Object oldVal，Object newVal) | 使用新值替换 List 对象的所有旧值 |
代码演示：
List list = new ArrayList();
list.add("Gork");
list.add("五五开");
list.add("The Shy");
list.add("小马");
list.add("小马");
list.add("小陆");
list.add("微笑");
list.add("LOL");
System.out.println("list=" + list);//list=[Gork, 五五开, The Shy, 小马, 小马, 小陆, 微笑, LOL]
//1.reverse(List)：反转List中元素的顺序
Collections.reverse(list);
System.out.println("反转后list：" + list);//反转后list：[LOL, 微笑, 小陆, 小马, 小马, The Shy, 五五开, Gork]
//2.shuffle(List)：对 List 集合元素进行随机排序
Collections.shuffle(list);
System.out.println("随机排序list：" + list);//随机排序list：[小马, LOL, 小陆, 微笑, 小马, The Shy, Gork, 五五开]
//3.sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
Collections.sort(list);
System.out.println("自然排序：" + list);//自然排序：[Gork, LOL, The Shy, 五五开, 小陆, 小马, 小马, 微笑]
//4.sort(List,Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
//要求，按照长度的从大到小..
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o2).length() - ((String)o1).length();
}
});
System.out.println("排序后list：" + list);//排序后list：[The Shy, Gork, LOL, 五五开, 小陆, 小马, 小马, 微笑]
//5.swap(List,int i,int j)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Collections.swap(list, 0, 2);
System.out.println("交换后:" + list);//交换后:[LOL, Gork, The Shy, 五五开, 小陆, 小马, 小马, 微笑]
//6.Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
System.out.println(Collections.max(list));//微笑
//7. Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
System.out.println(Collections.max(list,new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length() - ((String)o2).length();
}
}));//The Shy
//8.Object min(Collection)
System.out.println(Collections.min(list));//Gork
//9.Object min(Collection，Comparator)
System.out.println(Collections.min(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length() - ((String)o2).length();
}
}));//小陆
//10. int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
System.out.println(Collections.frequency(list, "小马"));//2
//11. void copy(List dest,List src)
List dest = new ArrayList();
for (int i = 0; i < list.size(); i++) {
dest.add(i);
}
Collections.copy(dest , list);
System.out.println(dest);//[LOL, Gork, The Shy, 五五开, 小陆, 小马, 小马, 微笑]
//12.boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
Collections.replaceAll(list, "LOL", "英雄联盟");
System.out.println("替换后list：" + list);//替换后list：[英雄联盟, Gork, The Shy, 五五开, 小陆, 小马, 小马, 微笑]
每日小结
- 小马觉得ArrayList和HashMap这两个一定要熟悉它的使用，开发中大部分使用的还是他们
- 扩容机制有能力的小伙伴一定要了解一下，面试说不定就问到了
- Collections工具类可以动手敲一下，它会使我们的开发效率事半功倍
以上就是小马今天要发的内容，这篇文章小马也是整理了很久，欢迎大家互相学习，共同进步，也可以在评论区互动哦！👇
4433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
