文章目录
- 一、集合概述
- 二、Iterable
- 三、Collection
- 四、List接口及其子类
- 1.ArrayList类
- 2.Vector类
- 3.LinkedList类
- 五、Set接口及其子类
- 1.HashSet类
- 1.1LinkedHashSet类
- 2.TreeSet类
- 六、Java中单列集合的粗略关系图
一、集合概述
- 为什么出现集合
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。 - 集合的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。 - 集合的分类
java中集合分为单列集合和键值对集合。在两个顶级接口下又衍生出多中不同实现、不同数据结构的集合类。
二、Iterable
Iterable为单列集合封装了一系列迭代方法，为集合的遍历提供了底层依赖。下面列出方法列表
方法 | 作用 |
Iterator iterator(); | 返回迭代器对象 |
default void forEach(Consumer<? super T> action) | 遍历collection类的集合（1.8新增） |
default Spliterator spliterator() | 返回并行迭代器对象（1.8新增） |
三、Collection
单列集合的根接口。继承Iterable接口。方法列表
方法 | 作用 |
int size(); | 返回集合中元素的个数 |
boolean isEmpty(); | 判断集合是否为空 |
boolean contains(Object o); | 判断集合是否包含某个元素 |
Iterator iterator(); | 返回迭代器对象 |
T[] toArray(T[] a); | 将集合转为对象数组 |
boolean add(E e); | 添加元素（成功返回true） |
boolean remove(Object o); | 移除元素（成功返回true） |
boolean containsAll(Collection<?> c); | 是否包含给定集合中的所有元素 |
boolean addAll(Collection<? extends E> c); | 将给定集合中的元素添加到本集合 |
boolean removeAll(Collection<?> c); | 将给定集合从本集合中移除 |
boolean retainAll(Collection<?> c); | 本集合对给定集合做交集运算，结果保存在本集合（发生改变返回true） |
void clear() | 清空集合中的元素 |
default boolean removeIf(Predicate<? super E> filter) | 移除集合中符合条件的元素（1.8新增） |
default Stream stream() | 返回stream串行流（1.8新增） |
default Stream parallelStream() | 返回stream并行流（1.8新增） |
部分方法演示：
@Test
public void test1() {
Collection<String> collection1 = new ArrayList<>();
//添加元素
collection1.add("Hello ");
collection1.add("Collection!");
//集合长度
int size = collection1.size();
System.out.println("collection.size:"+size);
Collection<String> collection2 = new ArrayList<>();
collection2.add("I ");
collection2.add("Love ");
collection2.add("You!");
//contains方法
System.out.println("是否包含'Love '元素："+collection2.contains("Love "));
//addAll方法
collection1.addAll(collection2);
//remove方法
collection1.remove("Love ");
System.out.println("移除'Love '后："+collection1);
//removeIf方法，移除以感叹号结束的元素
collection1.removeIf(s -> s.endsWith("!"));
System.out.println("----遍历----");
//获取Stream流并遍历
collection1.stream().forEach(System.out::println);
}运行结果：
collection.size:2
是否包含'Love '元素：true
移除'Love '后：[Hello , Collection!, I , You!]
----遍历----
Hello
I四、List接口及其子类
List接口，继承Collection。有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
主要特点：元素有放入顺序，可重复。
特有方法列表：
方法 | 作用 |
boolean addAll(int index, Collection<? extends E> c) | 将给定集合插入到指定索引处 |
E get(int index) | 获取给定索引处的元素 |
E set(int index, E element) | 将元素设置到指定索引处 |
void add(int index, E element); | 将元素添加到指定索引处 |
E remove(int index); | 移除指定索引处的元素 |
int indexOf(Object o); | 返回给定元素在集合中的第一个索引值 |
int lastIndexOf(Object o); | 返回给定元素在集合中的最后一个索引值 |
ListIterator listIterator() | 返回ListIterator迭代器对象 |
ListIterator listIterator(int index); | 返回以index为迭代起始位置的迭代器对象 |
List subList(int fromIndex, int toIndex); | 截取从fromIndex（包含）到toIndex（不包含）的子集合 |
default void replaceAll(UnaryOperator operator) | 将集合中的每个元素按照给定规则替换（1.8新增） |
default void sort(Comparator<? super E> c) | 按照给定规则将元素排序（1.8新增） |
部分方法演示：
@Test
public void test2() {
//用Arrays工具类创建集合
List<Integer> list = new ArrayList<>();
list.add(0);
list.add(11);
list.add(222);
list.add(3333);
list.add(44444);
list.add(44444);
//在指定索引处添加元素;
list.add(3, 0);
//获取指定索引处的元素
System.out.println("3 索引处的元素：" + list.get(3));
System.out.println(list);
//移除指定索引处的元素
System.out.println("移除 4 索引处的元素：" + list.remove(5));
System.out.println(list);
//返回给定元素在集合中的最后一个索引值
System.out.println("0 在集合中的最后一个索引值"+list.lastIndexOf(0));
//replaceAll方法
list.replaceAll(i -> ++i);
System.out.println(list);
}运行结果
3 索引处的元素：0
[0, 11, 222, 0, 3333, 44444, 44444]
移除 4 索引处的元素：44444
[0, 11, 222, 0, 3333, 44444]
0 在集合中的最后一个索引值3
[1, 12, 223, 1, 3334, 44445]1.ArrayList类
主要特点：底层数据结构是数组； 查询快，增删慢 ； 线程不安全，效率高
特有方法列表：
方法 | 作用 |
public void trimToSize() | 将ArrayList容量修改为当前大小（节约内存） |
public void ensureCapacity(int minCapacity) | 预定ArrayList容量大小（当添加大量元素时效率高） |
2.Vector类
主要特点：底层数据结构是数组； 查询快，增删慢 ； 线程安全，效率低
特有方法列表：
方法 | 作用 |
public synchronized void copyInto(Object[] anArray) | 将元素复制到给定数组中 |
public synchronized void trimToSize() | 将Vector容量修改为当前大小（节约内存） |
public synchronized void ensureCapacity(int minCapacity) | 预定Vector容量大小（当添加大量元素时效率高） |
public synchronized void setSize(int newSize) | 设置Vector的长度（元素个数） |
public synchronized int capacity() | 返回Vector的当前容量大小 |
public synchronized int indexOf(Object o, int index) | 返回从index开始元素o（可为空）的第一个索引值 |
public synchronized int lastIndexOf(Object o, int index) | 返回从index开始元素o（可为空）的最后一个索引值 |
public synchronized E elementAt(int index) | 返回index索引处的元素 |
public synchronized E firstElement() | 返回 0 索引处的（第一个）元素 |
public synchronized E lastElement() | 返回最后一个元素 |
public synchronized void setElementAt(E obj, int index) | 在指定索引处设置给定元素 （集合长度不变） |
public synchronized void removeElementAt(int index) | 将指定索引处的元素移除 |
public synchronized void insertElementAt(E obj, int index) | 在指定索引处添加元素（集合长度+1） |
public synchronized void addElement(E obj) | 添加元素 |
public synchronized boolean removeElement(Object obj) | 移除元素 |
public synchronized void removeAllElements() | 移除所有元素（集合长度变为0） |
public Enumeration elements() | 返回Enumeration对象（常用于遍历） |
部分方法演示：
@Test
public void test3() {
Vector<String> vector = new Vector<>();
vector.add("王");
vector.add("富");
vector.add("贵");
vector.add("王富贵");
vector.add("王富贵");
//设置指定索引处的元素（ 参数index<vector.size()，否则越界 ）
vector.set(3,"富贵");
System.out.println(vector);
//在指定索引处添加元素（ 参数index<=vector.size()，否则越界 ）
vector.add(0,"哈哈");
System.out.println(vector);
System.out.println("第一个元素为："+vector.firstElement());
System.out.println("最后一个元素为："+vector.lastElement());
}运行结果：
[王, 富, 贵, 富贵, 王富贵]
[哈哈, 王, 富, 贵, 富贵, 王富贵]
第一个元素为：哈哈
最后一个元素为：王富贵3.LinkedList类
主要特点：底层数据结构是链表 ; 查询慢，增删快; 线程不安全，效率高;
特有方法列表：
方法 | 作用 |
public E getFirst() | 获取第一个元素 |
public E getLast() | 获取最后一个元素 |
public E removeFirst() | 移除第一个元素 |
public E removeLast() | 移除最后一个元素 |
部分方法演示：
@Test
public void test4() {
LinkedList<Character> list = new LinkedList<>();
list.add('A');
list.add('A');
list.add('B');
list.add('C');
System.out.println(list);
System.out.println("第一个元素：" + list.getFirst());
System.out.println("最后一个元素：" + list.getLast());
System.out.println("移除第一个元素：" + list.removeFirst());
System.out.println(list);
System.out.println("移除最后一个元素：" + list.removeLast());
System.out.println(list);
}运行结果：
[A, A, B, C]
第一个元素：A
最后一个元素：C
移除第一个元素：A
[A, B, C]
移除最后一个元素：C
[A, B]五、Set接口及其子类
Set接口，继承自Collection接口。该类集合特点元素不可重复，无放入顺序（注意：元素虽然无放入顺序，但是元素在 set 中的位置是有该元素的 HashCode 决定的，其位置其实是固定的）
主要特点：元素不可重复，无放入顺序
1.HashSet类
主要特点：底层数据结构是哈希表； 不保证 set 的迭代顺序； 线程不安全
代码演示：
@Test
public void test5() {
HashSet<String> set = new HashSet<>();
set.add("窝窝头");
set.add("一块钱");
set.add("四个");
set.add("嘿嘿");
//元素顺序与添加顺序不同，但其顺序由HashCode决定，又相对固定
for (int i = 0; i < 5; i++) {
System.out.println("打印："+set);
}
//添加元素
set.add("哈哈");
//元素顺序发生改变，故其不保证迭代顺序
System.out.println("添加元素后："+set);
System.out.println("添加重复元素："+set.add("窝窝头"));
System.out.println(set);
}运行结果
打印：[一块钱, 四个, 嘿嘿, 窝窝头]
打印：[一块钱, 四个, 嘿嘿, 窝窝头]
打印：[一块钱, 四个, 嘿嘿, 窝窝头]
打印：[一块钱, 四个, 嘿嘿, 窝窝头]
打印：[一块钱, 四个, 嘿嘿, 窝窝头]
添加元素后：[一块钱, 四个, 嘿嘿, 哈哈, 窝窝头]
添加重复元素：false
[一块钱, 四个, 嘿嘿, 哈哈, 窝窝头]1.1LinkedHashSet类
LinkedHashSet实现Set接口，继承自HashSet。由链表保证了元素有序，由哈希表保证了元素唯一。
主要特点：元素有序、唯一 ；线程不安全；
代码演示：
@Test
public void test6() {
LinkedHashSet<Character> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add('B');
linkedHashSet.add('A');
linkedHashSet.add('N');
linkedHashSet.add('G');
linkedHashSet.add('S');
linkedHashSet.add('E');
linkedHashSet.add('R');
linkedHashSet.add('R');//重复元素
System.out.println(linkedHashSet);
}运行结果
[B, A, N, G, S, E, R]2.TreeSet类
TreeSet 使用元素的自然顺序对元素进行排序 或者根据创建 set 时提供的 Comparator 进行排序， 具体取决于使用的构造方法。
主要特点： 底层数据结构是红黑树，元素有序且唯一；线程不安全；
代码演示:
@Test
public void test7() {
//无参构造，自然排序规则
TreeSet<Integer> integers = new TreeSet<>();
integers.add(1);
integers.add(8);
integers.add(6);
integers.add(3);
integers.add(15);
System.out.println(integers);
//带参(比较器)构造
/*
TreeSet<String> strings = new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return Integer.compare(s1.length(),s2.length());
}
});*/
//1.8后使用Lambda表达式
TreeSet<String> strings = new TreeSet<>(Comparator.comparingInt(String::length));
strings.add("天王盖地虎宝塔镇河妖");
strings.add("谁tm买小米啊");
strings.add("菠菜贱卖");
System.out.println(strings);
}运行结果
[1, 3, 6, 8, 15]
[菠菜贱卖, 谁tm买小米啊, 天王盖地虎宝塔镇河妖]六、Java中单列集合的粗略关系图
