两大集合接口
Collection
- 单列集合接口，它是所有单列集合类的根接口。
- Collection集合有两个重要的子接口，分别是List和Set
- List集合的特点是元素有序、可重复。该接口的主要实现类有ArrayList和LinkedList
- Set集合的特点是元素无序并且不可重复。该接口的主要实现类有HashSet和TreeSet
相关方法
Map
- 双列集合接口，用于存储具有键（key）、值（Value）映射关系的元素
- 它存储了一组键值对的数据，其中每个键都是唯一的。通过键可以快速地访问对应的值
- Map接口的主要实现类有HashMap和TreeMap
| Collection | List | ArrayList | 使用数组实现的动态数组 |
| LinkedList | 使用链表数据结构来存储元素 | ||
| set | HashSet | 使用哈希表作为其底层数据结构 | |
| TreeSet | 使用红黑树的数据结构来存储元素 | ||
| Map<K,V> | AbstractMap<K,V> | HashMap<K,V> | 使用数组+链表+红黑树的结构 |
| TreeMap<K,V> | 使用红黑树，TreeMap实现了有序的键值对存储和检索 | ||
| ConcurrentHashMap<K,V> | 使用数组+链表+红黑树的组合实现的 | ||
| Dictionary<K,V> | HashTable<K,V> | 使用数组和链表的结合方式 |
ArrayList与LinkedList
ArrayList
- 使用数组实现的动态数组，它实现了可变大小的数组
- 提供快速的随机访问，但插入和删除操作可能较慢（需要移动元素）
LinkedList
- 使用链表数据结构来存储元素
- 提供快速的插入和删除操作，但随机访问较慢（需要顺序遍历）
public class ListTest {
public static void main(String[] args) {
//ArrayList随机访问
List<String> arrayList = new ArrayList<>();
arrayList.add("Lucy");
arrayList.add(1, "Tom");
System.out.println(arrayList);
//多用于快速随机访问
String rst = arrayList.get(1);
System.out.println(rst);
//LinkedList插入操作
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("Kitty");
//多用于插入与删除操作，尤其是在大数据中
linkedList.add(0, "LiSi");
System.out.println(linkedList);
}
}
HashSet、LinkedHashSet与TreeSet
- HashSet：无序，快速查找，但是不支持元素的有序遍历
- LinkedHashSet：保持插入顺序，查询速度和HashSet相当
- TreeSet：保持自然顺序，查找速度慢于前两者，但是可以有序遍历
public class SetTest {
public static void main(String[] args) {
//HashSet快速查找
Set<Integer> hashSet = new HashSet<>();
hashSet.add(20);
hashSet.add(40);
hashSet.add(42);
//快速查找
boolean contains1 = hashSet.contains(22);
boolean contains2 = hashSet.contains(42);
System.out.println(contains1);
System.out.println(contains2);
//LinkedHashSet保持插入顺序
Set<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("apple");
linkedHashSet.add("banana");
linkedHashSet.add("cherry");
//按插入顺序遍历
Iterator<String> iterator = linkedHashSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//TreeSet自然排序
TreeSet<Integer> treeSt=new TreeSet<>();
treeSt.add(0);
treeSt.add(2);
treeSt.add(8);
//获取第一个（最小的）元素
Integer first = treeSt.first();
Integer last = treeSt.last();
System.out.println(first);
System.out.println(last);
}
}HashMap 、TreeMap与ConcurrentHashMap
- HashMap<K,V>用于存储键值对，并且不保证顺序。它基于哈希表实现，提供了快速的插入、删除和查找操作。
- TreeMap<K,V>用于存储有序的键值对。它基于红黑树实现，对插入、删除、查找等操作都提供了较高的性能
- ConcurrentHashMap<K,V>用于用于存储有序的键值对，多线程安全场景，不同的线程可以同时访问不同的段，并发操作不会产生冲突
- EnumMap与EnumSet专门为枚举类型设计的集合，内部使用数组而不是哈希表
enum Color {RED, GREEN, BLUE}
public class MapTest {
public static void main(String[] args) {
//使用HashMap
Map<String, String> hashMap = new HashMap<>();
hashMap.put("Java", "JVM");
hashMap.put("C#", "WINFOEM");
//使用LinkedHashMap
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("Java", "NORMAL");
linkedHashMap.put("C#", "EASY");
//使用TreeMap
Map<String, String> treeMap = new TreeMap<>();
treeMap.put("Java", "DEPT");
treeMap.put("C#", "COMPANY");
//使用EnumMap
Map<Color, String> enumMap = new EnumMap<>(Color.class);
enumMap.put(Color.RED, "Ruby");
enumMap.put(Color.GREEN, "Emerald");
//使用EnumSet
Set<Color> enumSet = EnumSet.of(Color.RED, Color.BLUE);
}
}集合的操作与算法
遍历：增强型for循环，迭代器、Java8的stream流
搜索：使用List的indexOf和lastIndexOf方法来搜索特定元素
排序：使用Collections类或者Java8的流来对集合排序
public class OperateTest {
public static void main(String[] args) {
//使用增强型for循环遍历List
List<String> list = new ArrayList<>();
list.add("Tom");
list.add("Nancy");
for (String language : list) {
System.out.println(language);
}
//使用迭代器遍历Set
Set<String> set = new HashSet<>();
set.add("SuSan");
set.add("Mark");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
//使用Java 8 Stream遍历Map
Map<String, String> map = new HashMap<>();
map.put("Java", "JVM");
map.put("C#", "NC");
map.forEach((key, value) -> System.out.println(key + " runs on " + value));
//搜索
List<String> list1 = Arrays.asList("Java", "Kotlin", "Scala", "Groovy");
int index = list1.indexOf("Kotlin"); // 返回1
System.out.println(index);
//使用Collections.sort()对List进行排序
List<String> list2 = new ArrayList<>();
list2.add("Tom");
list2.add("Kotlin");
Collections.sort(list2);
System.out.println(list2);
//使用Java 8 Stream对List进行自定义排序
List<String> list3 = new ArrayList<>();
list3.add("Tom");
list3.add("Ace");
List<String> sortedList = list3.stream()
.sorted((s1, s2) -> s1.compareTo(s2))
.collect(Collectors.toList());
System.out.println(sortedList);
}
}集合转换：可以使用Collections类或Java 8的流来进行集合转换
不可变集合：指一旦创建后就不能被修改的集合，它们提供了更好的线程安全性
public class Operate1Test {
public static void main(String[] args) {
//将List转换为Set
List<String> list = Arrays.asList("Java", "Kotlin", "Java");
Set<String> set = new HashSet<>(list);
System.out.println(set);
//使用Java 8 Stream将List转换为Map
Map<String, Integer> map = list.stream()
.collect(Collectors.toMap(
String::toString,
s -> 1,
(existing, replacement) -> existing
));
System.out.println(map);
//创建不可变List
List<String> immutableList = Collections.unmodifiableList(
new ArrayList<>(Arrays.asList("Java", "Kotlin"))
);
System.out.println(immutableList);
//创建不可变Set
Set<String> immutableSet = Collections.unmodifiableSet(
new HashSet<>(Arrays.asList("Java", "Kotlin"))
);
System.out.println(immutableSet);
}
}Collections和Arrays类提供了多种静态方法来操作集合和数组，翻转、排序、二分查找和填充等算法
public class Operate2Test {
public static void main(String[] args) {
//集合
List<String> list = Arrays.asList("Java", "C#", "PHP");
Collections.reverse(list); // 翻转List
System.out.println(list);
Collections.shuffle(list); // 随机打乱List
System.out.println(list);
//数组
Integer[] array = {3, 1, 4, 1, 5};
Arrays.sort(array); // 排序数组
int index = Arrays.binarySearch(array, 4); // 二分查找
System.out.println(index);
}
}