1.常用集合的分类: Collection 接口的接口 对象的集合(单列集合) ├——-List 接口:元素按进入先后有序保存,可重复 │—————-├ LinkedList 接口实现类, 链表, 插入删除, 没有同步, 线程不安全 │—————-├ ArrayList 接口实现类, 数组, 随机访问, 没有同步, 线程不安全 │—————-└ Vector 接口实现类 数组, 同步, 线程安全 │ ———————-└ Stack 是Vector类的实现类 └——-Set 接口: 仅接收一次,不可重复,并做内部排序 ├—————-└HashSet 使用hash表(数组)存储元素 │————————└ LinkedHashSet 链表维护元素的插入次序 └ —————-TreeSet 底层实现为二叉树,元素排好序 Map 接口 键值对的集合 (双列集合) ├———Hashtable 接口实现类, 同步, 线程安全 ├———HashMap 接口实现类 ,没有同步, 线程不安全- │—————–├ LinkedHashMap 双向链表和哈希表实现 │—————–└ WeakHashMap ├ ——–TreeMap 红黑树对所有的key进行排序 └———IdentifyHashMap 集合和数组的区别: List接口下面有很多的集合,他们存储元素的时候,使用的结构方式是不同的,这样导致 每一个集合有着不同的特点 数据存储的常用的结构有:堆栈,队列,数组,链表。 堆栈:采用这个结构的集合,对元素的存取的特点是: 先进后出(即,先存进去的元素,要在它后面的元素依次被取出来之后,才会被取出) 比如:子弹压进弹夹,先放进去的子弹,在最下面,等开枪的时候,最后一粒被压进去的子弹第一个打出 特点: 栈的入口和出口都在顶端位置 压栈: 就是存储元素,即把元素存储到站顶端的位置,栈中已有的元素依次向栈底的方向移动一个位置 弹栈: 就是取元素,即,把栈顶的元素取出来,栈中已有的元素依次向上移动一个位置
/**
* 使用LinkedList进行栈的模拟(栈的特点,先进后出)
*/
public class MyStack {
//存储元素的集合,底层使用双向链表进行实现
LinkedList<String> list = new LinkedList<String>();
//模拟进栈
public void push(String e){
list.addFirst(e);//将新的元素添加到栈顶
}
//模拟出栈
public String pop(){
return list.removeFirst();//删除栈顶元素
}
public static void main(String[] args) {
MyStack ms = new MyStack();
ms.push("张三");//张三进栈
ms.push("李四");//李四进栈
ms.push("王五");//王五进栈
//出栈
while (ms.list.size() != 0){
System.out.println(ms.pop());
}
}
}
队列,采用这个结构的集合 先进先出(即,先存进去的元素,会先被取出来) 安检的时候,只有前面的人都被检查完了,当前位置的人才能检查 队列的入口和出口在不同的位置
/**
* 进行队列的模拟
*/
public class MyQueue {
private LinkedList<String> list = new LinkedList<String>();
//进队列,队尾进行插入操作
public boolean offer(String element){
return list.offer(element);
}
//出队列,对头进行删除操作
public String poll(){
return list.poll();
}
public static void main(String[] args) {
MyQueue myQueue = new MyQueue();
myQueue.offer("a");
myQueue.offer("b");
myQueue.offer("c");
while (myQueue.list.size() != 0){
System.out.println(myQueue.poll() + "出队列");
}
}
}
数组: 特点: 查找元素的时候比较快:是通过索引进行快速访问指定位置的元素 增删比较慢: 指定索引位置增加元素,需要创建一个新的数组,将指定的新元素存储在指定索引位置, 再把原来数组元素根据索引赋值到新数组对应的索引位置 删除指定索引位置的元素,需要先创建一个新的数组,把原来的数组根据索引赋值到新数组 对应的索引的位置,原数组中指定索引位置的元素,不进行新的赋值
public class Demo_01 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList(100);
arrayList.add("1");
arrayList.add(3.33);
System.out.println(arrayList.size());
ArrayList a = new ArrayList();
a.add(1);
a.add(2);
a.add(3);
a.add(4);
a.add(1);
a.add(2);
a.add(3);
ArrayList b = new ArrayList(a);
b.add(9);
System.out.println(b.size());
}
}
链表: 多个节点之间,通过地址进行连接. 举例:多个人手拉手,每个人使用自己的右手拉住下一个人的左手,以此类推将元素连接在一起 特点: 查找元素比较慢 想要查找某一个元素,需要通过连接的节点,依次向后查找指定的元素 增删元素比较快 增删元素只需要修改下一个元素的地址就可以了
/**
* HashSet是保证元素的唯一性,可以将元素放入到集合中但是没有顺序,我们现在如果想要
* 元素有顺序
* LinkedHashSet:可以帮我们完成set集合有序的操作
* 底层:链表 + hash
*/
public class LinkedHashSetDemo {
public static void main(String[] args) {
//原始元素:{11,22,33,11,16,11,19,51,44,11,66,77}
//得到元素:{11,22,33,16,19,51,44,66,7}
//要求去掉重复之后保留原来的顺序
//首先将信息给到List集合中
List<Integer> hashSet = new ArrayList<Integer>();
hashSet.add(11);hashSet.add(22);
hashSet.add(33);hashSet.add(11);
hashSet.add(16);hashSet.add(11);
hashSet.add(19);hashSet.add(51);
hashSet.add(44);hashSet.add(11);
hashSet.add(66);hashSet.add(77);
System.out.println(hashSet);
//将List集合中的元素放入到LinkedHashSet中
LinkedHashSet<Integer> set = new LinkedHashSet<Integer>(hashSet);
System.out.println(set);
LinkedHashSet<Integer> set1 = new LinkedHashSet<Integer>();
set1.add(111);
set1.add(121);
set1.add(122);
set1.add(131);
set1.add(101);
set1.add(1);
set1.add(11);
System.out.println(set1);
}
}
Collection(单列集合 单身) 一个元素 Map(双列集合 情侣) 元素是成对出现的,每个元素有键和值两部分组成 map存储元素的时候以键值对的形式 键 key 不可以重复 值 value 可以重复 查看API可以发现Map有很多实现类,学习中常见的实现类是: 1、HashMap<K,V> 2、Hashtable<K,V> 3、LinkedHashMap<K,V>:是HashMap的子类,在HashMap的基础上保存了元素的链式存储记录存储顺序 4、TreeMap<K,V>:需要对存储的数据进行自定义的排序 注意: Map有两个泛型<K,V> 在使用的时候需要为它们提供指定的数据类型 K,V数据类型可以一样,也可以不一样 get(Object key) 根据键来获取对应的值 put(K key,V value) 向map集合中存入值 remove(Object key) 根据键来删除键值对 replace(K key,V value) 使用新的值替换指定的key的值 size() map集合中的键值对数 boolean containsKey(Object key) 如果此映射包含指定键的映射,则返回 true 。 boolean containsValue(Object value) 如果此地图将一个或多个键映射到指定的值,则返回 true 。 boolean isEmpty() 如果此地图不包含键值映射,则返回 true。 遍历map集合中的数据 方式1: 先获取所有的key,在调用get根据key获取值 Set<K> keySet() 返回此地图中包含的键的Set视图。 方式2: 直接获取键值对: Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。 方式3: 不能获取key,只能获取所有的值的方法 Collection<V> values() 返回此地图中包含的值的Collection视图。
public class MapDemo {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1,"哈士奇");
map.put(2,"泰迪");
map.put(3,"藏獒");
map.put(4,"博美");
System.out.println(map);
//key重复,后面的key的值会覆盖掉前面的相同的key的值
map.put(2,"中华田园犬");
System.out.println(map);
//value可以重复
map.put(5,"藏獒");
System.out.println(map);
//获取指定的键对应的值
//如果键不存在,则输出null
String v1 = map.get(6);
System.out.println(v1);
//清除集合中的元素
//map.clear();
System.out.println(map);
//将5改成拉布拉多
map.replace(5,"拉布拉多");
System.out.println(map);
//获取集合中的所有的键值对
System.out.println(map.size());
//判断map集合中是否包含key为3的键值对
boolean f = map.containsKey(3);
System.out.println(f);
boolean b = map.containsValue("比熊");
System.out.println(b);
//如何遍历map集合
//方式1:
// 先获取所有的key,在调用get根据key获取值
// Set<K> keySet() 返回此地图中包含的键的Set视图。
System.out.println("---------第一种方式----------");
Set<Integer> set = map.keySet();
//对集合进行遍历
for(Integer key : set){
//根据键来找值
String value = map.get(key);
System.out.println(key + " ==== " + value);
}
//方式2:
// 直接获取键值对:
// Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。
System.out.println("---------第二种方式----------");
Set<Map.Entry<Integer,String>> set1 = map.entrySet();
for(Map.Entry<Integer,String> entry : set1){
System.out.println(entry);
Integer key = entry.getKey();
String value = entry.getValue();
}
//方式3:
// 不能获取key,只能获取所有的值的方法
// Collection<V> values() 返回此地图中包含的值的Collection视图。
System.out.println("---------第三种方式----------");
Collection<String> value = map.values();
System.out.println(value);
}
}
Hashtable HashMap、Hashtable 相同点: 实现的原理相同,功能相同,底层都是哈希表的结构 同样每个元素都是key - value,其内部也是通过链 表解决冲突问题,当容量不足的时候,会自动进行增加 不同点: 1、jdk1.0版本开始的时候 Hashtable 基本已经废弃使用了 jdk1.2HashMap出现 常用HashMap 2、Hashtable 继承 Dictionary类 是一个抽象类,已经过时了 HashMap 实现了Map接口 3、Hashtable 线程安全 HashMap 线程不安全,用在单线程的情况下 4、Hashtable 不允许有null键和null值,如果有会抛出空指针异常 HashMap中可以存储null键和null值 5、Hashtable 比 HashMap多了一种遍历的方式
public class HashtableDemo {
public static void main(String[] args) {
Hashtable<String,String> table = new Hashtable<String, String>();
table.put("admin","123456");
//凡是出现了空键或者空值,就会出现空指针异常
//table.put("admin2",null);
//table.put(null,"123456");
System.out.println(table);
//Hashtable使用枚举遍历
Enumeration<String> e = table.elements();
while (e.hasMoreElements()){//判断是否有更多的元素
String key = e.nextElement();//取出这个元素
String value = table.get(key);
System.out.println(key + " ===== " + value);
}
}
}
/**经典题目 * 键盘输入一个字符串,统计该字符串中各个字符的个数 * 比如: * 输入:aaaabbbcc * 输出:a(4)b(3)c(2) */
public class Demo_01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("键盘输入:");
String input = scanner.nextLine();
//aaaabbbcc
//创建了一个集合用来存储字符和出现的次数
HashMap<Character,Integer> map = new HashMap<Character, Integer>();
for(int i = 0; i < input.length();i++){
char key = input.charAt(i);
//根据ket找到这个字符原来的个数
//调用get方法如果key不存在就返回为null
//如果key存在就获取到key所对应的value值
int oldCount = map.getOrDefault(key,0);
//如果有这样一个元素,我就将集合中的固定的key后面对应的值加1
map.put(key,oldCount+1);
System.out.println(map);
}
//获取到map集合中所有的键集
Set<Character> set = map.keySet();
//遍历集合中的键然后根据键去找值
for(Character c : set){
System.out.println(c + "(" + map.get(c) + ")");
}
}
}
总结:
List小结:
(1)ArrayList:底层数据结构是数组,查询快,增删慢,线程不安全,效率高,可以存储重复元素
(2)LinkedList 底层数据结构是链表,查询慢,增删快,线程不安全,效率高,可以存储重复元素
(3)Vector:底层数据结构是数组,查询快,增删慢,线程安全,效率低,可以存储重复元素
List和Set总结:
(1)、List,Set都是继承自Collection接口,Map则不是
(2)、List特点:元素有放入顺序,元素可重复 ,Set特点:元素无放入顺序,元素不可重复,重复元素会覆盖掉,(注意:元素虽然无放入顺序,但是元素在set中的位置是有该元素的HashCode决定的,其位置其实是固定的,加入Set 的Object必须定义equals()方法 ,另外list支持for循环,也就是通过下标来遍历,也可以用迭代器,但是set只能用迭代,因为他无序,无法用下标来取得想要的值。)
(3).Set和List对比:
Set:检索元素效率低下,删除和插入效率高,插入和删除不会引起元素位置改变。
List:和数组类似,List可以动态增长,查找元素效率高,插入删除元素效率低,因为会引起其他元素位置改变。
(4)、ArrayList与LinkedList的区别和适用场景
Arraylist:
优点:ArrayList是实现了基于动态数组的数据结构,因为地址连续,一旦数据存储好了,查询操作效率会比较高(在内存里是连着放的)。
缺点:因为地址连续, ArrayList要移动数据,所以插入和删除操作效率比较低。
LinkedList:
优点:LinkedList基于链表的数据结构,地址是任意的,所以在开辟内存空间的时候不需要等一个连续的地址,对于新增和删除操作add和remove,LinedList比较占优势。LinkedList 适用于要头尾操作或插入指定位置的场景
缺点:因为LinkedList要移动指针,所以查询操作性能比较低。
适用场景分析:
当需要对数据进行对此访问的情况下选用ArrayList,当需要对数据进行多次增加删除修改时采用LinkedList。
Map小结:
HashMap 非线程安全
HashMap:基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()],为了优化HashMap空间的使用,您可以调优初始容量和负载因子。
TreeMap:非线程安全基于红黑树实现。TreeMap没有调优选项,因为该树总处于平衡状态。
适用场景分析:
HashMap和HashTable:HashMap去掉了HashTable的contains方法,但是加上了containsValue()和containsKey()方法。HashTable同步的,而HashMap是非同步的,效率上比HashTable要高。HashMap允许空键值,而HashTable不允许。
HashMap:适用于Map中插入、删除和定位元素。
Treemap:适用于按自然顺序或自定义顺序遍历键(key)。
5.线程安全集合类与非线程安全集合类
LinkedList、ArrayList、HashSet是非线程安全的,Vector是线程安全的;
HashMap是非线程安全的,HashTable是线程安全的;
StringBuilder是非线程安全的,StringBuffer是线程安全的。
数据结构
ArrayXxx:底层数据结构是数组,查询快,增删慢
LinkedXxx:底层数据结构是链表,查询慢,增删快
HashXxx:底层数据结构是哈希表。依赖两个方法:hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序:自然排序和比较器排序