集合

（集合存储的是引用类型，若需要基本数据类型则用其包装类类型）

(一)Collection

是单列集合的顶层接口，表示一组对象，这些对象称为Collection的元素

集合的遍历 Iterator

Iterator迭代器，集合的专用遍历方式（Iterator一个接口）

Iterator中的常用方法
next():返回迭代中的下一个元素
hasNext():如果迭代具有更多元素，则返回true

Collection<String> c = new ArrayList<String>();
c.add(“1”);
c.add(“2”);
c.add(“3”);

Iterator<String> it = c.iterator(); //迭代器
while(it.hasNext()){
  System.out.println(it.next());
}

(二)List

List集合的特点：
有序：存储和取出的元素顺序一致
可重复：存储的元素可以重复

遍历List集合的三种方法：
①迭代器 / 列表迭代器（集合特有的遍历方式）
②for循环(带有索引的遍历方式)
③增强for循环(最方便的遍历方式)

ArrayList

ArrayList是Java中的动态数组实现的集合类，它实现了List接口，可以用于存储有序的元素集合。ArrayList允许在列表的任何位置插入、删除和访问元素，并且可以根据需要动态调整其大小。

ArrayList中常用的方法包括：

1. add(element)：将指定的元素添加到列表的末尾。
2. add(index, element)：在指定的索引位置插入指定的元素。
3. get(index)：获取指定索引位置的元素。
4. remove(index)：删除指定索引位置的元素。
5. size()：返回列表的大小（元素个数）。
6. clear()：清空列表中的所有元素。
7. contains(element)：判断列表中是否包含指定的元素。
8. indexOf(element)：返回指定元素在列表中第一次出现的索引。
9. lastIndexOf(element)：返回指定元素在列表中最后一次出现的索引。
10. set(index, element)：将指定索引位置的元素替换为指定的元素。

ArrayList是一个常用的集合类，适用于需要频繁访问和修改元素的场景。

LinkedList

LinkedList是Java中的一个双向链表实现的集合类，它实现了List接口和Deque接口，可以用于存储有序的元素集合。
与ArrayList相比，LinkedList在插入和删除元素时更加高效，因为它不需要像ArrayList那样移动元素。

LinkedList中常用的方法包括：

1. add(element)：将指定的元素添加到列表的末尾。

2. add(index, element)：在指定的索引位置插入指定的元素。

3. get(index)：获取指定索引位置的元素。

4. remove(index)：删除指定索引位置的元素。

5. remove(Object o)：删除指定元素o，如果存在多个相同元素，则只删除第一个匹配的元素。(如果要删除的元素不存在，remove方法则会返回false)

6. size()：返回列表的大小（元素个数）。

7. clear()：清空列表中的所有元素。

8. contains(element)：判断列表中是否包含指定的元素。

9. indexOf(element)：返回指定元素在列表中第一次出现的索引。

10. lastIndexOf(element)：返回指定元素在列表中最后一次出现的索引。

11. offerFirst(element)：将指定的元素插入到列表的开头。

12. offerLast(element)：将指定的元素插入到列表的末尾。

13. pollFirst()：移除并返回列表的第一个元素。

14. pollLast()：移除并返回列表的最后一个元素。

15. peekFirst()：返回列表的第一个元素，但不移除。

16. peekLast()：返回列表的最后一个元素，但不移除。

除了上述方法，LinkedList还提供了一些其他方法用于操作链表，如添加、删除、获取元素等。通过这些方法，可以方便地对LinkedList中的元素进行操作。

(三)Set

Set集合的特点：
不包含重复元素的集合
没有带索引的方法，所以不能使用普通for循环遍历

HashSet

在Java中，HashSet是一个实现了Set接口的集合类，它基于哈希表实现。下面是HashSet的一些常用方法：

1. add(E e): 向HashSet中添加元素 e
2. remove(Object o): 从HashSet中移除元素o
3. contains(Object o): 判断HashSet是否包含元素o
4. size(): 返回HashSet中的元素个数
5. isEmpty(): 判断HashSet是否为空
6. clear(): 清空HashSet中的所有元素
7. iterator(): 返回在HashSet上进行迭代的迭代器
8. toArray(): 将HashSet转换为数组
9. equals(Object o): 判断HashSet是否与指定对象 o 相等
10. hashCode(): 返回HashSet对象的哈希码值
11. clone(): 创建并返回HashSet的浅表副本

除了以上这些，HashSet还继承了Set接口和Collection接口的方法。需要注意的是，HashSet不保证元素的顺序，不包含重复的元素。

TreeSet

TreeSet集合特点

1. 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法。
   TreeSet():根据其元素的自然排序进行排序
   TreeSet(Comparator comparator):根据指定的比较器进行排序
2. 没有带索引的方法，所以不能使用普通的for循环遍历；
3. 由于是set集合，所以不包含重复的集合。

常用方法包括：

1. add(E e)：向集合中添加元素。
2. remove(Object o)：从集合中移除指定元素。
3. contains(Object o)：判断集合中是否包含指定元素。
4. size()：返回集合中元素的个数。
5. isEmpty()：判断集合是否为空。
6. clear()：清空集合中的所有元素。
7. iterator()：返回一个迭代器，用于遍历集合中的元素。
8. first()：返回集合中的第一个元素。
9. last()：返回集合中的最后一个元素。
10. headSet(E toElement)：返回小于指定元素的子集合。
11. tailSet(E fromElement)：返回大于等于指定元素的子集合。
12. subSet(E fromElement, E toElement)：返回指定范围内的子集合。

通过TreeSet的这些方法，可以方便地对集合中的元素进行添加、删除、查找和遍历操作，并且可以根据元素的顺序进行子集合的操作。

(四)泛型

泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型
它的本质是参数化类型，即操作的数据类型被指定为一个参数
将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

泛型的好处
①把运行时期的问题提前到了编译期间
②避免了强制类型转换

此处的 T 可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
通常情况下，T 表示 “Type”，
E 表示 “Element”，
K 表示 “Key”，
V 表示 “Value”
这些符号没有固定的含义，仅作为占位符号在泛型代码中使用。
选择使用哪个符号来表示泛型参数，完全取决于程序员的个人喜好和约定。

类型通配符

为了表示各种泛型List的父类，可以使用类型通配符
类型通配符:<?>
List<?>: 表示元素类型末知的List，它的元素可以匹配任何的类型
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果说我们不希望 List<?> 是任何泛型 List 的父类，只希望它代表某一类泛型 List 的父类，可以使用类型通配符的上限
类型通配符上限: <?extends类型>
List<?extends Number>: 它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
类型通配符下限: <?super类型>
List<?super Number>: 它表示的类型是Number或者其父类型

可变参数

一个方法实现多个参数(参数个数不一定)的操作
可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了格式:
修饰符 返回值类型方法名(数据类型…变量名))
范例: public static int sum(int…a) { }

public static int sum(int...a){
        int sum = 0;
        for (int i:a){
            sum += i;
        }
        return sum;
    }

可变参数注意事项:
这里的变量其实是一个数组如果一个方法有多个参数，包含可变参数，可变参数要放在最后

(五)Map集合

Map集合概述
Interface Map<K,V> K:键的类型; V:值的类型
将键映射到值的对象
不能包含重复的键；每个键可以映射到最多一个值

创建 Map 集合的对象:
①多态的方式
②具体的实现类 HashMap(哈希映射)

(1)Map集合的常用方法

1. put(key, value): 添加元素，将指定的键值对存储到 HashMap 中
   (键第一次出现是添加元素，第二次出现就是修改元素，用后面的值把前面的替代掉)
2. remove(key): 根据指定的键移除对应的键值对(返回要删除的键对应的值)
3. containsKey(key): 判断 HashMap 中是否包含指定的键(包含就返回true，否则false)
4. containsValue(value): 判断 HashMap 中是否包含指定的值
5. size(): 获取 HashMap 中键值对的数量
6. clear(): 清空 HashMap 中的所有键值对
7. isEmpty():判断集合是否为空

Map集合的获取功能：
8. get(key): 根据指定的键获取对应的值
9. keySet(): 获取 HashMap 中所有的键 Set< K >
10. values(): 获取 HashMap 中所有的值 Collection< V >
11. entrySet(): 获取 HashMap 中所有的键值对 Set < Map.Entry< K,V >>

如果键重复的话，之前的值会被覆盖掉

(2)Map集合的遍历

方法一：
1:获取所有键的集合。用keySet()方法实现
2:遍历键的集合，获取到每一个键。用增强for实现
3:根据键去找值。用get(object key)方法实现

//创建集合对象
Map<String,String> map = new HashMap<String,String>();
//添加元素
map.put("张无忌","赵敏");
map.put("郭靖","黄蓉");
map.put("杨过","小龙女");

//获取所有键的集合
Set<String> keySet = map.keySet();
//遍历键的集合，获取每一个键
for(String key:keySet){
    //根据键找值
    String value = map.get(key);
    System.out.println(key + ","value);
}

方法二：
转换为Map集合中的操作:
获取所有键值对对象的集合
     Set< Map.Entry< K,V >> entrySet(): 获取所有键值对对象的集合
遍历键值对对象的集合，得到每一个键值对对象
     用增强for实现，得到每一个 Map.Entry
根据键值对对象获取键和值
用 getKey() 得到键
用 getValue() 得到值

//获取所有键值对对象的集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//遍历键值对对象的集合，得到每一个键值对对象
for (Map.Entry<String, String> me : entrySet) {
    //根据键值对对象获取键和值
    String key = me.getKey();
    String value = me.getValue();
    System.out.println(key +"" + value);
}

***Map.Entry< K, V >*是Java中表示键值对的接口。
它表示 Map 中的一个条目，包含一个键和对应的值。
Map 接口中的方法 entrySet() 返回一个包含Map中所有条目的Set集合，每个条目都是一个Map.Entry对象。
Map.Entry接口提供了getKey()和getValue()**方法分别用于获取键和值。
可以使用 Map.Entry 对象来遍历Map中的所有条目，或者对Map中的条目进行操作。
Map.Entry接口是泛型接口，可以使用任意类型作为键和值。

(六)Collections

针对集合操作的工具类
此类仅由静态方法组成

Collections类的常用方法：
sort(List< T > list): 将指定的列表按升序排序(Collections.sort)

Collections.sort()方法： Collections.sort()方法是Java中的一个静态方法，用于对集合进行排序。该方法接受一个List类型的集合作为参数，并根据集合元素的自然顺序或指定的Comparator进行排序。具体语法如下：
public static void sort(List list)
其中，T表示集合中元素的类型。Collections.sort()方法会根据集合元素的自然顺序进行排序，如果集合元素的类型实现了Comparable接口并重写了compareTo()方法，则会按照compareTo()方法定义的顺序进行排序。如果集合元素的类型没有实现Comparable接口，则会抛出ClassCastException异常。

reverse(List< ? > list): 反转指定列表中素的顺序
shuffle(List< ? > list): 使用默认的随机源随机排列指定的列表(按照随机的顺序重新排列、洗牌)

sort(List ist, Comparator<? super T> c)

线程安全的方法：
public static < T > List< T > synchronizedList(List< T > list)
public static < K,V > Map< K,V > synchronizedMap(Map< K,V > m)
public static < T > Set< T > synchronizedSet(Set< T > s)

Donate