Java常用集合

目录

根据“Admol”的博客Java常用集合总结整理，集合中的方法可结合Java帮助文档查看学习

List

public class List
extends Component
implements ItemSelectable, Accessible

有序的 collection（也称为序列）,允许重复的元素。

常用实现类：

ArrayList

public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

底层使用的是数组结构,特点:查询速度快,增删操作较慢,而且线程不同步。因此根据博客“多线程”中的“三大不安全案例”中的第三个，线程不安全。

要保证同步,可以使用：List list = Collections.synchronizedList(new ArrayList());进行包装。

常用方法：

add(E e)：将指定元素追加到此列表末尾

add(int index, E element)：在此列表指定位置插入指定元素

addAll(Collection<? extends E> c)：按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾

addAll(int index, Collection<? extends E> c)：将指定集合中的所有元素插入到此列表中，从指定的位置开始。

clear()：从列表中删除所有元素。

contains(Object o)：如果此列表包含指定的元素，则返回 true 。

get(int index)： 返回此列表中指定位置的元素。

indexOf(Object o)：返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

remove(int index)：删除该列表中指定位置的元素。

remove(Object o)：从列表中删除指定元素的第一个出现（如果存在）。

removeAll(Collection<?> c)：从此列表中删除指定集合中包含的所有元素。

set(int index, E element)：用指定的元素替换此列表中指定位置的元素。

size()： 返回此列表中的元素数。

sort(Comparator<? super E> c)：方式为Collections.sort(list);

Array.java

package com.sgkurisu.base;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Array {
    public static void main(String[] args) throws InterruptedException {
        List<Integer> list = new ArrayList<Integer>();

        //add方法
        list.add(1);
        list.add(3);
        list.add(2);
        list.add(4);
        //sort方法
        Collections.sort(list);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println(list.size());
        //remove方法
        for (int i = 0; i < list.size(); i++) {
            list.remove(i);
        }
        //测试线程同步
        List<Integer> list1 = Collections.synchronizedList(new ArrayList<Integer>());
        System.out.println(list1.size());
        for (int i = 0; i < 10000; i++) {
            int a = i;
            new Thread(()->{
                //list1.add(i);在Lamda表达式中应按照以下方式
                list1.add(a);
            }).start();
        }
        Thread.sleep(100);
        System.out.println(list1.size());
    }
}

LinkedList

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

使用双向链表实现存储，允许所有元素（包括 null）。非线程安全,要保证同步,可以使用List list = Collections.synchronizedList(new LinkedList());进行包装,可以被当作堆栈和队列来使用。

List list = new LinkedList();

Vector

public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

Vector类实现了可扩展的对象数组。像数组一样，它包含可以使用整数索引访问的组件。 但是，Vector的大小可以根据需要增长或缩小，以适应在创建Vertor之后添加和删除项目。 Vector线程安全，如果不需要线程安全的实现，建议使用ArrayList代替Vector。

测试线程安全性

package com.sgkurisu.base;

import java.util.List;
import java.util.Vector;

public class Vec {
    public static void main(String[] args) throws InterruptedException {
        List list = new Vector<Integer>();

        for (int i = 0; i < 100000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(100);
        System.out.println(list.size());
    }
}

Map

HashMap

基于哈希表的 Map 接口的实现,存储键值对，键是唯一的,允许使用 null 值和 null 键,非同步，同步可以使用Map m = Collections.synchronizedMap(new HashMap<>());

常用方法：

clear()：从这张地图中删除所有的映射。

get(Object key)：返回到指定键所映射的值，如果返回null，可以判断该键不存在。 当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

isEmpty()：如果此地图不包含键值映射，则返回 true。

remove(Object key)： 从该地图中删除指定键的映射（如果存在）。

remove(Object key, Object value)：仅当指定的密钥当前映射到指定的值时删除该条目。

size()： 返回此地图中键值映射的数量。

HashTable

底层是哈希表数据结构，不可以存入null键null值，是线程同步的

Set

HashSet

底层数据结构是哈希表(实际上是一个 HashMap 实例)，允许使用 null 元素,唯一且无序,非线程安全

Collections

此类仅由静态方法组合或返回集合。实现对集合的查找、排序、替换、 线程安全化（将非同步的集合转换成同步的）等操作。

Arrays

此类由静态方法组成，包含用于操作数组的各种方法（如排序和搜索）。

posted @ 2021-02-19 13:10  sgKurisu  阅读(53)  评论(0)    收藏  举报