集合
概述:用来存储引用类型,集合的长度可变
面试题:集合与数组的区别?
- 长度区别:数组一旦创建,长度不可变;集合可支持容度的改变
- 类型区别:集合只能存储引用类型(其他类型自动装箱),数组既可以存储引用类型,又可以存储基本类型
- 元素区别:数组只能存储一种类型元素,即元素的类型唯一性,集合可以存储多种类型的元素,可以用泛型约束
一、collection接口
1. collection接口为集合类的父接口,单列集合,提供许多功能,其长度可变,可以存储多种类型元素。子接口:List,Set
2.集合框架
3. collection接口常用方法
package cn.tedu.day13;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**
* 方法摘要
* boolean add(E e)
* 确保此 collection 包含指定的元素(可选操作)。
* boolean addAll(Collection<? extends E> c)
* 将指定 collection 中的所有元素都添加到此 collection 中(可选操作)。
* void clear()
* 移除此 collection 中的所有元素(可选操作)。
* boolean contains(Object o)
* 如果此 collection 包含指定的元素,则返回 true。
* boolean containsAll(Collection<?> c)
* 如果此 collection 包含指定 collection 中的所有元素,则返回 true。
* boolean equals(Object o)
* 比较此 collection 与指定对象是否相等。
* int hashCode()
* 返回此 collection 的哈希码值。
* boolean isEmpty()
* 如果此 collection 不包含元素,则返回 true。
* Iterator<E> iterator()
* 返回在此 collection 的元素上进行迭代的迭代器。
* boolean remove(Object o)
* 从此 collection 中移除指定元素的单个实例,如果存在的话(可选操作)。
* boolean removeAll(Collection<?> c)
* 移除此 collection 中那些也包含在指定 collection 中的所有元素(可选操作)。
* boolean retainAll(Collection<?> c)
* 仅保留此 collection 中那些也包含在指定 collection 的元素(可选操作)。
* int size()
* 返回此 collection 中的元素数。
* Object[] toArray()
* 返回包含此 collection 中所有元素的数组。
*/
public class MyCollection {
public static void main(String[] args) {
Collection<String> list = new ArrayList<String>();
list.add("傻逼");
list.add("憨逼");
list.add("二逼");
Collection c = new ArrayList();
c.add("古力娜扎");
c.add("迪丽热巴");
c.add("马儿扎哈");
//list.clear();清空集合
list.add("赵丽颖");
System.out.println(list);//打印集合
System.out.println(list.isEmpty());//是否为空
System.out.println(list.remove("赵丽颖"));//移除元素
System.out.println(list.contains("二逼"));//是否包含元素
System.out.println(list.hashCode());//获取哈希值
Object[] obj = c.toArray();//将集合变成数组
System.out.println(Arrays.toString(obj));
System.out.println("__________________");
System.out.println(c);
System.out.println(list);
System.out.println(c.addAll(list));//添加参数集合中所以元素
System.out.println(c.containsAll(list));//是否包含参数集合中的所有元素
System.out.println(c.retainAll(list));//保留交集元素
System.out.println(c.removeAll(list));//删除参数集合中的所有元素
System.out.println(c.size());//元素个数
System.out.println(c);
list.add("古力娜扎");
list.add("迪丽热巴");
list.add("马儿扎哈");
System.out.println(list);
}
}
运行结果
二、List接口
特点:
- 可以存储相同的元素,有序的集合
- 元素有序,可以根据索引访问元素
- 可以存储null值
- 常用方法测试
package cn.tedu.day13;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* list集合
* 特点:
* 1.有序,可以重复元素的集合
* 2.可以存储null值
* 3.可以根据索引获取元素
* 4.list接口也有迭代器
* 5.List接口提供了两种搜索指定对象的方法
*
* 常用方法
* boolean add(E e)
* 向列表的尾部添加指定的元素(可选操作)。
* void add(int index, E element)
* 在列表的指定位置插入指定元素(可选操作)。
* boolean addAll(Collection<? extends E> c)
* 添加指定 collection 中的所有元素到此列表的结尾,顺序是指定 collection 的迭代器返回这些元素的顺序(可选操作)。
* boolean addAll(int index, Collection<? extends E> c)
* 将指定 collection 中的所有元素都插入到列表中的指定位置(可选操作)。
* void clear()
* 从列表中移除所有元素(可选操作)。
* boolean contains(Object o)
* 如果列表包含指定的元素,则返回 true。
* boolean containsAll(Collection<?> c)
* 如果列表包含指定 collection 的所有元素,则返回 true。
* boolean equals(Object o)
* 比较指定的对象与列表是否相等。
* E get(int index)
* 返回列表中指定位置的元素。
* int hashCode()
* 返回列表的哈希码值。
* int indexOf(Object o)
* 返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。
* boolean isEmpty()
* 如果列表不包含元素,则返回 true。
* Iterator<E> iterator()
* 返回按适当顺序在列表的元素上进行迭代的迭代器。
* int lastIndexOf(Object o)
* 返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。
* ListIterator<E> listIterator()
* 返回此列表元素的列表迭代器(按适当顺序)。
* ListIterator<E> listIterator(int index)
* 返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置开始。
* E remove(int index)
* 移除列表中指定位置的元素(可选操作)。
* boolean remove(Object o)
* 从此列表中移除第一次出现的指定元素(如果存在)(可选操作)。
* boolean removeAll(Collection<?> c)
* 从列表中移除指定 collection 中包含的其所有元素(可选操作)。
* boolean retainAll(Collection<?> c)
* 仅在列表中保留指定 collection 中所包含的元素(可选操作)。
* E set(int index, E element)
* 用指定元素替换列表中指定位置的元素(可选操作)。
* int size()
* 返回列表中的元素数。
* List<E> subList(int fromIndex, int toIndex)
* 返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图。
* Object[] toArray()
* 返回按适当顺序包含列表中的所有元素的数组(从第一个元素到最后一个元素)。
*
* 面试题:iterdtor()与listIterator()的区别?
* 1.iterator()来自父接口collection,ListIterator()来自List接口
* 2.iterator()返回父接口,ListIterator()返回子接口
* 3.listIterator()既有父接口的功能,又有自己扩展功能,如逆向遍历
*/
public class Mylist {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马儿扎哈");
list.add("迪丽热巴");
list.add(null);
System.out.println(list);
list.add(1,"韩梅梅");//在索引处添加元素,后面元素往后移
System.out.println(list);
System.out.println(list.get(2));//获取索引处元素
System.out.println(list.indexOf("迪丽热巴"));//获取元素第一次出现的下标
System.out.println(list.lastIndexOf("迪丽热巴"));//获取元素最后一次出现的下标
list.remove(4);//删除索引处的元素
list.set(3,"angelababa");//替换索引处的元素
System.out.println(list);
List<String> list2 = list.subList(2,4);//集合的截取,包含左不包含右
System.out.println(list2);
//List的元素遍历
System.out.println("1.迭代器iterator()遍历");
Iterator<String> it = list.iterator();
while (it.hasNext()){
String data = it.next();
System.out.print(data+" ");
}
System.out.println();
System.out.println("2.下标遍历");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i)+" ");
}
System.out.println();
System.out.println("3.foreach遍历");
for (String data : list){
System.out.print(data+" ");
}
System.out.println();
System.out.println("4.ListIterator()遍历");
ListIterator<String> it2 = list.listIterator();
while (it2.hasNext()){
String str = it2.next();
System.out.print(str+" ");
}
System.out.println();
System.out.println("5.ListIterator()逆向遍历");
while (it2.hasPrevious()) {
String data = it2.previous();
System.out.print(data+" ");
}
}
}
运行结果
子类ArrayList和LinkedList,Vector
-
Arraylist:底层存储的数据结构为数组,每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素,其容量也自动增长。并未指定增长策略的细节,因为这不只是添加元素会带来分摊固定时间开销那样简单。
-
LinkedList:List 接口的链接列表实现。实现所有可选的列表操作,并且允许所有元素(包括 null)。除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。此类实现 Deque 接口,为 add、poll 提供先进先出队列操作,以及其他堆栈和双端队列操作。
-
Vector:Vector 类可以实现可增长的对象数组。与数组一样,它包含可以使用整数索引进行访问的组件。但是,Vector 的大小可以根据需要增大或缩小,以适应创建 Vector 后进行添加或移除项的操作。
测试-LinkedList
package cn.tedu.day14;
import java.util.LinkedList;
public class MyLinkedList {
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.addFirst(0);
list.addLast(5);
System.out.println(list);
System.out.println(list.getFirst());
System.out.println(list.getLast());
System.out.println(list.removeFirst());
System.out.println(list.removeLast());
System.out.println(list);
list.set(1,9);
System.out.println(list.get(1));
}
}
运行结果
三、set接口
1. 特点:不能存储相同的元素,元素无序,底层存储的数据结构为哈希表(数组+链表)
2. set接口不能存储相同元素的原理:重写hashCode()和equals()方法
- boolean add(E e) 如果 set 中尚未存在指定的元素,则添加此元素(可选操作)。更确切地讲,如果此 set 没有包含满足 (enull ? e2null : e.equals(e2)) 的元素 e2,则向该 set 中添加指定的元素 e。如果此 set 已经包含该元素,则该调用不改变此 set 并返回 false。结合构造方法上的限制,这就可以确保 set 永远不包含重复的元素。
- HashSet底层存储原理为哈希表,创建HashSet对象时其实是在创建HashMap对象,添加元素时本质上在调用HashMap的put方法,添加的元素存储在映射里的key,map集合里的key不唯一,于是set就不包含相同的元素
3. 测试set接口常用方法
注:set接口没有什么扩展的方法,全部是继承自collection父类接口的方法,set接口的主要作用是去重元素
package cn.tedu.day14;
/**
* set集合:无可重复,无序,底层是哈希表/散列表(map)
*/
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Text_Set {
public static void main(String[] args) {
//本质上创建hashset,实际上创建hashmap
Set<Object> set = new HashSet<>();
//本质上,是将数据存入map里,即set.put(e,new Object),v是常量
set.add("来了老弟");
set.add("qew");
set.add(6.6);
set.add(null);
set.add(null);
System.out.println(set.isEmpty());
System.out.println(set.size());
//1.继承自collection接口的iterator()
Iterator it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
System.out.println(set.contains(6.6));
//2.for each
for (Object obj : set){
System.out.print(obj+" ");
}
}
}
4.子类HashSet,TreeSet,LinkedHashSet
- HashSet:此类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例)支持。它不保证 set 的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用 null 元素。 此类为基本操作提供了稳定性能,这些基本操作包括 add、remove、contains 和 size,假定哈希函数将这些元素正确地分布在桶中。对此 set 进行迭代所需的时间与 HashSet 实例的大小(元素的数量)和底层 HashMap 实例(桶的数量)的“容量”的和成比例。因此,如果迭代性能很重要,则不要将初始容量设置得太高(或将加载因子设置得太低)。
- TreeSet:基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的 Comparator 进行排序,具体取决于使用的构造方法。 此实现为基本操作(add、remove 和 contains)提供受保证的 log(n) 时间开销。
- LinkedHashSet;具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于,后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序,即按照将元素插入到 set 中的顺序(插入顺序)进行迭代。注意,插入顺序不 受在 set 中重新插入的 元素的影响。(如果在 s.contains(e) 返回 true 后立即调用 s.add(e),则元素 e 会被重新插入到 set s 中。)
四、Map接口
接口 Map<K,V>
类型参数:
K - 此映射所维护的键的类型
V - 映射值的类型
- 特点:不允许重复的key,value值可以重复,若添加已有的key值,会覆盖原先的key-value映射
key,value一 一对应,可以根据键提取对应的值
存放的都是无序数据
初始容量是16,默认的加载因子是0.75
测试–map接口
package cn.tedu.day14;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 方法摘要
* void clear()
* 从此映射中移除所有映射关系(可选操作)。
* boolean containsKey(Object key)
* 如果此映射包含指定键的映射关系,则返回 true。
* boolean containsValue(Object value)
* 如果此映射将一个或多个键映射到指定值,则返回 true。
* Set<Map.Entry<K,V>> entrySet()
* 返回此映射中包含的映射关系的 Set 视图。
* boolean equals(Object o)
* 比较指定的对象与此映射是否相等。
* V get(Object key)
* 返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null。
* int hashCode()
* 返回此映射的哈希码值。
* boolean isEmpty()
* 如果此映射未包含键-值映射关系,则返回 true。
* Set<K> keySet()
* 返回此映射中包含的键的 Set 视图。
* V put(K key, V value)
* 将指定的值与此映射中的指定键关联(可选操作)。
* void putAll(Map<? extends K,? extends V> m)
* 从指定映射中将所有映射关系复制到此映射中(可选操作)。
* V remove(Object key)
* 如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
* int size()
* 返回此映射中的键-值映射关系数。
* Collection<V> values()
* 返回此映射中包含的值的 Collection 视图。
*/
public class Text_HashMap {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<>();
System.out.println();
map.put(1,"娜娜莉");
map.put(2,"尤菲");
map.put(3,"夏利");
map.put(4,"卡莲");
map.put(5,"科内利亚");
map.put(null,null);//允许存入空值
map.put(5,"朱雀");//key唯一,如果存入相同的key,则会覆盖之前的value
System.out.println(map.containsKey(1));
System.out.println(map.containsValue("娜娜莉"));
System.out.println(map.get(1));
System.out.println(map.isEmpty());
System.out.println(map.remove(5));//删除key,返回value
System.out.println(map.size());
//返回key的set键集合
System.out.println("返回key的set键集合");
Set<Integer> set = map.keySet();
for (Integer key : set){
System.out.println(key);
}
//返回value值的collection集合
System.out.println("返回value值的collection集合");
Collection<String> value = map.values();
for (String values : value) {
System.out.println(values);
}
//返回key-value的set试图
System.out.println("返回key-value");
Set<Map.Entry<Integer,String>> out = map.entrySet();
for (Map.Entry<Integer,String> x : out) {
Integer key = x.getKey();
String values = x.getValue();
System.out.println(key+"="+values);
}
}
}
运行结果
五、集合总结
- List接口
- ArrayList:底层存储数据结构为数组,查询快,增删慢,线程不安全,不同步,效率高,可以存储重复元素,元素有索引,默认容量10
- LinkedList :底层存储数据结构为链表(双向链表),查询慢,增删快,线程不安全,不同步,可以存储重复元素,元素有索引,支持随机位置增删,但是在定位时需要线性扫描,效率低
- Vector:底层存储数据结构为数组,查询快,增删慢,线程安全,同步,效率低,可以存储重复元素,默认容量10
- Set接口
- HashSet:底层存储数据结构为哈希表(HashMap),元素无序且唯一,线程不安全,不同步,效率高,可以存储null元素,元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的
- LinkedHashSet :底层数据结构采用链表和哈希表共同实现,链表维护元素的插入次序,哈希表保证了元素的唯一性,线程不安全,效率高。
- TreeSet :底层实现为红黑树,元素唯一并且排好序,不允许重复元素,线程不安全,不同步
- Map接口
- HashMap :底层数据结构为哈希表(数组+链表结构),具有映射关系的集合,Map里保存着两组数据:key和value,没有同步, 线程不安全,运行存储null值,但是不能存储重复元素,会覆盖掉value值,性能好
- Hashtable :接口实现类, 线程同步,安全,性能差
- TreeMap :红黑树对所有的key进行排序 ,有自然排序和定制排序
集合的使用分析
HashMap和HashTable:HashMap去掉了HashTable的contains方法,但是加上了containsValue()和containsKey()方法。HashTable同步的,而HashMap是非同步的,效率上比HashTable要高。HashMap允许空键值,而HashTable不允许。
HashMap:适用于Map中插入、删除和定位元素。
Treemap:适用于按自然顺序或自定义顺序遍历键(key)。
线程安全集合类与非线程安全集合类
LinkedList、ArrayList、HashSet是非线程安全的,Vector是线程安全的;
HashMap是非线程安全的,HashTable是线程安全的;
StringBuilder是非线程安全的,StringBuffer是线程安全的。
数据结构
ArrayXxx:底层数据结构是数组,查询快,增删慢
LinkedXxx:底层数据结构是链表,查询慢,增删快
HashXxx:底层数据结构是哈希表。依赖两个方法:hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序:自然排序和比较器排序