Java：集合

尔玉先生

已于 2022-08-02 17:00:35 修改

阅读量172

点赞数

分类专栏： Java 文章标签： java 集合论链表

于 2020-07-26 10:15:44 首次发布

本文链接：https://blog.csdn.net/weixin_44330955/article/details/107589871

版权

Java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DVOQnXEb-1595729476900)(F:\JianShu_material\Java\图片\集合\集合.png)]$

1. Java集合框架概述

1.1 集合定义

集合、数组都是对多个数据进行存储操作的结构，简称Java容器。

面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。

而使用Array存储对象方面具有一些弊端。

数组的弊端：

数组初始化以后，长度就不可变了，不便于扩展
数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。
存储数据的特点单一，存储的数据是有序的、可以重复的。

Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

1.2 集合概述

Java集合可分为Collection和Map两种体系：

Collection接口：单列数据，定义了存取一组对象的方法的集合
- List：元素有序、可重复的集合，实现类：ArrayList、LinkedList、Vector
- Set：元素无序、不可重复的集合，实现类：HashSet、LinkedHashSet、TreeSet
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cKfxV7nP-1595729476912)(F:\JianShu_material\Java\图片\集合\001.png)]$
Map接口：双列数据，保存具有映射关系“key-value对”的集合，实现类：HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VMUA4lvG-1595729476937)(F:\JianShu_material\Java\图片\集合\002.png)]$

2. Collection接口方法

2.1 Collection接口常用方法1

add()、addAll()、size()、clear()、isEmpty()

向Collection接口的实现类的对象中添加数据Obj时，要求Obj所在类要重写equals()。

//导入的包有：import org.junit.Test;import java.util.ArrayList;import java.util.Collection;

public class CollectionTest {

    @Test
    public void test1(){
        Collection coll = new ArrayList();

        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("bb");
        coll.add(123);//自动装箱
        coll.add(new Object());

        //size():获取添加的元素个数
        System.out.println(coll.size());//4

        //addAll(Collection coll1):将coll1集合中的元素添加到当前集合中
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);

        System.out.println(coll.size());//6
        System.out.println(coll);//[AA, bb, 123, java.lang.Object@78e03bb5, 456, CC]

        //clear():清空集合元素
        coll.clear();

        //isEmpty():判断当前吗集合是否为空
        System.out.println(coll.isEmpty());//true
    }
}

2.2 Collection接口常用方法2

contains()、containsAll()

//导入的包有：import org.junit.Test;import java.util.ArrayList;import java.util.Arrays;import java.util.Collection;

public class CollectionTest {

    @Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        //contains(Object obj):判断当前集合是否包含obj
        //判断时会调用obj对象所在类的equals(),若重写则判断内容，没有则判断地址
        System.out.println(coll.contains(123));//true
        System.out.println(coll.contains(new String("Tom")));//true

        //containsAll(Collection coll1):判断形参中所有元素是否在当前集合中
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(coll.containsAll(coll1));//true
    }
}

2.3 Collection接口常用方法3

remove()、removeAll()、retainAll()、equals()

//导入的包有：import org.junit.Test;import java.util.ArrayList;import java.util.Arrays;import java.util.Collection;

public class CollectionTest {
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        //remove(Object obj):从当前集合中移除obj元素
        //移除时也需要使用equals()判断，返回布尔类型
        coll.remove(123);
        System.out.println(coll);//[456, Tom, false]
        coll.remove(new String("Tom"));
        System.out.println(coll);//[456, false]

        //removeAll(Collection coll1):从当前集合中移除coll1中的所有元素，即两者共同的元素
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);
        System.out.println(coll);//[false]
    }
    
    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        //retainAll(Collection coll1):获取当前集合和coll1集合的交集，并返回给当前集合
        Collection coll1 = Arrays.asList(123,456,789);
        coll.retainAll(coll1);
        System.out.println(coll);//[123, 456]
    }
    
    @Test
    public void test5(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new String("Tom"));
        coll1.add(false);

        //equals(Object obj):要想返回true，需要当前集合和形参集合元素相同
        System.out.println(coll.equals(coll1));//true
    }
}

2.4 Collection接口常用方法4

hashCode()、toArray()

//导入的包有：import org.junit.Test;import java.util.ArrayList;import java.util.Arrays;import java.util.Collection;

public class CollectionTest {

    @Test
    public void test6(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        //hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //toArray():集合---->数组
        Object[] arr = coll.toArray();//7639761
        for(int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);//123\n456\nTom\nfalse
        }
    }

3. Iterator迭代器接口

3.1 Iterator接口遍历集合

Iterator对象称为迭代器(设计模式的一种)，主要用于遍历Collection集合中的元素。

Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。

//导入的包有：import org.junit.Test;import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;

public class InteratorTest {

    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();

        //hasNext()：判断是否还有下一个元素
        while(iterator.hasNext()){
            //next()：①指针下移，②将下移后的集合位置上的元素返回
            System.out.println(iterator.next());
        }
        /*123
         456
         Tom
         false*/
    }
}

3.2 Iteratot接口移除元素

Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove()方法，不是集合对象的remove()方法。

这个方法不能使用Collection的remove()方法，只能使用iterator的remove()方法

//导入的包有：import org.junit.Test;import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;

public class InteratorTest {

    @Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();

        //删除集合中“Tom”
        while(iterator.hasNext()){
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();
            }
        }
        iterator = coll.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        /*123
        456
        false*/
    }
}

3.3 foreach遍历集合

Java 5.0 提供了 foreach 循环迭代访问集合和数组。

遍历操作不需获取Collection或数组的长度，无需使用索引访问元素。

//导入的包有：import org.junit.Test;import java.util.ArrayList;import java.util.Collection;

public class ForTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        //for(集合元素类型 局部变量 : 集合对象)
        //内部使用的还是迭代器
        for(Object obj : coll){
            System.out.println(obj);
        }
        /*123
        456
        Tom
        false*/
    }

    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //for(数组元素类型 局部变量 : 数组对象)
        for(int i : arr){
            System.out.println(i);
        }
    }
}

4. Collection子接口一：List

4.1 List接口概述

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组

List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。

List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

4.2 ArrayList、LinkedList和Vector的异同

相同之处

三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据

不同之处

ArrayList： 作为List接口的主要实现类；线程不安全，效率高；底层使用Object[]存储。
LinkedList： 对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储。
Vector： 作为List接口的古老实现类；线程安全的，效率低；底层使用Object[]存储。

下面是List接口的实现

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo1 {
    public static void main(String[] args) {
        //List与Collection接口不同的是：List可以使用角标
        //List与Collection接口相同的是：是有序，可重复的集合
        List list = new ArrayList();
        list.add("苹果");
        list.add("华为");
        list.add("小米");
        System.out.println(list.size()); //3
        list.remove(0);
        System.out.println(list.toString()); //[华为, 小米]

        //遍历方式1：普通for循环
        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //遍历方式2：增强for循环
        for (Object object:list) {
            System.out.println(object);
        }
        //遍历方式3：iterator迭代器
        //略
        //遍历方式4：listiterator迭代器，这个迭代可以从前往后，也可以从后往前，还可以添加，删除，修改元素
        ListIterator listIterator = list.listIterator();
        while(listIterator.hasNext()){
            System.out.println(listIterator.nextIndex() + ":" + listIterator.next());
        }
    }
}

public class Demo02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(10);
        list.add(20);
        list.add(30);
        //当删除数值型元素时
        //list.remove(10);这种方式是不能删除数字10的，因为这是按照索引来删除
        list.remove((Object)10); //这时才能删除该元素
    }
}

4.3 ArrayList、LinkedList和Vector的源码分析

ArrayList源码分析

JDK7中源码分析：

使用空参构造器创建对象时，在底层创建了长度时10的Object[]数组elementData。
如果在集合在添加元素过程中，导致底层elementData数组容量不够，则扩容。
默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
建议开发中使用带参构造器，参数为容量，可以不用反复创建新的数组。

JDK8中源码分析：

底层Object[] elementData初始化为{}，并没有创建长度为10的数组。
第一次调用add()时，底层才创建了长度为10的数组。
后续的添加和扩容与JDK7无异。

LinkedList源码分析

内部声明了Node类型的first和last属性，默认值为null。

将使用add()添加的元素封装到Node中，创建了Node对象。

Node定义为：体现了LinkedList的双向链表的说法。

Vector源码分析

JDK7和JDK8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。

在扩容方面，默认扩容为原来的数组长度的2倍。

4.4 List中的常用方法

除了Collection接口中定义的一些方法，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 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位置的子集合

//导入的包有：import org.junit.Test;import java.util.ArrayList;import java.util.Arrays;import java.util.List;

public class LinkTest {
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add(new String("Tom"));
        list.add(false);

        //void add(int index, Object ele)：在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);//[123, BB, 456, Tom, false]

        //boolean addAll(int index, Collection eles)：从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1,2,3);
        list.addAll(list1);
        System.out.println(list.size());//8

        //Object get(int index)：获取指定index位置的元素
        System.out.println(list.get(0));//123

        //int indexOf(Object obj)：返回obj在集合中首次出现的位置
        //如果不存在该元素，返回值为-1
        int index = list.indexOf(456);
        System.out.println(index);//2

        //int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置
        //如果不存在该元素，返回值为-1
        System.out.println(list.lastIndexOf(456));//2

        //Object remove(int index)：移除指定index位置的元素，并返回此元素
        Object obj = list.remove(3);
        System.out.println(obj);//Tom
        System.out.println(list);//[123, BB, 456, false, 1, 2, 3]

        //Object set(int index, Object ele)：设置指定index位置的元素为ele
        list.set(1,121388);
        System.out.println(list);//[123, 121388, 456, false, 1, 2, 3]

        //List subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex位置左闭右开的子集合
        List list2 = list.subList(2, 4);
        System.out.println(list2);//[456, false]
        System.out.println(list);//[123, 121388, 456, false, 1, 2, 3]
    }
}

5. Collection子接口二：Set

5.1 Set接口概述

Set接口是Collection的子接口，Set接口没有提供额外的方法

Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。

Set判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法。

JDK API中Set接口的实现类常用的有：HashSet、LinkedHashSet和TreeSet。

5.2 HashSet、LinkedHashSet和TreeSet的异同

相同之处

三个类都是实现了List接口，存储数据的特点相同：存储无序的、不可重复的数据

不同之处

HashSet： 作为Set接口的主要实现类；线程不安全的；可以存储null值
LinkedHashSet： 作为HashSet的子类；在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据；因此遍历其内部数据时，可以按照添加顺序显示
TreeSet： 可以按照添加对象的制定属性，进行排序

5.3 无序性以及不可重复性

名词解释

无序性： 不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定。

不可重复性： 保证添加元素按照equals()判断时，不能返回true，相同元素只能添加一个。

添加元素过程，以HashSet为例

我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值
次哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置）
判断此位置上是否已经有元素：
- 如果此位置上没有其它元素，则元素a添加成功 --------------> 情况1
- 如果此位置上有其它元素b（或以链表形式存在的多个元素），则比较a与b的哈希值：
  - 如果哈希值不相同，则元素a添加成功 ---------------> 情况2
  - 如果哈希值相同，进而需要调用元素a所在类的equals()方法：
    - equals()返回true，元素a添加失败
    - equals()返回false，则元素a添加成功 ----------------> 情况3

对于添加成功的情况2和情况3而言：元素a，与已经存在指定索引位置上数据以链表的方式存储：

JDK7： 元素a放到数组中，指向原来的元素
JDK8： 原来的元素在数组中，指向元素a

根据上述添加元素的过程，则必须有两个要求：

向Set中添加的数据，其所在的类一定要重写hashCode()和equal()
重写的hashCode()和equal()尽可能保持一致性：相等的对象必须具有相等的哈希值

5.4 TreeSet的排序

自然排序（实现Comparable接口）

向TreeSet中添加的数据，要求是相同类的对象，否则报错

自然排序中，若比较的是两个对象，则使用compareTo()，而不是equal()

//导入的包有：import org.junit.Test;import java.util.Iterator;import java.util.TreeSet;

public class TreeSetTest {
    @Test
    public void test1(){
        TreeSet set = new TreeSet();

        set.add(-1);
        set.add(-5);
        set.add(11);
        set.add(10);
        set.add(35);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());//-5,-1,10,11,35
        }

    }
}

定制排序（实现Comparator接口）

自然排序中，若比较的是两个对象，则使用compare()，而不是equal()

6. Map接口

6.1 Map接口概述

Map接口：双列数据，存储key-value对的数据，类似函数。其实现类有：

HashMap： 作为Map的主要实现类；线程不安全的，效率高；可存储null的key和value
- LinkedHashMap： 保证在遍历map元素时，可以按照添加的顺序实现遍历，对于频繁的遍历操作，效率高于HashMap
TreeMap： 保证按照添加的key-value对进行排序，实现排序遍历，此时考虑key的自然排序或定制排序，底层使用红黑树
Hashtable： 作为古老的实现类；线程安全的，效率低；不能存储null的key和value
- Properties： 常用来处理配置文件。key和value都是String类型

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TggjSByu-1595729476939)(F:\JianShu_material\Java\图片\集合\００３.png)]$

6.2 Map的底层实现原理

Map结构的理解

Map中的key：无序的、不可重复的，使用Set存储所有的key

Map中的value：无序的、可重复的，使用Collection存储所有的value

一个键值对：key-value构成了一个Entry对象

Map中的entry：无序的、不可重复的，使用Set存储所有的entry

JDK7中HashMap的底层实现原理

HashMap map=new HashMap()：在实例化以后，底层创建了长度是16的一维数组Entry[] table。
map.put(key1,value1)：当添加元素时，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
- 如果此位置上的数据为空，此时的key1-value1添加成功。--------------情况1
- 如果此位置上的数据不为空，意味着此位置上存在一个或多个数据（以链表形式存在），比较key1和已经存在的一个或多个数据的哈希值：
  - 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----------------情况2
  - 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)：
    - 如果equals()返回false：此时key1-value1添加成功。-----------------情况3
    - 如果equals()返回true：使用value1替换value2

补充：关于情况2和情况3，此时key1-value1和原来的数帮以链表的方式存储。

扩容问题：在不断的添加过程中，会涉及到扩容问题，默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。

JDK8中HashMap的底层实现原理

JDK8相较于JDK7在底层方面有些不同：

new HashMap()：底层没有创建一个长度为16的数组
JDK 8底层的数组是：Node[]，而非Entry[]
首次调用put()方法时，底层创建长度为6的数组
JDK7底层结构只有：教组+链表。JDK8中底层结构：数组+链表+红黑树。
- 当数组的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时，此时此索引位置上的所有数据改为使用红黑树存储。

6.3 Map中的常用方法

put()、putAll()、remove()、clear()

Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m)：将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()： 清空当前map中的所有数据

//导入的包有：import org.junit.Test;import java.util.HashMap;import java.util.Map;

public class MapTest {
    @Test
    public void test1(){
        Map map = new HashMap();

        //put():添加
        map.put("AA",123);
        map.put("BB",123);
        map.put(45,123);

        //put():修改
        map.put("BB",0);

        System.out.println(map);//{AA=123, BB=0, 45=123}

        Map map1 = new HashMap();
        map1.put("DD",123);
        map1.put("EE",123);

        //putAll()
        map.putAll(map1);
        System.out.println(map);//{AA=123, BB=0, DD=123, EE=123, 45=123}

        //remove()
        Object value = map.remove("AA");
        System.out.println(value);//123
        System.out.println(map);//{BB=0, DD=123, EE=123, 45=123}

        //clear()
        map.clear();
        System.out.println(map.size());//0
        System.out.println(map);//{}
    }
}

get()、containsKey()、containsValue()、size()、isEmpty()、equals()

Object get(Object key)： 获取指定key对应的value
boolean containsKey(Object key)： 是否包含指定的key
boolean containsValue(Object value)： 是否包含指定的value
int size()： 返回map中key-value对的个数
boolean isEmpty()： 判断当前map是否为空
boolean equals(Object obj)： 判断当前map和参数对象obj是否相等

//导入的包有：import org.junit.Test;import java.util.HashMap;import java.util.Map;

public class MapTest {
    @Test
    public void test2(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",123);
        map.put(45,123);

        //get()
        System.out.println(map.get(45));//123

        //containsKey()
        System.out.println(map.containsKey("AA"));//true

        //containsValue()
        System.out.println(map.containsValue(123));//true

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

        Map map1 = new HashMap();
        map1.put("AA",123);
        map1.put("BB",123);
        map1.put(45,123);
        //equals()
        System.out.println(map.equals(map1));//true

        map.clear();
        //isEmpty()
        System.out.println(map.isEmpty());//true
    }
}

###keySet()、values()、entrySet()

Set keySet()： 返回所有key构成的Set集合
Collection values()： 返回所有value构成的Collection集合
Set entrySet()： 返回所有key-value对构成的Set集合

//导入的包：import org.junit.Test;import java.util.*;

public class MapTest {
    @Test
    public void test3(){
        Map map = new HashMap();
        map.put("AA",1);
        map.put("BB",12);
        map.put(45,123);

        //遍历所有的key集：keySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //遍历所有的value集：values()
        Collection values = map.values();
        for(Object obj : values){
            System.out.println(obj);
        }

        //遍历所有的key-value：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while(iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
    }
}

6.4 TreeMap的排序

分为自然排序和定制排序，可参考 【5.4 TreeSet的排序】

6.5 Properties处理属性文件

//导入的包有：import java.io.FileInputStream;import java.util.Properties;

public class PropertiesTest {
    public static void main(String[] args) {
        Properties pros = new Properties();
        
        fis = new FileInputStream(jdbc.properties);
        pros.load(fis);//加载流对应的文件
        
        String name = pros.getProperty("name");
        String password = pros.getProperty("password");

        System.out.println("name = " + name + ", password = " + password); 
    }
}

7. Collections工具类

7.1 Collections概述

Collections是一个操作Set、List和Map等集合的工具类

Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

7.2 Collections常用方法

reverse(List)： 反转 List 中元素的顺序
shuffle(List)： 对 List 集合元素进行随机排序
sort(List)： 根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)： 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)： 将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection)： 根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)： 根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)： 返回指定集合中指定元素的出现次数
void copy(List dest,List src)： 将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)： 使用新值替换List对象的所有旧值
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pjQBSYWx-1595729476941)(F:\JianShu_material\Java\图片\集合\004.png)]$

尔玉先生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java：集合

1. Java集合框架概述1.1 集合定义集合、数组都是对多个数据进行存储操作的结构，简称Java容器。面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。而使用Array存储对象方面具有一些弊端。数组的弊端：数组初始化以后，长度就不可变了，不便于扩展数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。存储数据的特点单一，存储的数据是有序的、可以重复的。Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关.
复制链接

扫一扫