Java集合的基本使用

集合基本使用

在Java中，集合的接口主要包括Collection和Map，具体继承关系如下所示。使用之前需要导入相应的包java.util.xxx

Collection 常见方法

int size(); // 返回集合中元素的个数

boolean add(E e); // 向集合中添加一个元素

boolean addAll(Collection<? extends E> c); // 向集合中添加一组元素

void clear(); // 清空集合中的元素

boolean remove(Object o); // 删除某个特定元素

boolean contains(Object o); // 查找一个元素是否存在

boolean containsAll(Collection<?> c); // 查找一组元素是否存在

boolean isEmpty(); // 判断集合是否为空

Iterator iterator(); // 返回对应迭代器

Object[] toArray(); // 以对象数组的形式返回集合内容

T[] toArray(T[] a); // 指定对应泛型，返回集合内容

List 常见方法

void add(int index, E element); // 将元素添加到指定位置

E get(int index); // 返回指定位置的元素

E remove(int index); // 移除指定位置的元素，返回被移除的元素

E set(int index, E element); // 用指定元素替换集合中指定位置的元素

ArrayList

// 创建
ArrayList<String> list = new ArrayList<>();

// 添加元素
list.add(obj);
list.addAll();
// boolean addAll(Collection c);

// 访问元素，按索引
obj = list.get(index);

// 删除元素，按索引
list.remove(index);

// 删除元素，按内容
list.remove(obj);

// 计算大小
len = list.size()

// 返回元素的索引值
index = list.indexOf(obj);

// 判断是否包含某元素
list.contains();

// 清空
list.clear();

// 判断是否为空
list.isEmpty();

LinkedList

ArrayList中的方法，LinkedList都能够使用，除此以外还有更多的方法。

// 创建
LinkedList<Integer> list = new LinkedList<>();

// 元素添加到头部
list.addFirst(E e);

// 元素添加到尾部
list.addLast(E e);	

// 删除并返回第一个元素
int a = list.removeFirst();	

// 删除并返回最后一个元素
int b = list.removeLast();	

Stack

// 创建
Stack<Integer> stack = new Stack<>();

// 压栈
stack.push(int element);

// 弹栈并返回元素
int a = stack.pop();

// 获取栈顶元素
int b = stack.peek();

// 判断是否为空
stack.isEmpty();
stack.empty();

Queue 常见方法

// 队尾添加元素 
// 队列满的时候add抛出异常，offer返回false
boolean offer(E e);
void add(E e);

// 弹出队首元素
// 队列为空的时候remove抛出异常，poll返回Null
E poll();
E remove();

// 查看队首元素
// 队列为空的时候element抛出异常，peek返回Null
E element();
E peek();

LinkedList和ArrayDeque

双端队列，可以用来模拟栈。

// 创建
LinkedList<Integer> deque = new LinkedList<>();
ArrayDeque<Integer> deque = new ArrayDeque<>();

// 添加元素
deque.offer(int element);

// 返回并删除队首元素
int a = deque.poll();

// 查看队首元素
int b = deque.peek();

// 判空
deque.isEmpty();

// 大小
deque.size();

PriorityQueue

优先队列，可以用来模拟堆。默认为小根堆，可以通过比较函数来指定称为大根堆。（比较函数可以通过定义匿名类或者Lambda表达式实现）

// 小根堆
PriorityQueue<Integer> qmin = new PriorityQueue<>();
// 大根堆-匿名类
PriorityQueue<Integer> qmax = new PriorityQueue<>(new Comparator<Integer>(){
    public int compare(Integer a, Integer b){
        return b - a;
    }
});
// 大根堆-lambda表达式
PriorityQueue<Integer> qmax = new PriorityQueue((x, y) -> y - x)
    
// 大根堆-使用Collections接口
PriorityQueue<Integer> qmax = new PriorityQueue<>(Collections.reverseOrder());

// 添加
qmax.offer(4);

// 返回并删除
qmax.poll();

// 查看堆顶
qmax.peek();

Set 常见方法

// 返回集合中小于等于给定元素的最大元素，不存在则返回null
floor(E e);

// 返回集合中大于等于给定元素的最小元素，不存在则返回null
ceiling(E e);

// 返回集合中小于给定元素的最大元素，不存在则返回null
lower(E e);

// 返回集合中大于给定元素的最小元素，不存在则返回null
higher(E e);

HashSet

// 创建
HashSet<String> set = new HashSet<String>();

// 基本与ArrayList相同
// 添加
set.add("xxx");

// 删除
set.remove("yyy");

// 返回大小
set.size();

// 判断是否包含元素
set.contains("xxx");

// 清空
set.clear();

Map 常见方法

// 增加或修改键值对
void put(Object key, Object value);

// 根据key值获取对应的值，不存在返回null
Object get(Object key);

// 根据key值获取对应的值，没有返回默认值
Object getOrDefault(Object key, Object defalutValue);

// 判断是否包含该key
boolean containsKey(Object key);

// 判断是否包含某个值
boolean containsValue(Object value);

// 返回key的Set视图
Set keySet();

// 返回value的Collection视图
Collection values();

// 返回映射关系的Set视图
Set<Map.Entry<K, V>> entrySet();

K-V的遍历：

Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
for(Map.Entry<Integer, Integer> entry: entries){
    int key = entry.getKey();
    int value = entry.getValue();
}

HashMap

// 创建
HashMap<String, Integer> map = new HashMap();

// 加入键值对
map.put(key, value);

// 按key获取value
v = map.get(key);

// 返回所有key集合
map.keySet();

// 返回所有value集合
map.values();

// 删除
map.remove(key);
map.remove(key, value);

// 替换
map.replace(key, value);
map.replace(key, oldValue, newValue);

// 判断是否包含key
map.containsKey(key);
// 判断是否包含value
map.containsValue(value);

// 如果要迭代hashmap的话，可以选择迭代key或value
// 通常迭代key会多一些
// 使用for each语句即可，例如
for(int i: map.keySet()) {
  ...
}

TreeMap

// 创建
TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>();

// 由于TreeMap可以进行对Key的排序，所以可以用下面的操作
// 返回大于或等于给定键的最小键，如果没有则返回null
map.ceilingKey(Integer key);

// 返回小于或等于给定键的最大键，如果没有则返回null
map.floorKey(Integer key);

工具类

Collection工具类

ArrayList<Integer> array = new ArrayList<>();

// 反转
Collections.reverse(array);

// 随机排序
Collections.shuffle(array);

// 交换指定位置上的元素
Collections.swap(array, 1, 3);

// 排序
Collections.sort(array);

// 自定义排序
Collections.sort(array, new Comparator<Integer>(){
    public int compare(Integer t1, Integer t2){
        return t2 - t1;
    }
});

// 最大值
Collections.max(array);

// 统计1出现的次数
Collections.frequency(array, 1);

// 二分查找，返回索引
Collections.binarySearch(array, 1);

Arrays工具类

int a[] = {1, 2, 3, 4, 54, 5, 6, 6};

Arrays.sort(a); // 排序

Arrays.asList(T ...p); // 生成List

参考文章

1. Java刷题常用集合类以及函数总结_叶~子的博客-CSDN博客_java集合函数
2. Java常用容器基础操作汇总 - JavicxhloWong - 博客园 (cnblogs.com)