Collection
集合中只能放置对象的引用，不能放置原生数据类型。
常用方法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
| // 将所有元素从一个列表复制到另一个列表
Collections.copy(new ArrayList(), new ArrayList());
// 如果两个指定collection中没有相同的元素,则返回 true
Collections.disjoint(new ArrayList(), new ArrayList());
// 使用指定元素替换指定列表中的所有元素
Collections.fill(new ArrayList(), new Object());
// 返回指定 collection 中等于指定对象的元素数
Collections.frequency(new ArrayList(), new Object());
// 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1
Collections.indexOfSubList(new ArrayList(), new ArrayList());
// 根据元素的自然顺序，返回给定 collection 的最大元素
Collections.max(new ArrayList());
// //根据元素的自然顺序，返回给定 collection 的最大元素
Collections.min(new ArrayList());
// 使用另一个值替换列表中出现的所有某一指定值
Collections.replaceAll(new ArrayList(), "oldVal", "newVal");
// 反转指定列表中元素的顺序
Collections.reverse(new ArrayList());
// 返回一个比较器,它强行反转
Collections.reverseOrder();
// 返回一个比较器,它强行反转指定比较器的顺序
Collections.reverseOrder(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return 0;
}
});
// 使用默认随机源随机更改指定列表的序列
Collections.shuffle(new ArrayList());
// 根据元素的自然顺序对指定列表按升序进行排序
Collections.sort(new ArrayList());
// 根据元素的自然顺序对指定列表按降序进行排序
Collections.sort(new ArrayList(), Collections.reverseOrder());
// 在指定列表的指定位置处交换元素
Collections.swap(new ArrayList(), 1, 2);
|
Set
实现类：HashSet,LinkedHashSet.
子接口：SortSet，TreeSet.
不包含重复元素，最多包含一个null，元素没有顺序。
HashSet
HashSet不是Ordered也不是Sorted,存储对象引用时是按照哈希策略来实现的,
HashSet中是否存在一个对象是通过equals()和hashCode()协同判断，不保证顺序。
构造方法
1
2
3
| public HashSet()
public HashSet(int initialCapacity)
public HashSet(Collection c)
|
1
| public HashSet(Collection c)
|
HashSet底层是使用HashMap实现的
HashSet的add()方法详解:
判断已经存储在集合中的对象hashCode值是否与增加对象的hashCode值一致。
如果不一致,直接加进去。
如果一致,再进行equals()比较，如果equals()返回true,对象已经存在不增加进去，如果equals()返回false,把对象增加进去。
LinkedHashSet
LinkedHashSet是Ordered,采用双链表实现的，有固定顺序,也就是插入顺序。
LinkedHashSet底层是使用LinkedHashMap实现的。
构造方法
1
2
3
| public LinkedHashSet()
public LinkedHashSet(int initialCapacity)
public LinkedHashSet(Collection c)
|
SortedSet
保证迭代器按照元素递增顺序遍历的集合,可以按照元素的自然顺序进行排序。
常用方法：
1
2
3
4
5
6
7
8
9
10
11
12
| Object first()
返回此有序集合中当前第一个(最小的)元素
Object last()
返回此有序集合中最后一个(最大的)元素
SortedSet headSet(Object toElement)
返回此有序集合的部分视图,其元素严格小于toElement
SortedSet tailSet(Object fromElement)
返回此有序集合的部分视图,其元素大于或等于fromElement
SortedSet subSet(Object fromElement,Object toElement)
返回此有序集合的部分视图,元素范围从fromElement(包括)到toElement(不包括)
Comparator comparator()
返回与此有序集合关联的比较器,如果使用元素的自然顺序,则返回 null
|
TreeSet
TreeSet是SortedSet接口的实现,元素不论以什么元素插入,在遍历的时候,都会以天然顺序遍历。因为它是自带排序的，所以如果想要增加自定义类型就必须指定排序的规则。
TreeSet底层是使用TreeMap实现的。
构造方法
1
2
3
4
5
| public TreeSet()
public TreeSet(SortedSet s)
public TreeSet(int initialCapacity)
public TreeSet(Comparator<? super E>)
public TreeSet(Collection c)
|
List
具有列表的功能,元素顺序均是按添加的先后进行排列的,允许重复的元素,允许多个null元素。
常用方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
| List list = new ArrayList();
// 向列表的尾部追加指定的元素
list.add("lwc");
// 在列表的指定位置插入指定元素
list.add(1, "nxj");
// 追加指定 collection 中的所有元素到此列表的结尾
list.addAll(new ArrayList());
// 从列表中移除所有元素
list.clear();
// 如果列表 大专栏 java基础-略知一二包含指定的元素,则返回true
list.contains("nxj");
// 如果列表包含指定 collection 的所有元素,则返回 true
list.containsAll(new ArrayList());
// 比较指定的对象与列表是否相等
list.equals(new ArrayList());
// 返回列表中指定位置的元素
list.get(0);
// 返回列表的哈希码值
list.hashCode();
// 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.indexOf("lwc");
// 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.lastIndexOf("lwc");
// 如果列表不包含元素,则返回 true
list.isEmpty();
// 移除列表中指定位置的元素
list.remove(0);
// 移除列表中出现的首个指定元素
list.remove("lwc");
// 从列表中移除指定 collection 中包含的所有元素
list.removeAll(new ArrayList());
// 用指定元素替换列表中指定位置的元素
list.set(0, "lp");
// 返回列表中的元素数
list.size();
// 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图
list.subList(1, 2);
// 返回以正确顺序包含列表中的所有元素的数组
list.toArray();
// 返回以正确顺序包含列表中所有元素的数组
list.toArray(new String[] { "a", "b" });
|
ArrayList
构造方法
1
2
3
| public ArrayList()
public ArrayList(int initialCapacity)
public ArrayList(Collection c)
|
ArrayList依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组。
当元素超过10,那么ArrayList底层会新生成一个数组,长度为原来的1.5倍+1,然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中,当新数组无法容纳增加的元素,重复该过程即可。
LinkedList
LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的,因此有很好的插入和删除性能,但随机访问元素的性能很差。
构造方法
1
2
| public LinkedList()
public LinkedList(Collection c)
|
LinkedList类中有一个Entry内部类,Entry内部类包含3个部分向前的引用,向后的引用,数据
1
| header.next = header.previous = header;
|
Map
Map接口中键和值一一映射. 可以通过键来获取值.
特性
- 给定一个键和一个值，你可以将该值存储在一个Map对象. 之后，你可以通过键来访问对应的值。
- 当访问的值不存在的时候，方法就会抛出一个NoSuchElementException异常。
- 当对象的类型和Map里元素类型不兼容的时候，就会抛出一个 ClassCastException异常。
- 当在不允许使用Null对象的Map中使用Null对象，会抛出一个NullPointerException 异常。
- 当尝试修改一个只读的Map时，会抛出一个UnsupportedOperationException异常。
方法
| 1 |
void clear( ) 从此映射中移除所有映射关系（可选操作）。 |
| 2 |
boolean containsKey(Object k) 如果此映射包含指定键的映射关系，则返回 true。 |
| 3 |
boolean containsValue(Object v) 如果此映射将一个或多个键映射到指定值，则返回 true。 |
| 4 |
Set entrySet( ) 返回此映射中包含的映射关系的 Set 视图。 |
| 5 |
boolean equals(Object obj) 比较指定的对象与此映射是否相等。 |
| 6 |
Object get(Object k) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 |
| 7 |
int hashCode( ) 返回此映射的哈希码值。 |
| 8 |
boolean isEmpty( ) 如果此映射未包含键-值映射关系，则返回 true。 |
| 9 |
Set keySet( ) 返回此映射中包含的键的 Set 视图。 |
| 10 |
Object put(Object k, Object v) 将指定的值与此映射中的指定键关联（可选操作）。 |
| 11 |
void putAll(Map m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。 |
| 12 |
Object remove(Object k) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 |
| 13 |
int size( ) 返回此映射中的键-值映射关系数。 |
| 14 |
Collection values( ) 返回此映射中包含的值的 Collection 视图。 |
HashMap
常用操作
1.第一步就是给HashMap里面put一些键值对。
1
2
3
4
5
6
7
8
9
10
11
12
| HashMap<Integer, Integer> hashMap = new HashMap<>();
hashMap.put(5, 2);
hashMap.put(9, 2);
hashMap.put(8, 1);
hashMap.put(7, 3);
hashMap.put(16, 1);
hashMap.put(10, 2);
hashMap.put(6, 2);
//下面两个键值对是没有存的，因为key存过的不会重复存储，只会覆盖之前的vlue
hashMap.put(5, 2);
hashMap.put(5, 3);
|
2.containsKey(Object key)方法，返回值为boolean，用于判断当前HashMap中是否包含key对应的key-value。
3.containsValue(Object value)方法，返回值为boolean，用于判断当前HashMap中是否包含value对应的key-value。
4.遍历HashMap的两种方式：
1）利用haspmap.entrySet().iterator()：利用迭代器，从Entry中取出键、取出值，推荐使用这种方式进行遍历，效率较高：
1
2
3
4
5
6
7
8
| Iterator<Entry<Integer, Integer>> iterator = hashMap.entrySet().iterator();
while (iterator.hasNext()) {
Entry<Integer, Integer> entry = iterator.next();
Integer key = entry.getKey();
Integer value = entry.getValue();
System.out.print(key + "--->" + value);
System.out.println();
}
|
2）利用hashmap.keySet().iterator()：利用键的迭代器，每次取出一个键，再根据键，从HashMap中取出值，这种方式的效率不高，不推荐使用：
1
2
3
4
5
6
7
| Iterator<Integer> iterator2 = hashMap.keySet().iterator();
while (iterator2.hasNext()) {
Integer key = iterator2.next();
Integer value = hashMap.get(key);
System.out.print(key + "---" + value);
System.out.println();
}
|
参考链接
Iterator
在Java中Iterator为一个接口，它只提供了迭代了基本规则，在JDK中他是这样定义的：对 collection 进行迭代的迭代器。迭代器取代了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同：
1
2
3
| 1、迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的 collection 移除元素。
2、方法名称得到了改进。
|
接口定义：
1
2
3
4
5
| public interface Iterator {
boolean hasNext();
Object next();
void remove();
}
|
Object next()：返回迭代器刚越过的元素的引用，返回值是Object，需要强制转换成自己需要的类型。
boolean hasNext()：判断容器内是否还有可供访问的元素。
void remove()：删除迭代器刚越过的元素。
未完待续~~~