Java_Collection集合与Map集合的理解与应用

皮卡丘不断更

已于 2022-04-01 19:53:11 修改

阅读量458

点赞数 1

分类专栏： Java基础文章标签： java 开发语言后端

于 2022-03-01 22:47:42 首次发布

本文链接：https://blog.csdn.net/PIKapikaaaa/article/details/123218367

版权

Java基础专栏收录该内容

37 篇文章 1 订阅

订阅专栏

集合

概述：可以存储多个数据的容器

集合和数组的区别：
- 相同点：都可以存储多个数组
- 不同点：
  - 数组中可以存多个数据，但是不能自由的实现数据的新增和删除操作
    
    集合中除了可以存储多个数据，还可以自由的实现数据的新增和删除操作
  - 数组中及可以存储基本类型的数据有可以存储引用类型数据
    
    集合中只能存储引用类型数据
  - 数组本身自带的功能较少，集合中自带的功能比较多

集合的体系

在这里插入图片描述

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]

皮卡丘不断更

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java_Collection集合与Map集合的理解与应用

Java_Collection集合与Map集合的理解与应用
复制链接

扫一扫

专栏目录