Java集合整理

最新推荐文章于 2022-11-13 22:02:46 发布

一只小林同学

最新推荐文章于 2022-11-13 22:02:46 发布

阅读量176

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_40401156/article/details/106433706

版权

Java 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

Java集合

一、集合概念

C++的STL给我们提供了vector、list、stack等方便好用的容器，在java中也同样拥有一些类似的容器模板，这个模板被叫做集合。集合将一些基本的和使用频率极高的基础类进行封装增强后再以一个类或接口的形式提供。集合中存放着一系列对象，并且长度是可变的。不同的集合由不同的供和特点，适用于不同的场合。
在这里插入图片描述
集合类的框架

从图中可以看出，java集合主要分为两大块，Collection集合和Map映射，其中Collection下又分为三个小类，List列表，Set集合和Queue队列，再下面是每个小类的抽象类和实现类。我们可以看到一个集合总是包括三个部分：接口、抽象类和实现类。

二、具体的接口与类

1、Collection

Collection接口是最基本的集合接口，一个Collection代表一组Object，即Collection的元素，java不提供直接继承自Collection的类，只提供继承于Collection的子接口。

2、List

List继承于Collection，是一个有序的列表，存储的是同一个类的对象，允许出现相同的对象，可以通过整数索引来获取存储在相应位置的对象，可以理解为增加了索引的链表

2.1、vector类

vector类继承了AbstractList类，和ArrayList有些类似，可以理解为时一种动态长度的数组，vector是线程安全的，实现了Serializable接口，其内部有很多代码来同步以保证线程安全。

vector的创建：

Vector();//构造一个默认向量，长度为10
Vector(int size);//构造一个长度为size的向量
Vector(int size,int incr);//构造一个长度为size的向量，inrc表示每次增加的元素数目
Vector(Collection c);//创建一个包含集合c的元素的向量

vector常用方法：

void add(int index,Object element)//在index处插入元素element
boolean add(Object o)//在向量末尾添加元素o
boolean addAll(Collection c)//将集合c中的所有元素添加到向量末尾，按指定Collection迭代器所返回的顺序添加这些元素
boolean addAll(int index,Collection)//在index处插入Collection中的所有元素
void addElement(Object o)//将o添加到向量末尾
int capacity()//返回向量容量
int clear()//移除所有元素
boolean contains(Object o)//判断向量是否包含o
boolean containsAll(Collection c)//判断向量是否包含Collection中的所有元素
Object elementAt(int index)//返回index索引处的元素
Object get(int index)//返回指定位置的元素
int hashcode()//返回次向量的哈希吗
int indexOf(Object elem)//返回向量中第一次出现指定元素elem的索引位置，若不包含该元素则返回-1
int indexOf(Object elem,int index)//返回向量中第一次出现元素elem的索引，从index处开始正向搜索，若没有该元素返回-1
void insertElementAt(Object obj,int index)//在指定位置插入元素obj
Object remmove(Object)//删除向量中第一个匹配的元素
void setSize(int newSize)//重设向量的大小

2.2、ArrayList类

ArrayList实现了List接口，和Vector类似，可以把它理解为动态数组，其底层也是用数组实现的

ArrayList的创建：

ArrayList有三个构造方法，其中默认构造方法会创建一个容量为10的ArrayList

ArrayList<String> arraylist = new ArrayList<>();//默认构造函数，创建建一个容量为10的ArrayList
ArrayList<String> arraylist = new ArrayList<>(100);//带参构造函数，参数为int型，创建一个传入的参数大小的ArrayList
ArrayList<String> arraylist = new ArrayList<>(new HashSet());//带参构造函数，传入一个Collection型的参数，将其中的元素存入ArrayList中

ArrayList常用方法：

boolean add(E element);//将元素element添加到ArrayList尾部
void add(int index,E element);//将元素element插入到指定位置
boolean addAll(Collection c);//将集合c中的元素按照迭代器返回的顺序加入到ArrayList的尾部
boolean addAll(int index,Collection c);//将集合c中的元素按迭代器返回的顺序插入到ArrayList指定位置
void clear();//移除ArrayList中的所有元素
Object clone();//返回ArrayList实例的浅复制副本
boolean contains(Object o);//若ArrayList中包含o则返回true
E get(int index);//返回ArrayList索引index处的元素
int indexOf(Object o);//返回列表中首次出现元素o得到索引
boolean isEmpty();//判断ArrayList是否为空
int lastIndexOf(Object o);//返回最后一次出现元素o的索引
E remove(int index);//移除指定索引处的元素，并返回该元素
boolean remove(Object o);//移除元素o首次出现的元素
E set(int index,E element);//将索引index处的元素设置为新的元素element并返回原来的元素
int size();//返回元素个数
Object[] toArray();//将ArrayList转为数组

2.3、LinkedList类

LinkedList继承了AbstractSequentialList类，是一个双向链表

LinkedList的创建：

LinkedList<String> linkedlist = new LinkedList<>();//创建一个空链表
LinkedList<String> linkedlist = new LinkedList<>(Collection c);//以传入的Collection类构造链表

LinkedList常用方法：

boolean add(Object o);//将元素o插入到链表尾部
boolean add(int index,Object o);//将元素插入到索引index处
boolean addAll(Collection c);//将集合c中的所有元素添加到链表尾部
boolean addAll(int index,Collection c);//将集合c中的元素插入到索引index处
boolean remove(Object o);//删除指定节点
E remove(int index);//删除指定索引节点并返回该节点
E set(int index,E element);//将索引index处的元素替换为element，并返回原来的元素
void clear();//删除所有元素
int indexOf(Object o);//返回第一个元素o的索引，若元素不存在则返回-1
int lastIndexOf(Object o);//返回最后一个o元素的索引，若元素不存在则返回-1；
Object clone();//返回一个浅复制实例
Object[] toArray();//将链表转为数组
int size();//返回元素个数
boolean contains(Object o);//判断链表中是否包含元素o

此外LinkedList还可以用来模拟队列

LinkedList关于队列的方法：

E peek();//获取队列的第一个元素
E element();//获取队列的第一个元素，若为null则抛出异常
E poll();//获取并删除队列第一个元素，若为null则抛出异常
E remove();//获取并删除队列的第一个元素，若为null则抛出异常
boolean offer(E e);//将元素添加到队列尾部
boolean offerFirst(E e);//将元素添加到首部
boolean offerLast(E e);//将元素添加到尾部
E peekFirst();//获取首部元素
E peekLast();//获取尾部元素
E pollFirst();//删除首部元素，若为null抛出异常
E pollLast();//删除尾部元素，若为null抛出异常
void push();//将元素添加到首部
E pop();//删除首部，若为null抛出异常
boolean removeFirstOccurrence(Object o);//删除链表中元素之等于o的第一个节点
boolean removeLastOccurrence(Object o);//删除链表中元素之等于o的最后一个节点

2.4、ArrayList与LinkedList的对比：

ArrayList是基于索引的数据结构，底层使用数组实现，因此通过索引来获得元素的速度很快，但插入和删除的效率较低，ArrayList每次进行插入或者删除都需要对其中的元素进行移动，初始化时必须指定长度（虽然默认构造函数不需要参数，但他默认指定数组长度为10）；LinkedList是基于链表实现的，因此查询元素的速度很慢，因为要对链表进行遍历，但相应的插入删除的效率相对较高。此外ArrayList与LinkedList都是线程不安全的。

ArrayList与LinkedList操作时间复杂度对比：

操作	ArrayList	LinkedList
随机访问	O(1)	O(n)
头部插入	O(n)	O(1)
尾部插入	O(1)	O(1)
头部删除	O(n)	O(1)
尾部删除	O(1)	O(1)
随机插入（插入位置index）	O(n-index)	O(index)

3、Set

set是一个集合，这个集合就类似于数学上的集合，是一个无序的，不重复的同一类元素的集体。由于是无序的，Set并不能通过索引来获取元素

3.1、HashSet

private transient HashMap<E,Object> map;

从源码中可以看到HashSet底层是使用HashMap实现的，其继承了AbstractSet类，实现了Set接口

HashSet的创建：

HashSet<String> set = new HashSet<>();//默认构造其
HashSet<String> set = new HashSet<>(Collection c);//将参数集合c中的元素添加到集合中
HashSet<String> set = new HashSet<>(initialCapacity);//initialCapacity是一个int型参数，表示集合的初始容量
HashSet<String> set = new HashSet<>(initialCapacity,loadFactor);//initialCapacity是一个int型的参数，表示HashSet的初始容量，loadFactor是float型参数，表示加载因子；加载因子体现HashMap中元素的填满程度，加载因子越大，填满的元素越多，但冲突机会也就越高，反之填满的元素越少，冲突机会越少

HashSet常用方法：

boolean add(E e);//添加元素
boolean remove(Object o);//删除指定元素
boolean contains(Object o);//查找集合中是否包含元素o
void clear();//清空集合
Object clone();//返回一个浅复制实例
int size();//获取元素个数

3.2、TreeSet

    public TreeSet() {
        this(new TreeMap<E,Object>());
    }

从默认构造函数可以看到，TreeSet是基于TreeMap实现的，其继承了AbstractSet类，实现了NavigableSet, Cloneable, java.io.Serializable接口

TreeSet的创建：

TreeSet<String> set = new TreeSet<>();//默认构造函数
TreeSet<String> Set = new TreeSet<>(Collection c);//创建包含集合c中元素的集合
TreeSet<String> set = new TreeSet<>(comparator);//comparator是一个比较器
TreeSet<String> set = new TreeSet<>(set);//set是Sort恶的Set类型的参数，创建包含set中的元素的集合

TreeSet常用方法：

boolean add(E e);//添加元素e
boolean addAll(Collection c);//将c中的元素全部添加到集合中
void clear();//清空集合
Object clone();//返回一个浅复制实例
boolean contains(Object o);//确认集合中是否包含元素o
E first();//返回第一个元素
E last();//返回最后一个元素
SortedSet headSet(Object toElement);//返回集合中小于等于指定元素的元素
SortedSet tailSet(Object toElement);//返回集合中大于等于指定元素的元素
SortedSet subSet(Object fromElement,Object toElement);//返回从fromElement到toElement的元素
boolean isEmpty();//集合判空
int size();//返回元素个数
boolean remove(Object o);//删除集合中的指定元素

3.3、HashSet与TreeSet对比

HashSet底层使用HashMap实现的，内部元素是无序的，是线程不安全的，HashSet不允许保存重复对象，HashSet中使用hashcode与equals方法判断对象的唯一性，若hashcode值不同则不判断equals方法，若hashcode相同，则比较equals方法；TreeSet保存的对象是有顺序的，其底层使用红黑树实现，由于TreeSet是有序的，因此在构造的时候需要实现Comparable接口或将比较器作为参数传入构造函数

4、Queue

队列接口，LinkedList实现了Queue接口，因此可以把LinkedList当做Queue使用

5、Map

Map是一种映射关系，将键映射到相应的值，一个映射不能包括相同的键，但可以允许值的重复

5.1、HashMap

HashMap即哈希表，是一种基于数组和链表的散列结构，其实现了Map接口，查找性能高，在不考虑哈希冲突的情况下查找一个键所对应的值往往只要O(1)的时间复杂度

哈希冲突：

若两个不同的元素通过哈希算法得出的是同一位置，那么就产生了哈希冲突，HashMap中使用链地址法解决哈希冲突，即在产生冲突的位置用一个链表来存储冲突的元素

HashMap的创建：

Map<String,String> map = new HashMap();
Map<String,String> map = new HashMap(capacity);//capacity是一个int参数，指定HashMap容量大小
Map<String,String> map = new HashMap(capacity,loadFactor);//capacity是一个int参数，指定HashMap容量大小，loadFactor是一个float参数，表示加载因子
Map<String,String> map = new HashMap(Map<String,String> m);//通过一个已有的map创建HashMap

HashMap常用方法：

void clear();//清空元素
Object clone();//返回一个浅复制实例
boolean containsKey(Object key);//判断HashMap中是否存在键key
boolean containsValue(Object value);//判断HashMap中是否存在值value
V get(Object key);//返回键key对应的值
V put(K key,V value);//添加键值对key，value
V remove(Object key);//删除键为key的元素并返回值
void putAll(Map<? extends K,?extends V> map);//将map中的所有元素添加到HashMap中
int size();//返回元素数量
boolean isEmpty();//判空

5.2、HashTable

HashTable也是一个哈希表，也存储着键值对的映射。其键和值都不允许是空值。值得注意的是HashTable中的方法都是同步的，因此它是线程安全的。

HashTable的创建：

Map<String,String> map = new HashTable();
Map<String,String> map = new HashTable(capacity);//capacity是一个int参数，用于指定容量大小
Map<String,String> map = new HashTable(capacity,loadFactor);//capacity是一个int参数，指定HashMap容量大小，loadFactor是一个float参数，表示加载因子
Map<String,String> map = new HashTable(map);//通过一个已有的map创建HashTable

HashMap常用方法：

void clear();//清空元素
Object clone();//返回一个浅复制实例
boolean containsKey(Object key);//判断HashMap中是否存在键key
boolean containsValue(Object value);//判断HashMap中是否存在值value
V get(Object key);//返回键key对应的值
V put(K key,V value);//添加键值对key，value
V remove(Object key);//删除键为key的元素并返回值
void putAll(Map<? extends K,?extends V> map);//将map中的所有元素添加到HashMap中
int size();//返回元素数量
boolean isEmpty();//判空

5.3、HashMap与HashTable的区别

HashMap继承自AbstractMap，而HashTable继承自Dictionary；HashMap线程不安全而HashTable是线程安全的；在单线程的情况下，HashMap效率高于HashTable；HashMap允许存放空键与空值，而HashTable则不允许出现

三、迭代器

Java集合框架中有那么多的集合，每个集合都有自己的特点，适用于不同的场景，因此每个集合的遍历方法似乎变得很麻烦，例如TreeSet中的元素该以什么样的方式遍历。因此Java引入了迭代器的概念。迭代器Iterator是一个对象，其主要功能就是对集合进行遍历，它提供了一种访问容器对象中各个元素且又不破坏封装性的方法。有一点要注意的是，迭代器是只读的，这意味着使用迭代器不能修改元素的内容。迭代器使用next来读取元素内容。（Map集合没有迭代器，不可以使用迭代器遍历）

迭代器实例

public class CollectionTest {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        TreeSet<Float> set = new TreeSet<>();
        list.add("a");
        list.add("b");
        list.add("c");
        set.add(123.5f);
        set.add(90.0f);
        set.add(12.4f);
        set.add(1.0f);
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

运行结果：

a
b
c
1.0
12.4
90.0
123.5

一只小林同学

关注

0
点赞
踩
1

收藏

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

Java集合一、集合概念 C++的STL给我们提供了vector、list、stack等方便好用的容器，在java中也同样拥有一些类似的容器模板，这个模板被叫做集合。集合将一些基本的和使用频率极高的基础类进行封装增强后再以一个类或接口的形式提供。集合中存放着一系列对象，并且长度是可变的。不同的集合由不同的供和特点，适用于不同的场合。集合类的框架从图中可以看出，java集合主要分为两大块，Collection集合和Map映射，其中Collection下
复制链接

扫一扫