By

Contents
  1. 1. 1.java中常用的集合类型
  2. 2. 2.集合接口
  3. 3. 3.集合实现类
  4. 4. 4.set 和list的区别
  5. 5. 5.Set的使用
  6. 6. 6.LinkedList和ArrayList的区别：
  7. 7. Vector
  8. 8. 7.java中循环删除list中元素的方法总结
  9. 9. 8.map的遍历方式
  10. 10. 9.collection 和collections的区别：
  11. 11. 10.HashMap和TreeMap的比较
  12. 12. 11.HashMap和HashTable的比较
  13. 13. 12.Vector的同步性

1.java中常用的集合类型

img

java 集合位于java.util 包中，所以当使用集合框架时需要进行import

2.集合接口

集合框架定义了一些接口。本节提供了每个接口的概述：

序号 接口描述
1 Collection 接口 Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。Collection 接口存储一组不唯一，无序的对象。
2 List 接口 List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。List 接口存储一组不唯一，有序（插入顺序）的对象。
3 Set Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。Set 接口存储一组唯一，无序的对象。
4 SortedSet 继承于Set保存有序的集合。
5 Map Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
6 Map.Entry 描述在一个Map中的一个元素（键/值对）。是一个Map的内部类。
7 SortedMap 继承于 Map，使 Key 保持在升序排列。
8 Enumeration 这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。

3.集合实现类

​ 标准集合类汇总于下表：

序号 类描述
1 AbstractCollection 实现了大部分的集合接口。
2 AbstractList 继承于AbstractCollection 并且实现了大部分List接口。
3 AbstractSequentialList 继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。
4 LinkedList 该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：Listlist=Collections.synchronizedList(newLinkedList(...));LinkedList 查找效率低。
5 ArrayList 该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。
6 AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。
7 HashSet 该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
8 LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9 TreeSet 该类实现了Set接口，可以实现排序等功能。
10 AbstractMap 实现了大部分的Map接口。
11 HashMap HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
12 TreeMap 继承了AbstractMap，并且使用一颗树。
13 WeakHashMap 继承AbstractMap类，使用弱密钥的哈希表。
14 LinkedHashMap 继承于HashMap，使用元素的自然顺序对元素进行排序.
15 IdentityHashMap 继承AbstractMap类，比较文档时使用引用相等。

在前面的教程中已经讨论通过java.util包中定义的类，如下所示：

序号 类描述
1 Vector 该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。
2 Stack 栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
3 Dictionary Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。
4 Hashtable Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。
5 Properties Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。
6 BitSet 一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

4.set 和list的区别

1.都是实现Collection 接口。

2.set 不允许元素重复，不允许元素为空；list可以重复元素。

  1. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

5.Set的使用

set的两大实现类 TreeSet和HashSet

TreeSet 会将里面的元素默认排序。

HashSet :允许包含值为null的元素，但最多只能有一个null元素，不允许出现重复的元素。

6.LinkedList和ArrayList的区别：

ArrayList内部是使用可増长数组实现的，所以是用get和set方法是花费常数时间的，但是如果插入元素和删除元素，除非插入和删除的位置都在表末尾，否则代码开销会很大，因为里面需要数组的移动。
LinkedList是使用双链表实现的，所以get会非常消耗资源，除非位置离头部很近。但是插入和删除元素花费常数时间。

Vector

  1. Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。

7.java中循环删除list中元素的方法总结

1.使用for循环删除

删除某个元素后，list的大小发生了变化，索引也在变化，会导致遍历的时候漏掉一些元素，比如当你删除第1个元素后，继续根据索引访问第2个元素时，因为删除的关系后面的元素都往前移动了一位，所以实际访问的是第3个元素。因此，这种方式可以用在删除特定的一个元素时使用，但不适合循环删除多个元素时使用。

2.增强for循环

1
2
3
4
5
6
for(String str:list2){
    if("abc2".equals(str)){
        list2.remove(str);//发生ConcurrentModificationException因为元素在使用的时候发生了并发的修改，导致异常抛出。但是删除完毕马上使用break跳出，则不会触发报错。
        break;//使用 跳出 则不会出发报错
    }
}

3.在list集合迭代元素中，对元素进行判断，一旦条件满足就添加一个新元素。代码如下

public class IteratorDemo {

//在list集合迭代元素中，对元素进行判断，一旦条件满足就添加一个新元素

public static void main(String[] args) {

//创建List集合

List list = new ArrayList();

//给集合中添加元素

list.add(“abc1”);

list.add(“abc2”);

list.add(“abc3”);

list.add(“abc4”);

//迭代集合，当有元素为”abc2”时，集合加入新元素”itcast”

Iterator it = list.iterator();

while(it.hasNext()){

String str = it.next();

//判断取出的元素是否是”abc2”，是就添加一个新元素

if(“abc2”.equals(str)){

list.add(“itcast”);// 该操作会导致程序出错

}

}

//打印容器中的元素

System.out.println(list);

}

}

运行上述代码发生了错误 java.util.ConcurrentModificationException这是什么原因呢？

在迭代过程中，使用了集合的方法对元素进行操作。导致迭代器并不知道集合中的变化，容易引发数据的不确定性。

并发修改异常解决办法：在迭代时，不要使用集合的方法操作元素。

那么想要在迭代时对元素操作咋办？通过ListIterator迭代器操作元素是可以的，ListIterator的出现，解决了使用Iterator迭代过程中可能会发生的错误情况。

8.map的遍历方式

1.Map.Entry keySet的方式

2.key value 的方式遍历 map.keySet获取所有的key 在获取value

3.Iterator的方式遍历，map.entrySet().iterator()获取所有的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Map<String,String> map = new HashMap<>();
map.put("key1","1");
map.put("key2","2");
map.put("key3","3");
//Entry 遍历 在容量大的时候推荐使用
for(Map.Entry<String,String> entry:map.entrySet()){
    System.out.println(entry.getKey()+":"+entry.getValue());
}
//key value的方式遍历 通过Map.keySet 遍历所有的value和key   元素比较小的情况下推荐使用
for(String key:map.keySet()){
    String value = map.get(key);
    System.out.println(key+":"+value);
}
//Iterator 迭代器的方法 map.entrySet().iterator 方法遍历
Iterator<Map.Entry<String,String>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
    Map.Entry<String,String> entry = iterator.next();
    System.out.println(entry.getKey()+":"+entry.getValue());
}

9.collection 和collections的区别：

collection是java.util下的接口，它是各种集合的父接口，继承于它的接口主要包含Set和List.Collections是java.util下的类，针对集合的帮助类。提供一些 静态方法实现以及对各种集合的搜索，排序，线程安全化等操作。

10.HashMap和TreeMap的比较

HashMap通过hashcode对其内容进行快速查找，而 TreeMap中所有的元素都保持着某种固定的顺序。

HashMap：适用于在Map中插入、删除和定位元素。
Treemap：适用于按自然顺序或自定义顺序遍历键(key)。

HashMap通常比TreeMap快一点(树和哈希表的数据结构使然)，建议多使用HashMap，在需要排序的Map时候才用TreeMap。

11.HashMap和HashTable的比较

HashTable不允许有空值；

HashMap可允许有唯一的空值；

HashTable是线程安全的，HashMap非线程安全。

12.Vector的同步性

同步容器中的所有自带方法都是线程安全的，因为方法都使用synchronized关键字标注。但是，对这些集合类的复合操作无法保证其线程安全性。需要客户端通过主动加锁来保证。