Java容器用法汇总

容器分类

1

  • List(对付顺序的好帮手): 存储的元素是有序的、可重复的。
  • Set (注重独一无二的性质)：存储的元素是无序的、不可重复的。
  • Queue (实现排队功能的叫号机):按特定的排队规则来确定先后顺序，存储的元素是有序的、可重复的。
  • Map (用 key 来搜索的专家) :使用键值对（key-value）存储，类似于数学上的函数 y=f(x)，“x” 代表 key，“y” 代表 value，key 是无序的、不可重复的，value 是无序的、可重复的，每个键最多映射到一个值。

Collection

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import java.util.*;

public class CollectionAPITest {

    public static void main(String[] args) {
        //Collection是接口，使用需要实现类
        Collection col = new ArrayList();
        //add()添加一个元素，添加基本数据类型，会自动装箱，int--->Integer
        col.add(1);
        col.add(2);
        System.out.println("使用add方法添加1和2："+col);
        //addALl()添加一个集合的所有元素
        List<Integer> integers = Arrays.asList(new Integer[]{3, 4, 5, 6, 7, 8});
        col.addAll(integers);
        System.out.println("使用addAll方法添加{3, 4, 5, 6, 7, 8}:"+col);
        System.out.println(Integer.toBinaryString(2)+" "+Integer.toBinaryString(-2)+" "+Integer.toHexString(-2>>>2)+" "+Integer.toBinaryString(-2>>>2));
        //remove()方法移除指定元素
        System.out.println("使用remove()方法移除元素1："+col.remove(1)+"(true成功/false失败)移除后集合"+col);
        System.out.println("再次使用remove()方法移除元素1："+col.remove(1)+"(true成功/false失败)移除后集合"+col);
        System.out.println(Integer.toBinaryString(2)+" "+Integer.toBinaryString(-2)+" "+Integer.toHexString(-2>>>2)+" "+Integer.toBinaryString(-2>>>2));
        //clear()方法清除集合
        col.clear();
        System.out.println("使用clear方法清除集合"+col);
        //isEmpty()方法查看集合是否为空
        System.out.println("使用isEmpty方法查看集合是否为空"+col.isEmpty());
        System.out.println(Integer.toBinaryString(2)+" "+Integer.toBinaryString(-2)+" "+Integer.toHexString(-2>>>2)+" "+Integer.toBinaryString(-2>>>2));
        //equals()方法比较两个集合是否相等
        ArrayList<Object> objects = new ArrayList<>();
        System.out.println("集合一："+col+"集合二："+objects+"使用equals()比较两个集合元素是否相等"+col.equals(objects));
        objects.add(1);
        System.out.println("集合一："+col+"集合二："+objects+"使用equals()比较两个集合元素是否相等"+col.equals(objects));
        System.out.println(Integer.toBinaryString(2)+" "+Integer.toBinaryString(-2)+" "+Integer.toHexString(-2>>>2)+" "+Integer.toBinaryString(-2>>>2));
        //contains()方法判断集合是否包含指定元素
        System.out.println("集合："+objects+"使用contains()方法判断集合是否包含1这个元素"+objects.contains(1));
        System.out.println("集合："+objects+"使用contains()方法判断集合是否包含2这个元素"+objects.contains(2));
        System.out.println(Integer.toBinaryString(2)+" "+Integer.toBinaryString(-2)+" "+Integer.toHexString(-2>>>2)+" "+Integer.toBinaryString(-2>>>2));
        //size()方法获取集合长度
        System.out.println("集合："+col+"使用size()方法获取集合长度"+col.size());
        System.out.println("集合："+objects+"使用size()方法获取集合长度"+objects.size());
        System.out.println(Integer.toBinaryString(2)+" "+Integer.toBinaryString(-2)+" "+Integer.toHexString(-2>>>2)+" "+Integer.toBinaryString(-2>>>2));
        //使用iterator()迭代器遍历集合
        col.addAll( Arrays.asList(new Integer[]{3, 4, 5, 6, 7, 8}));
        System.out.println("使用iterator()遍历集合"+col);

        Iterator iterator = col.iterator();//获取Iterator对象
        int i = 1;
        while(iterator.hasNext()){//Iterator.hasNext()方法，判断是否有个下一个可迭代对象
            Object next = iterator.next();//返回当前元素，并指针后移，指针指向下一个元素，若没有，下一次hasNext方法会做处理
            System.out.println("第"+i+"个元素："+next);
            i++;
        }

    }
}

常见用法

List

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//增删改查方法
public void add(Object element) //增添元素
public void add(int index,Object element) //在指定位置增添元素
public boolean remove(Object o) //删除指定对象
public Object remove(int index) //删除指定位置的元素
public Object set(int index,Object element) //修改指定位置元素的值
public Object get(int index) //获取指定位置元素
public int indexOf(Object o) //获取指定元素的位置
public boolean contains(Object o) //判断指定元素是否存在
 
//其他常用方法
public int size() //获取容器中元素个数
public Iterator<E> iterator() //获取迭代器
public void clear() //清空元素

ArrayList适合快速查找元素，LinkedList适合频繁地对列表进行增加或删除元素操作，因此LinkedList类可用于实现堆栈和队列，对此LinkedList类中定义了特定的方法，如下：

1
2
3
4
5
6
7
8
9
10
11
//模拟栈和队列操作
public void addFirst(Object o) //在链表头增添元素
public void addLast(Object o) //在链表尾增添元素
public Object removeFirst() //删除链表头元素，并返回该元素
public Object removeLast() //删除链表尾元素，并返回该元素
public boolean isEmpty() //判断链表是否为空
 
public void push(E e) //等价于addFirst()
public E pop() //等价于removeFirst()
public E getFirst() //获取链表首元素
public E getLast() //获取链表尾元素

Set

1
2
3
4
5
6
7
8
9
10
//增删查方法
public void add(Object element) //增添元素
public boolean remove(object element) //删除元素
public boolean contains(Object o) //判断元素是否存在
 
//其他常用方法
public int size() //获取容器中元素个数
public boolean isEmpty() //判断集合是否为空
public Iterator<E> iterator() //获取迭代器
public void clear() //清空元素

Map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//增删查
public Object put(Object key,Object value) //增添元素
public Object remove(Object key) //删除元素,并返回键对应的值
public Object get(Object key) //获取键对应的值
public boolean containsKey(Object key) //判断指定键是否存在
public boolean containsValue(Object value) //判断指定值是否存在
 
//获取键、值、元素集合
public Collection values() //获取值集合
public Set KeySet() //获取键集合
public Set entrySet() //获取元素集合
 
//其他方法
public int size() //获取容器中元素个数
public boolean isEmpty() //判断容器是否为空
public void clear() //清空元素

Map 接口没有提供 iterator() 方法，其子接口 Entry 提供了 iterator() 方法，并且提供了获取键、值的方法，如下：

1
2
3
4
5
6
7
8
9
10
11
12
//Map.Entry接口主要方法
public Iterator<E> iterator() //获取迭代器
public Object getKey() //获取键
public Object getValue() //获取值
 
//调用案例
Iterator(Entry) iter=map.entrySet().iterator();
while(iter.hasNext()){
    Entry entry=iter.next();
    int key=(Integer)entry.getKey();
    int val=(Integer)entry.getValue();
}

Arrays

1
2
3
4
5
6
7
8
public static int binarySearch(Object[] a, Object key) //二分查找（a已排序）
public static boolean equals(Object[] a, Object[] a2) //判断两数组是否完全一致
public static void fill(Object[] a, Object val) //在a中所有位置填充val
public static void fill(Object[] a, int fromIndex, int toIndex, Object val) //在[fromIndex,toIndex)中填充元素val
public static String toString(Object[] a) //将数组a转换为字符串，如"[1, 2, 3]"
public static void sort(Object[] a) //改进的快速排序（升序）
public static void sort(Object[] a, int fromIndex, int toIndex) //对[fromIndex,toIndex)中的元素排序（升序）
public static <T> void sort(T[] a, Comparator<? super T> c) //自定义比较器排序

HashMap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 创建 HashMap 对象 Sites
HashMap<Integer, String> Sites = new HashMap<Integer, String>();
// 添加键值对
Sites.put(1, "Google");
//使用 get(key) 方法来获取 key 对应的 value		
//remove(key) 方法来删除 key 对应的键值对(key-value)


clear()					//删除 hashMap 中的所有键/值对
clone()					//复制一份 hashMap
isEmpty()				//判断 hashMap 是否为空
size()					//计算 hashMap 中键/值对的数量
put()					//将键/值对添加到 hashMap 中
putAll()				//将所有键/值对添加到 hashMap 中
putIfAbsent()			//如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。
remove()				//删除 hashMap 中指定键 key 的映射关系
containsKey()			//检查 hashMap 中是否存在指定的 key 对应的映射关系。
containsValue()			//检查 hashMap 中是否存在指定的 value 对应的映射关系。
replace()				//替换 hashMap 中是指定的 key 对应的 value。
replaceAll()			//将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。
get()					//获取指定 key 对应对 value
getOrDefault()			//获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
forEach()				//对 hashMap 中的每个映射执行指定的操作。
entrySet()				//返回 hashMap 中所有映射项的集合集合视图。
keySet()				//返回 hashMap 中所有 key 组成的集合视图。
values()				//返回 hashMap 中存在的所有 value 值。
merge()	     			//添加键值对到 hashMap 中
compute()				//对 hashMap 中指定 key 的值进行重新计算
computeIfAbsent()		//对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中
computeIfPresent()		//对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。