笔记目录:(https://www.cnblogs.com/wenjie2000/p/16378441.html)
前面我们保存多个数据使用的是数组,那么数组有不足的地方,我们分析一下。
●数组
写出Person数组扩容示意代码。
Person[] pers = new Person[1]; // 大小是1
pers[0] = new Person();
//增加新的Person对象 ?
Person[]pers2 = new Person[pers.length + 1];//新创建数组
for(){} //拷贝pers数组的元素到pers2
pers2[pers2.length - 1] = new Person();//添加新的对象
集合
集合的框架体系
Java的集合类很多,主要分为两大类,如图:[背下来]
//老韩解读
//1。集合主要是两组(单列集合,双列集合)
//2. Collection接口有两个重要的子接口 List Set,他们的实现子类都是单列集合
//3. Map接口的实现子类是双列集合,存放的 K-V
//4。把老师梳理的两张图记住
//collection
//Map
ArrayList arrayList = new ArrayList();
arrayList.add("jack ");
arrayList.add("tom");
HashMap hashMap = new HashMap();
hashMap.put("NO1", "北京");
hashMap.put("NO2","上海");
Collection接口实现类的特点
Collection接口常用方法,以实现子类ArrayList来演示.
add:添加单个元素
remove:删除指定元素
contains:查找元素是否存在
size:获取元素个数
isEmpty:判断是否为空
clear:清空
addAll:添加多个元素
containsAll:查找多个元素是否都存在
removeAll:删除多个元素
说明:以ArrayList实现类来演示.
List list = new ArrayList();
//add :添加单个元素
list.add("jack");
list.add(10);//此处10自动转为Integer类型 list.add(new Integer(10))
list.add(true);
System.out.println("list=" + list);//list=[jack, 10, true]
//remove:删除指定元素
//list.remove(0);//删除第一个元素
list.remove(true) ;//指定删除某个元素
list.remove((Integer)10);//如果直接填10,java会认为是移除列表中第11个对象
System.out.println("list=" + list);//list=[jack]
//contains:查找元素是否存在
System.out.println(list.contains( "jack"));//T
//size:获取元素个数
System.out.println(list.size());//1
//isEmpty:判断是否为空
System.out.println(list.isEmpty());//F
//clear:清空list.clear();
list.clear();
System.out.println("list="+ list);//list=[]
//addAll:添加多个元素(只要实现了collection接口就能作为参数)
ArrayList list2 = new ArrayList();
list2.add("红楼梦");list2.add("三国演义");
list.addAll(list2);
System.out.println("list=" + list);//list=[红楼梦, 三国演义]
//containsAll:查找多个元素是否都存在(只要实现了collection接口就能作为参数)
System.out.println(list.containsAll(list2));//T
// removeAll:删除多个元素
list.add("聊斋");
list.removeAll(list2);
System.out.println("list=" + list);//list=[聊斋]
//说明:以ArrayList实现类来演示。
Collection接口遍历元素方式1-使用Iterator(迭代器)
Iterator对象称为迭代器,主要用于遍历Collection集合中的元素。
所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了lterator接口的对象,即可以返回一个迭代器。
Iterator的结构.[看图]
提示:在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用,且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
// System.out.println("col=" + col);
//现在老师希望能够遍历col集合
//1。先得到col对应的迭代器
Iterator iterator = col.iterator();
//2.使用while循环遍历
//快捷键,快速生成while => itit (显示所有的快捷键的的快捷键ctrl + j)
while (iterator.hasNext()) {//判断是否还有数据
//返回下一个元素,类型是0bject
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
//3.当退出while循环后,这时iterator迭代器,指向最后的元素
// iterator.next();//NoSuchElementException
// 4,如果希望再次遍历,需要重置我们的迭代器
iterator=col.iterator();
System.out.println( "===第二次遍历===");
while (iterator.hasNext()) {//判断是否还有数据
//返回下一个元素,类型是0bject
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
}
}
class Book {
private String name;
private String author;
private double price;
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
Collection接口遍历对象方式2-for循环增强.
增强for循环,可以代替iterator迭代器,特点:增强for就是简化版的iterator,本质一样。只能用于遍历集合或数组。
>基本语法
for(元素类型 元素名:集合名或数组名){
访问元素
}
演示
import java.util.ArrayList;
import java.util.Collection;
public class Test {
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
//老韩解读
//1.使用增强for,在Collection集合
// 2.增强for,底层仍然是迭代器
//3.增强for可以理解成就是简化版本的迭代器遍历
for (Object book : col) {
System.out.println("book=" + book);
}
//增强for,也可以直接在数组使用
int[] nums = {1, 8, 10, 90};
for (int i : nums) {
System.out.println("i=" + i);
}
}
}
class Book {
private String name;
private String author;
private double price;
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
List接口基本介绍
List 接口是Collection 接口的子接口 List .java
List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
List集合中的每个元素都有其对应的顺序索引,即支持索引。(list.get(3))
List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
JDK API中List接口的实现类布置前文图中展示的:
常用的有:ArrayList、LinkedList和Vector。
List接口的常用方法
List 集合里添加了一些根据索引来操作集合元素的方法
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 lastlndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素,并返回此元素
Object set(int index,Object ele):设置指定index位置的元素为ele ,相当于是替换
List subList(int fromlndex, int tolndex):返回从fromIndex到tolndex位置的子集合
List list = new ArrayList();
list.add("张三丰");
list.add("贾宝玉");
//void add(int index,0bject ele):在index位置插入ele元素
// 在index =1的位置插入一个对象
list.add(1, "韩顺平");
System.out.println("list=" + list);
//boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
list.addAll(1, list2);
System.out.println("list=" + list);
//Object get(int index):获取指定index位置的元素
//说过
//int indexOf(0bject obj):返回obj在集合中首次出现的位置
System.out.println(list.indexOf("tom"));//2
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
list.add("韩顺平");
System.out.println("list=" + list);
System.out.println(list.lastIndexOf("韩顺平"));
//Object remove(int index):移除指定index位置的元素,并返回此元素(直接修改list,而非返回新的)
list.remove(0);
System.out.println("list=" + list);
//Object set(int index,0bject ele):设置指定index位置的元素为ele,相当于是替换
list.set(1, "玛丽");
System.out.println("list=" + list);
//List subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集合
//注意返回的子集合fromIndex <= subList < toIndex
List returnlist = list.subList(0, 2);//如果改动list元后,再打印returnlist会报错,所以一般是即查即用
System.out.println("returnlist=" + returnlist);
List的三种遍历方式 [ArrayList, LinkedList,Vector]
方式一:使用iterator
lterator iter = col.iterator();
while(iter.hasNext0){
Object o = iter.next();
}
方式二:使用增强for
for(Object o:col){
}
方式三:使用普通for
for(int i=o;i<list.size();i++){
Object object = list.get(i);
System.out.println(object);
}
说明:使用LinkedList完成使用方式和ArrayList一样
ArrayList的注意事项
ArrayList的底层操作机制源码分析(重点,难点.)
先说结论,在分析源码(示意图)
transient Object[] elementData;//transient表示瞬间,短暂的,表示该属性不会被序列化
当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData容量为0,第1次添加,则扩容elementData为10,如需要再次扩容,则扩容elementData为1.5倍。
如果使用的是指定大小的构造器,则初始elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍。
建议:自己去debug一把我们的ArrayList的创建和扩容的流程。
Vector的基本介绍
Vector类的定义说明
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
Vector底层也是一个对象数组,protected Object[] elementData;
Vector是线程同步的,即线程安全, Vector类的操作方法带有synchronized
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
在开发中,需要线程同步安全时,考虑使用Vector
Vector和ArrayList的比较
底层结构 | 版本 | 线程安全(同步)效率 | 扩容倍数 | |
---|---|---|---|---|
ArrayList | 可变数组 | jdk1.2 | 不安全,效率高 | 如果有参构造1.5倍 如果是无参 1.第一次10 2.从第二次开始安1.5扩 |
Vector | 可变数组Object[] | jdk1.0 | 安全,效率不高 | 如果是无参,默认10,满后,就按2倍扩容 如果指定大小,则每次直接按2倍扩 |
LinkedList的全面说明
LinkedList的底层操作机制(需要有数据结构的双向链表基础)
LinkedList的增删改查案例
//建议用debug去看源码
LinkedList linkedList = new LinkedList();
for (int i = 1; i <= 2; i++) {
linkedList.add(0);
}
linkedList.add(100);
linkedList.add(100);
for (Object object : linkedList) {
System.out.println(object);
}
// linkedList.remove(0);
// linkedList.remove(kk);
linkedList.set(0, "韩顺平教育");
System.out.println("===");
for (Object object : linkedList) {
System.out.println(object);
}
Object object = linkedList.get(0);
System.out.println("object=" + object);
System.out.println(linkedList.getFirst());
System.out.println(linkedList.getLast());
ArrayList和LinkedList的比较
底层结构 | 增删的效率 | 改查的效率 | |
---|---|---|---|
ArrayList | 可变数组 | 较低 数组扩容 | 较高 |
LinkedList | 双向链表 | 较高,通过链表追加 | 较低 |
如何选择ArrayList和LinkedList:
Set接口基本介绍
Set接口的常用方法
和List接口一样,Set接口也是Collection的子接口,因此,常用方法和Collection接口一样.
Set接口的遍历方式
同Collection的遍历方式一样,因为Set接口是Collection接口的子接口。
//1。以Set接口的实现类 HashSet 来讲解Set接口的方法
//2. set 接口的实现类的对象(Set接口对象),不能存放重复的元素,可以添加一个null
//3. set接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
//4。注意:取出的顺序的顺序虽然不是添加的顺序,但是他的固定。
Set set = new HashSet();
set.add("john");
set.add("lucy ");
set.add("john ");//重复 不会报错,但也不会再次添加到set中 执行add方法后会返回boolean值,成功true,失败false
set.add("jack");
set.add("hsp");
set.add("mary");
set.add(null);//
set.add(null);//再次添加null, 不会报错,但也不会再次添加到set中
set.remove("jack");
for (int i = 0; i < 10; i++) {
System.out.println("set=" + set);
}
//遍历
//方式1:使用迭代器
System.out.println("=====使用迭代器====");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
//方式2:增强for
System.out.println( "=====增强for==== ");
for (Object o : set) {
System.out.println("o=" + o);
}
//set接口对象,不能通过索引来获取
HashSet的全面说明
HashSet实现了Set接口
HashSet实际上是HashMap,看下源码.
public HashSet() {
map = new HashMap<>();
}
可以存放null值,但是只能有一个null
HashSet不保证元素是有序的,取决于hash后,再确定索引的结果.(即不保证存放和取出顺序一致)
不能有重复元素/对象.在前面Set 接口使用已经讲过(主要是看对象的地址。两个地址不同,则使用equals方法判断,看如下案例)
public class Test {
public static void main(String[] args) {
Set set = new HashSet();
System.out.println("set=" + set); //0
// 4 Hashset不能添加相同的元素/数据?
set.add("lucy");//添加成功
set.add("Lucy");//加入不了
set.add(new Dog("tom"));//0K
set.add(new Dog("tom"));//0k
System.out.println("set=" + set);//set=[Dog{name='tom'}, Lucy, Dog{name='tom'}, lucy]
//在加深一下。非常经典的面试题.
//看源码,做分析,先给小伙伴留一个坑,以后讲完源码,你就了然
//去看他的源码,即add到底发生了什么?
set.add(new String("hsp"));//ok
set.add(new String("hsp"));//加入不了。
System.out.println( "set=" +set);
}
}
class Dog {
private String name;
public Dog(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
'}';
}
}
HashSet底层机制说明
分析HashSet的添加元素底层是如何实现(hash()+equals())
//这里建议debug去看源码hashSet.add的源码
//笔记不方便说明,B站韩顺平java课程P522和p523有详细讲解 需要重点掌握
HashSet hashSet = new HashSet();
hashSet.add("java");
hashSet.add("php");
hashSet.add("java");
System.out.println("set=" + hashSet);
LinkedHashSet底层任然调用HashSet,在它的基础上就只是重写了afterNodeAccess(e),加入了双向链表,使添加和取出顺序相同。核心部分还是调用的HashSet源码。
LinkedHashSet的全面说明
LinkedHashSet底层机制示意图
说明
按照数据类型默认排序,也可以根据自定义内部类自定义排序(底层为TreeMap)
添加的对象对应的类要么实现Comparable要么自定义排序,否则会报错(原理看源码)
//1。当我们使用无参构造器,创建TreeSet时,是默认案编码顺序排
//2。老师希望添加的元素,按照字符串大小来排序
//3.使用TreeSet提供的一个构造器,可以传入一个比较器(匿名内部类)
// 并指定排序规则
//TreeSet treeSet = new TreeSet();
TreeSet treeSet = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//下面调用String的 compareTo方法进行字符串大小比较
return ((String) o2).compareTo((String) o1);//注意返回值为0时不添加,具体原因看源码
}
});
//添加数据。
treeSet.add("jack");
treeSet.add("tom");
treeSet.add("sp");
treeSet.add("a");
treeSet.add("abc");
System.out.println("treeSet=" + treeSet);
Map接口实现类的特点[很实用]
注意:这里讲的是JDK8的Map接口特点
Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value
Map 中的key和value可以是任何引用类型的数据,会封装到HashMap$Node对象中
Map中的key不允许重复,原因和HashSet一样,前面分析过源码.(如果存在key相同,则会替换掉之前的key-value)
Map中的value可以重复
Map 的key 可以为null, value也可以为null,注意key为null, 只能有一个,value为null,可以多个.
常用String类作为Map的key
key和 value之间存在单向一对一关系,即通过指定的key总能找到对应的value(例:map.get(key)会返回value)
Map存放数据的key-value示意图,一对k-v是放在一个HashMap$Node中的,有因为Node 实现了 Entry 接口,有些书上也说一对k-v就是一个Entry
Map接口常用方法
Map接口遍历方法
containsKey:查找键是否存在
keySet:获取所有的键
entrySet:获取所有关系k-v
values:获取所有的值
Map map = new HashMap();
map.put("邓超", "孙俪");
map.put("王宝强", "马蓉");
map.put("宋喆", "马蓉");
map.put("刘令博", null);
map.put(null, "刘亦菲");
map.put("鹿啥", "关晓彤");
//第一组:先取出所有的Key ,通过Key取出对应的Value
Set keyset = map.keySet();
//(1)增强for
System.out.println("-—---第一种方式------");
for (Object key : keyset) {
System.out.println(key + "-" + map.get(key));
}
//(2)迭代器
System.out.println("----第二种方式--—-----");
Iterator iterator = keyset.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key + "-" + map.get(key));
}
//第二组:把所有的values取出
Collection values = map.values();
//这里可以使用所有的Collections使用的遍历方法
// (1)增强for
System.out.println("---取出所有的value 增强for----");
for (Object value : values) {
System.out.println(value);
}
//(2)迭代器
System.out.println("---取出所有的value迭代器----");
Iterator iterator2 = values.iterator();
while (iterator2.hasNext()) {
Object value = iterator2.next();
System.out.println(value);
}
//第三组:通过EntrySet来获取k-v
Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>>//(1)增强for
System.out.println("----使用EntrySet 的 for增强(第三种)----");
for (Object entry : entrySet) {
//将entry 转成 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}
//(2)迭代器
System.out.println("----使用EntrySet的迭代器(第4种)----");
Iterator iterator3 = entrySet.iterator();
while (iterator3.hasNext()) {
Object entry = iterator3.next();
//System.out.println(next. getClass());//HashMap$Node -实现->Hap.Entry (getKey , getValue)
// 向下转型 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}
HashMap小结
HashMap底层机制及源码剖析
扩容机制[和HashSet相司]
HashTable的基本介绍
Hashtable table = new Hashtable();//ok
table.put("john", 100); //ok
// table.put(null, 100);// 异常 NullPointerException
//table.put("john" ,null);//异常NullPointerException
table.put("lucy", 100); //ok
table.put("lic", 100); //ok
table.put("lic", 88);//替换
System.out.println(table);
//简单说明一下Hashtable的底层
//1。底层有数组 Hashtable$Entry[]初始化大小为1
//2。临界值threshold 8 = 11 * 0.75
//3.扩容:按照自己的扩容机制来进行即可.
//4.执行方法 addEntry(hash,key,value,index);添加K-V封装到Entry
//5.当if (count >= threshold)满足时,就进行扩容
//6.按照int newCapacity = (oldCapacity << 1) +1;的大小扩容.
Hashtable和 HashMap对比
版本 | 线程安全(同步) | 效率 | 允许null建null值 | |
---|---|---|---|---|
HashMap | 1.2 | 不安全 | 高 | 可以 |
HashTable | 1.0 | 安全 | 较低 | 不可以 |
略(底层逻辑为HashMap添加了双向链表,原理如LinkedHashSet)
//使用默认的构造器,创建TreeMap,是无序的(也没有排序)
/*
要求:按照传入的k(String)的大小进行排序
*/
//TreeMap treeMap = new TreeMap();
TreeMap treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//按照传入的 k(String)的大小进行排序
//按照K(String)的长度大小排序
// return ((String) o2).compareTo((String) o1);
return ((String) o1).length() - ((String) o2).length();//注意返回值为0时不添加,具体原因看源码
}
});
treeMap.put("jack", "杰克");
treeMap.put("tom", "汤姆");
treeMap.put("kristina", "克瑞斯提诺");
treeMap.put("smith", "斯密斯");
System.out.println("treemap=" + treeMap);
基本介绍
//1. Properties继承Hashtable
//2.可以通过k-v存放数据,当然key 和 value 不能为null
// 增加
Properties properties = new Properties();
// properties.put(null,"abc ");//抛出空指针异常
// properties.put( "abc", null);//抛出空指针异常
properties.put( "john",100) ; //k-v
properties.put("lucy" ,100);
properties.put("lic",100);
properties.put("lic",88);//如果有相同的key , value被替换
System.out.println(properties.get("lic"));//88
//删除
properties.remove("lic");
System.out.println("properties=" + properties);//properties={john=100, lucy=100}
//修改
properties.put("john","约翰");
System.out.println("properties=" + properties);//properties={john=约翰, lucy=100}
//查找
System.out.println(properties.get("john"));//约翰
System.out.println(properties.getProperty("john"));//约翰
在开发中,选择什么集合实现类,主要取决于业务操作特点,然后根据集合实现类特性进行选择,分析如下:
先判断存储的类型(一组对象[单列]或一组键值对[双列])
一组对象:Collection接口
允许重复:List
不允许重复:Set
一组键值对:Map
键无序: HashMap [底层是:哈希表jdk7:数组+链表,jdk8:数组+链表+红黑树](线程不安全,如需要线程安全和key,value不为空,则使用Hashtable)
键排序:TreeMap
键插入和取出顺序一致:LinkedHashMap(线程不安全)
读取文件 Properties(线程安全)
Collections工具类介绍
排序操作:(均为static方法)
//创建ArrayList集合,用于测试。
List list = new ArrayList();
list.add("tom");
list.add("smith");
list.add("king");
list.add("milan");
//reverse(List):反转List 中元素的顺序
Collections.reverse(list);
System.out.println("list=" + list);
//shuffle(List):对 List集合元素进行随机排序
for (int i = 0; i < 5; i++) {
Collections.shuffle(list);
System.out.println("list=" + list);
}
//sort(List):根据元素的自然顺序对指定 List集合元素按升序排序
Collections.sort(list);
System.out.println("自然排序后");
System.out.println("list=" + list);
//sort(List,Comparator):根据指定的 Comparator产生的顺序对List集合元素进行排序
// 我们希望按照字符串的长度大小排序
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String) o1).length() - ((String) o2).length();
}
});
System.out.println("字符串长度大小排序=" + list);
//swap(List,int, int):将指定 list 集合中的i处元素和j处元素进行交换
// 比如
Collections.swap(list, 0, 1);
System.out.println("交换后的情况");
System.out.println("list=" + list);
查找、替换
//创建ArrayList集合,用于测试。
List list = new ArrayList();
list.add("king");
list.add("tom");
list.add("tom");
list.add("smith");
list.add("milan");
System.out.println(list);
//object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
System.out.println("自然顺序最大元素=" + Collections.max(list));
//Object max(Collection,Comparator):根据Comparator 指定的顺序,返回给定集合中的最大元素
//比如,我们要返回长度最大的元素
Object maxObject = Collections.max(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String) o1).length() - ((String) o2).length();//两个反过来相减则是获取最小元素
}
});
System.out.println("长度最大的元素=" + maxObject);
//Object min(collection)
//Object min(Collection,Comparator)
// 上面的两个方法,参考max即可
ArrayList dest = new ArrayList();
//为了完成一个完整拷贝,我们需要先给dest赋值,大小大于等于list.size(),以防拷贝越界
for (int i = 0; i < list.size(); i++) {
dest.add("");
}
dest.add("dddd");
//拷贝
Collections.copy(dest, list);//从list拷贝到dest(覆盖dest中原先的部分数据)
System.out.println("dest=" + dest);//dest=[king, tom, tom, smith, milan, dddd]
System.out.println("list=" + list);//list=[king, tom, tom, smith, milan]
//boolean replaceAll(List list,Object oldVal,Object newNal):使用新值替换 List 对象的所有旧值
//将list中所有tom替换成汤姆
Collections.replaceAll(list, "tom", "汤姆");
System.out.println("list替换后=" + list);//list替换后=[king, 汤姆, 汤姆, smith, milan]
转载自: https://www.cnblogs.com/wenjie2000/p/16631685.html