集合
概述:可以存储多个数据的容器
-
集合和数组的区别:
-
相同点:都可以存储多个数组
-
不同点:
-
数组中可以存多个数据,但是不能自由的实现数据的新增和删除操作
集合中除了可以存储多个数据,还可以自由的实现数据的新增和删除操作
-
数组中及可以存储基本类型的数据有可以存储引用类型数据
集合中只能存储引用类型数据
-
数组本身自带的功能较少,集合中自带的功能比较多
-
-
集合的体系
Collection集合
概述:此类是单列集合的顶层接口,任何单列集合都属于该接口的子接口或者实现类。
- 特点
- 是一个接口不能去创建对象。只能通过实现类创建对象访问其中的方法。
- 在java.util包,需要导包使用
- Collection中定义的方法,子接口和实现类都可以去使用。
Collection集合中常用的方法
- **add(E e) :**往集合中添加元素
- **addAll(Collection<? extends E> c) :**将集合c中的内容全添加到调用者集合中
- **remove(Object o) :**删除集合中的o元素
- **removeAll(Collection<?> c) :**删除调用者集合中和c集合中相同的元素
- **clear() :**清空集合
- **contains(Object o) :**判断集合中是否包含元素o
- **containsAll(Collection<?> c) :**判断调用者集合中是否全部包含集合c的所有元素
- **isEmpty() :**判断集合是否为空
- **size() :**返回集合中元素的个数
//创建Collection的实现类list,用接口接收
Collection c = new ArrayList();
//添加add
c.add("chen");
c.add("shuang");
System.out.println(c);
Collection c1 = new ArrayList();
c1.add("1999");
c1.add("0328");
c1.add(4);
//add All
c.addAll(c1);
System.out.println(c);
//删除集合中的元素
c.remove("chen");
//删除集合c中和集合c1中相同的元素
c.removeAll(c1);
System.out.println(c);
//判断集合中包含某一个元素
System.out.println("------------");
System.out.println(c.contains(4));
System.out.println(c.containsAll(c1));
//将集合中元素全部删除
c.clear();
//判断集合是否为空
System.out.println(c.isEmpty());
//判断集合元素个数
System.out.println(c.size());
Collection集合的遍历方式
Collection集合的第一种遍历方式
-
**转数组遍历:**将集合中的数据转到一个数组中,再遍历数组,等于是间接的遍历集合。
-
**集合转为数组的方法:**toArray()
Collection c =new ArrayList();
c.add(new Person("陈一",11));
c.add(new Person("陈二",13));
c.add(new Person("陈三",12));
//遍历方法一:
//先把集合转成数组,用Object超类接收
Object[] o = c.toArray();
//遍历Object数组
for (int i = 0; i < c.size(); i++) {
//强制转型为Person类型
Person p = (Person)o[i];
System.out.println(p.getName());
}
//陈一
//陈二
//陈三
Collection集合的第二种遍历方式
-
使用迭代器遍历集合
迭代:更新换代,一个到下一个
迭代器:用来获取集合中每一个元素的对象
-
**获取迭代器的方式:**通过集合定义的方法来获取:iterator()
-
迭代器对象可以使用的方法:
-
next();
-
hasNext();
-
-
注意事项:
- 虽然每次使用的方法都是next,但是获取的值是不同的
- next方法不仅可以获取下一个元素,而且获取之后,可以将指针指向下一个元素
- hasnext方法只可以判断是否有下一个元素,不能移动指针
- 如果集合中没有下一个元素了,仍然获取,会出现一个异常: NoSuchElementException
Collection c =new ArrayList();
c.add(new Person("陈一",11));
c.add(new Person("陈二",13));
c.add(new Person("陈三",12));
//先获取一个迭代器对象
Iterator i = c.iterator();
//使用hasNext()方法判断是否有下一个元素,如果有返回true否则false
while (i.hasNext()){
//如果有下一个元素,就用next()来获取该元素
System.out.println(i.next());
}
//Person{name='陈一', age=11}
//Person{name='陈二', age=13}
//Person{name='陈三', age=12}
//强转--
Iterator i1 = c.iterator();
while (i1.hasNext()){
//注意:(Person)i1.next()
Person pp = (Person)i1.next();
System.out.println(pp.getName()+"是:"+pp.getAge());
}
//陈一是:11
//陈二是:13
//陈三是:12
Collection集合的第三种遍历方式
-
使用增强for循环遍历
-
增强for循环:
它是JDK5之后出现的,其内部原理Iterator迭代器相同
格式:
for(元素的数据类型 元素名称:集合或者数组名称){
元素名称的使用
}
//for(超类 公共名称:集合名称)
for (Object o1:c){
System.out.println(o1);
}
代码:
Collection c =new ArrayList();
c.add(new Person("陈一",11));
c.add(new Person("陈二",13));
c.add(new Person("陈三",12));
//for(超类 公共名称:集合名称)
for (Object o1:c){
System.out.println(o1);
}
//Person{name='陈一', age=11}
//Person{name='陈二', age=13}
//Person{name='陈三', age=12}
//强转--遍历单个元素值
for (Object o2 : c) {
Person p1 = (Person)o2;
System.out.println((p1.getName())+"是"+(p1.getAge()));
}
//陈一是11
//陈二是13
//陈三是12
List集合
List集合是Collection接口下的子接口
- 特点:
- 属于一个单列集合
- 不能直接创建对象,可以通过实现类创建对象
- 该集合中的元素特点:
- 有序:元素存入的和取出的顺序可以保证一致
- 有索引:每个元素都有自己的一个位置,通过有序的序号来表示这个位置,索引
- 可重复:集合中可以存储相同的元素值
List集合中特殊的方法
- **add(int index, E element) :**往集合中的指定位置添加元素
- **get(int index) :**获取集合中指定元素的值
- **remove(int index) :**删除指定位置的元素
- **set(int index, E element) :**修改集合中指定位置的元素值为element
代码:
并发修改异常解决
ConcurrentModificationException
出现该异常的原因:
- 一边使用迭代器对象遍历集合,一边使用集合对象增加或者删除元素
ConcurrentModificationException异常
Iterator i =list.iterator();
while (i.hasNext()){ //使用迭代器遍历集合
Object o = i.next();
if (o.equals("chen")){
list.add("AAA"); //集合对象增加元素
}
}
System.out.println(list);
解决方案:【统一】
- 一边使用集合对象遍历,一边使用集合对象增加或者删除
- 一边使用迭代器遍历,一边使用迭代器增加或删除
第一种方式:
-
使用集合遍历:list.size方法和List.get方法
-
使用集合增加:list.add
//解决办法一:使用集合遍历
for (int i = 0; i < list.size()-1; i++) {
Object o = list.get(i);
System.out.print(o+" ");
}
第二种方式:
- **迭代器遍历:**hasnext next
- 迭代器增加:
- 使用父类中获取迭代器对象的方式,没有增加元素的方法,所以要使用List集合特有的获取方式:listIterator()
- 通过这个特有的方式获取的迭代器对象,不仅可以遍历集合,而且有add方法来增加元素。
ListIterator lis =list.listIterator();
while (lis.hasNext()){
Object o = lis.next();
if (o.equals("chen")){
lis.add("AAA");
}
}
List的实现类
概述:List集合也是一个接口,根据底层存储数据方式的不同有不同的实现类
分类:
- ArrayList
- LinkedList
ArrayList
List集合的实现类,本类没有特殊的方法,只能使用接口中定义的方法
特点:
- 底层数组实现,可以表示元素有序
- 查询元素的效率高,增删元素的效率低
- 特点:元素有序,元素有索引,元素可以重复
总结:
- 使用空参构造创建一个ArrayList集合对象,其实底层维护了一个空Object数组
- 当第一次向集合中添加元素,底层先将数组扩容,从0扩容10
- 当10个元素存储之后,继续存储其他元素,底层继续对数组进行扩容,扩容原来的1.5倍,依次类推。
LinkedList
属于List接口的实现类,可以使用接口中继承方法
-
底层通过双向链表实现,可以保证元素有序
-
查询元素效率低,增删元素效率高
-
使用构造方法创建一个LinkedList对象,底层什么也没有维护(数据是保存在Node对象中,如果没有数据,就不需要创建Node对象)
如果使用该集合对象增加一个元素,那么底层就会新建一个Node对象(节点)来保存该元素的值,以及上一个元素和下一个元素的地址值,如果继续新增元素,那么该新增的元素就是最后一个元素,将上一个元素的last地址改为新元素的地址,也会将新元素的上一个元素地址进行保存
特有方法:【因为linkedList可以记录头部和尾部元素的地址,所以有一些操作头部和尾部元素的方法:】
- addFirst(); 在头部位置添加元素
- addLast(); 在尾部添加元素
- removeFirst(); 删除头部位置的元素
- removeLast(); 删除尾部的元素
- getFirst(); 获取头部元素
- getLast(); 获取尾部元素
总结
-
数组和集合的区别
-
Colllection特点
方法
-
Collection遍历方式:
转数组:toArray
迭代器:iterator
增强for循环
-
List集合特点
-
元素有序 有索引 可以存储重复值
-
add(index ,e) get(index) remove(index) set(index,e)
特有的遍历方式: size() get(index)
-
异常:并发修改异常
使用同一个对象遍历集合,增删元素
-
ArrayList:
底层数组实现,查询快,增删慢
-
LinkedList:
底层双向链表实现,查询慢,增删快
有特殊的方法
-
数组和集合的区别
-
Colllection特点
方法
-
Collection遍历方式:
转数组:toArray
迭代器:iterator
增强for循环
-
List集合特点
-
元素有序 有索引 可以存储重复值
-
add(index ,e) get(index) remove(index) set(index,e)
特有的遍历方式: size() get(index)
-
异常:并发修改异常
使用同一个对象遍历集合,增删元素
-
ArrayList:
底层数组实现,查询快,增删慢
-
LinkedList:
底层双向链表实现,查询慢,增删快
有特殊的方法
Set集合
概述:该集合是一个单列集合,是Collection集合的子接口。
特点:
-
在java.util包中
-
该类元素特点:
不可重复:集合中不可以存储相同的元素(去重)
**没有索引:集合中没有一些操作元素索引的方法**
无序:元素存储的顺序和取出的顺序不能保持一致
TreeSet集合
概述:TreeSet集合为Set集合的实现类。
特点:
-
不可重复:集合不可以存放重复的元素(去重)
-
无序:元素存入和取出的顺序不一致
-
无索引:元素没有索引来对应
-
该集合底层使用二叉树来存储
虽然该集合是无序存入和取出,但是该集合可以对元素进行排序
存储元素排序方式:
-
如果集合中存储的是整数、小数则按照数据的大小,从小到达排序
-
如果集合中存储的是字符、则按照字符转码后的整数从小到达排序
-
如果是非中文字符串类型,则按照字符串中字符转码后的整数从小到达排序
-
如果是中文字符串则按照中文字符解码后的数字大小,从小到大排列
-
如果是自定义的类型对象,不能直接使用TreeSet集合存储
解决方案:实现Comparable接口,并重写接口中的compareTo方法
compareTo方法排序原理:
-
Comparable接口: 是一个比较接口
-
需要重写该接口的方法: public int compareTo(Object o)
-
方法的比较规则:
Comparable接口: 是一个比较接口
(2)需要重写该接口的方法: public int compareTo(Object o)
(3)方法的比较规则:
返回值为0 默认添加的元素重复,就实现去重
返回值为正 默认添加的元素大,将元素存储在右子树(后取)
返回值为负 默认添加的元素小,将元素存储在左子树(先取)
//person类实现比较接口并重写compareTo方法
public class Person implements Comparable<Person> {
@Override
public int compareTo(Person o) {
// 当前的减去上一次的返回值大,放右边,后取出,所以是从大到小排序
// return this.age-o.age;
//年龄比
int a= this.age-o.age;
//姓名比
int b = this.name.compareTo(o.name);
return a!=0 ? a:b;
}
}
//以上类重写后的方法可以决定测试类中TreeSet集合输出的排序顺序
public class Person_complication {
public static void main(String[] args) {
TreeSet<Person> p = new TreeSet<>();
p.add(new Person("张三",18));
p.add(new Person("李四",15));
p.add(new Person("王五",20));
p.add(new Person("赵六",14));
p.add(new Person("陈八",16));
p.add(new Person("王五",16));
p.add(new Person("周七",22));
System.out.println(p);
}
}
Comparator比较器使用
案例:
使用TreeSet集合存储多个学生信息, 先按照学生的总成绩升序排列 如果总成绩相同,则按照语文成绩升序排列 如果语文成绩也相同,则按照名字的自然排序升序排列 学生类: 属性:姓名 语文成绩 数学成绩
public class Student {
private String name;
private int chinese;
private int math;
private int sum=chinese+math;
public Student() {
}
public Student(String name, int chinese, int math) {
this.name = name;
this.chinese = chinese;
this.math = math;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getChinese() {
return chinese;
}
public void setChinese(int chinese) {
this.chinese = chinese;
}
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getSum() {
return sum;
}
public void setSum(int sum) {
this.sum = sum;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", chinese=" + chinese +
", math=" + math +
", sum=" + sum +
'}';
}
}
//测试类
public class Student_Test {
public static void main(String[] args) {
//使用Comparator比较器,new一个匿名内部类
Comparator c = new Comparator<Student>(){
@Override
public int compare(Student o1, Student o2) {
int sum = o1.getSum() - o2.getSum();//此值大于零时,按成绩升序
int chinese = o1.getChinese() - o2.getChinese();
int name = o1.getName().compareTo(o2.getName());
return sum == 0 ? (chinese == 0 ? name : chinese) : sum;
}
};
//往集合中录入数据
TreeSet<Student> s = new TreeSet<>(c);
s.add(new Student("张三",50,70));
s.add(new Student("李四",60,90));
s.add(new Student("王五",30,95));
s.add(new Student("赵六",40,40));
s.add(new Student("周七",80,20));
System.out.println(s);
}
}
HashSet集合
概念:属于set集合的实现类
特点:
- 无序,没有索引,不可重复
- 该集合没有特殊的方法,可以使用单列接口中定义的方法
- 该集合存储元素的方式,底层是根据哈希表来进行存储的
哈希值简介
是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
-
如何获取哈希值
Object类中的public int hashCode():返回对象的哈希码值
-
哈希值的特点
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 默认情况下,不同对象的哈希值不同
-
总结
- 两个对象的哈希值不同,肯定是不同的对象
- 如果两个对象的哈希值一样,可能不是同一个对象
哈希表图示
哈希表:底层就是使用 数组 + 链表 结合产生的。
JDK1.7版本哈希表的图示
- 使用数组和链表组成
JDK1.8之后对哈希表的优化
优化的原因:因为如果链表的长度过长,该链表中的数据在查询时,查询的效率低,所以当链表长度>=8时,会将该链表转为红黑树(特殊的二叉树)来存储,转换之后,链表的长度就会缩短,提高查询效率。
HashSet集合保证元素唯一性原理
LinkedHashSet集合
概述:是一个单列集合,是HashSet集合的子类
特点:
-
没有特殊的方法,可以使用父类中继承的方法
-
元素特点:
-
无索引
-
不可重复:和父类去重的原理一样
-
有序:可以保证元素存入的和取出的顺序
有序的原理和链表原理相同
-
单列集合总结
-
Collection接口:
- 单列集合的顶层接口
- 方法需要重写
- 三种遍历方式
-
List:Collection集合的子接口
- 特点:有序 有索引 可重复
- 特有方法:通过索引操作元素的方法
- 特有的遍历方式:size get
- 并发修改异常:解决:使用同一个对象操作集合
-
ArrayList:
- 底层使用数组实现,查询快,增删慢
-
LinkedList:
- 底层使用双向链表实现,查询慢,增删快
- 特有方法,操作头部和尾部元素方法
-
Set:Collection接口的子接口
- 特点:无序 无索引 去重
- 三种遍历方式
-
TreeSet:
- 底层使用二叉树实现
- 去重原理和无序原理:
- 通过比较器对象Compator对象的compare
- Comparable接口的compareTo方法
- 可以对元素进行排序
-
HashSet集合:
-
底层使用哈希表实现
-
去重原理:通过比较元素的哈希值和equals结果来去重
比较之后,两个结果都相同去重,有一个不同就存入
-
-
LinkedHashSet集合:
- HashSet集合的子类:哈希表实现
- 特点:有序 无索引 去重
Map集合
概念:现实生活中,我们常会看到这样的一种关系:IP地址与主机名,身份证号与个人,用户名与密码,等等。
这种一一对应的关系,就叫做映射。
Java提供了专门的集合类用来存放这种对象关系的数据,存储映射关系的集合就是双列集合。
Map集合中常用的方法
-
put(K key, V value) :往集合中添加元素 每个元素是由键值对组成
如果key值是第一次出现,就是添加
如果key值第二次出现,就是替换
//添加键值对
map.put(1, "陈爽");
map.put(2, "张三");
map.put(3, "李四");
- remove(Object key) :根据制定的key删除对应的键值对
//根据key删除键值对
map.remove(1);
- remove(Object key, Object value) :根据键和值删除对应键值对
map.remove(2,"张三");
- clear() :清空集合
//清楚所有集合
map.clear();
- containsKey(Object key) :判断集合中是否包含key
//判断集合中是否包含key
map.containsKey(1);
- containsValue(Object value) :判断集合中是否包含value
//判断集合中是否包含Value
map.containsValue("chenshuang");
- get(Object key) :根据key值获取对应的value值
//根据key值获取value
map.get(2);
- isEmpty() :判断集合是否为空
//判断集合是否为空
System.out.println(map.isEmpty());
- replace(K key, V value) :替换key对应的value值
//修改键值对
map.replace(3, "19990328");
- ** size()**:获取集合中键值对的对数
//返回集合中键值对的对数
System.out.println(map.size());
Map集合的遍历
遍历一:通过key获取Value
1、概述:
先将Map集合中的key单独获取到一个单列集合中,然后遍历该单列集合获取每一个key,再通过key依次获取每一个对应的value。
-
如何获取每一个key:keySet()
-
遍历set集合:
三种方式
-
遍历set集合获取每一个key,再使用get方法获取key对应的value
图示:
代码:
HashMap<String,Integer> map = new HashMap<>();
map.put("aaa",23);
map.put("sss",318);
map.put("ccc",999);
//遍历方式一:通过获取key来遍历
Set<String> set = map.keySet();
Iterator<String> it = set.iterator();
while (it.hasNext()){
//获取每一个key
String key = it.next();
//输出key和对应的value值
System.out.print(key+ map.get(key)+"\t");
}
//aaa23 sss318 ccc999
遍历二:通过键值对对象来获取key和value
1、思路:
先将Map集合中的每一个键值对数据封装为一个个键值对对象,然后将每一个对象保 存在set中,遍历set集合,获取每一个键值对对象,通过方法获取该对象中的key和 value
- 获取键值对对象到set中的方法:entrySet()
- 集合set中保存的是:一个个键值对对象 ,该键值对对象所属的类型是Entry接口
- Entry接口是,Map集合中内部接口
- 该接口中由两个方法:
getKey获取key
getValue获取value
思路:
-
获取set集合之后,遍历set获取每一个键值对
三种遍历方式
-
遍历set集合之后,可以得到每一个键值对,如何获取对应的key、value
getKey获取key
getValue获取value
图示:
代码:
HashMap<String,Integer> map = new HashMap<>();
map.put("aaa",23);
map.put("sss",318);
map.put("ccc",999);
//遍历方式二:通过对key和value的对象封装来遍历
Set<Map.Entry<String,Integer>> s= map.entrySet();
for(Map.Entry<String,Integer> o :s){
String key = o.getKey();
System.out.print(key+map.get(key)+"\t");
}
for (Map.Entry<String,Integer> o : map.entrySet()){
String key =o.getKey();
System.out.print(key+map.get(key)+"\t");
}
//aaa23 sss318 ccc999
//aaa23 sss318 ccc999
Map集合实现类
概述:Map集合为双列集合的顶层接口,底层根据不同的实现方式,有不同的实现类
- 实现类:
- TreeMap
- HashMap
TreeMap集合
概述:是一个双列集合,是Map集合的实现类
特点:
-
集合中的key值是唯一的,元素是无序的
TreeMap集合key值 去重和排序原理 与TreeSet都是一样的
底层都是二叉树来实现的
-
TreeSet集合和TreeMap集合的关系:
TreeSet集合的底层就是使用TreeMap集合实现的
HashMap集合
概述:是一个双列集合,属于map集合的实现类。
特点:
- 集合中的key值是唯一的,元素是无序的
- HashMap集合去重原理和无序原理和HashSet集合原理一致
- 通过比较key的哈希值和equals的结果来实现去重
- HashSet集合底层就是使用HashMap来实现的
LinkedHashMap集合
概述:是一个双列集合,是HashMap集合的子类
特点:
- 本类没有特殊的方法,只能使用父类中继承的
- 集合中元素有序
- 集合中的key值唯一
【笔试题】HashMap集合和HashTable集合的区别
相同点:
- 两个集合都是Map接口的实现类,都属于双列集合
- 两个集合底层是使用哈希表来存储数据
- 两个集合中的方法大致相同
不同点:
- 版本不同:HashMap是jdk1.2出现的,HashTable是jdk1.0出现
- 线程安全性不同:HashMap是线程不安全的,HashTable线程安全的
- 存储的值不同:HashMap可以存储null键null值,HashTable不可以存储null
Collections工具类
本类是JDK提供的操作集合的工具类,类中定义了一些操作集合元素的方法
常用方法
-
binarySearch(List<? extends Comparable<? super T>> list, T key) :
通过二分查找法查找元素key在集合中的索引
前提数组或者集合一定是升序排列
ArrayList<Integer> in = new ArrayList<>();
in.add(2);
in.add(3);
in.add(4);
in.add(5);
int indexx = Collections.binarySearch(in,2);
System.out.println(indexx);
//0
//创建学生对象实现Combareble接口,然后重写了其compareTo方法
public class Student implements Comparable<Student>{
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Student o) {
return 0;
}
}
//测试类
public class Student_test {
public static void main(String[] args) {
ArrayList<Student> st = new ArrayList<>();
st.add(new Student("chen",25));
st.add(new Student("shuang",24));
st.add(new Student("ccccc",20));
System.out.println(indexx);
int index = Collections.binarySearch(st,new Student("shuang",24));
System.out.println(index);
}
}
//1
-
frequency(Collection<?> c, Object o) :
获取集合中o元素出现的次数
public static void main(String[] args) {
ArrayList<Integer> in = new ArrayList<>();
in.add(2);
in.add(2);
in.add(3);
in.add(4);
in.add(5);
int count1 = Collections.frequency(in,2);
System.out.println(count1);
}
//2
//创建学生对象
public class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
}
//测试类
public class Student_test {
public static void main(String[] args) {
ArrayList<Student> st = new ArrayList<>();
st.add(new Student("chen",25));
st.add(new Student("shuang",24));
st.add(new Student("shuang",24));
st.add(new Student("ccccc",20));
int count = Collections.frequency(st,new Student("shuang",24));
System.out.println(count);
}
}
//2
- max(Collection c) : 求出集合中的最大值
//求出集合中最大值 max()
System.out.println(Collections.max(in));
- min(Collection c) : 求出集合中的最小值
//求出集合中最小值 min()
System.out.println(Collections.min(in));
- reverse(List<?> list) : 反转集合中的元素顺序
ArrayList<Integer> in = new ArrayList<>();
in.add(2);
in.add(2);
in.add(3);
in.add(4);
in.add(5);
//反转集合中的元素
Collections.reverse(in);
System.out.println(in);
//[5, 4, 3, 2, 2]
- shuffle(List<?> list) : 随机排列集合元素的顺序
//随机排列集合中的元素
Collections.shuffle(in);
System.out.println(in);
//[3, 5, 2, 4, 2]
- sort(List list) : 将集合中的元素进行升序排列
ArrayList<Integer> in = new ArrayList<>();
in.add(6);
in.add(4);
in.add(1);
in.add(4);
in.add(8);
//将集合中的元素升序排列
Collections.sort(in);
System.out.println(in);
//[1, 4, 4, 6, 8]
- swap(List<?> list, int i, int j) : 交换集合中两个元素的位置
ArrayList<Integer> in = new ArrayList<>();
in.add(6);
in.add(4);
//交换集合中两个元素的位置
Collections.swap(in,0,1);
System.out.println(in);
//[4, 6]