网站建设求职简历模板,一级a做爰片免费网站 小说,kalium wordpress,北京菜谱设计制作Java提供了多种集合框架类#xff0c;每种都有不同的特性和用途。以下是Java中常见的集合类#xff1a;
1、List#xff08;列表#xff09;:
ArrayList
ArrayList 是 Java 集合框架中的一个常用类#xff0c;实现了动态数组的数据结构。与传统的数组相比#xff0c;A…Java提供了多种集合框架类每种都有不同的特性和用途。以下是Java中常见的集合类
1、List列表:
ArrayList
ArrayList 是 Java 集合框架中的一个常用类实现了动态数组的数据结构。与传统的数组相比ArrayList 具有动态调整大小的能力可以方便地进行元素的添加、删除和访问。以下是关于 ArrayList 的介绍和使用方法
特点
1、动态数组 ArrayList 是基于动态数组的实现可以动态地增加或减少元素的数量。
2、随机访问 通过索引可以快速随机访问列表中的元素。
3、自动扩容 当元素数量超过当前容量时ArrayList 会自动扩展容量以适应更多的元素。
4、支持泛型 ArrayList 支持泛型可以存储任意类型的对象。
基本使用
1、创建 ArrayList 对象
import java.util.ArrayList;// 创建一个空的 ArrayList
ArrayListString arrayList new ArrayList();// 创建带有初始容量的 ArrayList
ArrayListInteger intList new ArrayList(10);
2、添加元素
arrayList.add(Java);
arrayList.add(Python);
arrayList.add(C);
3、访问元素
String firstElement arrayList.get(0);
System.out.println(First Element: firstElement);
4、删除元素
arrayList.remove(Python);
5、迭代 ArrayList
for (String element : arrayList) {System.out.println(element);
}
6、获取 ArrayList 的大小
int size arrayList.size();
System.out.println(Size: size);
注意事项
1、ArrayList 是非同步的不适合在多线程环境中使用。如果需要在多线程环境中使用可以考虑使用 Vector 或者使用 Collections.synchronizedList 方法使 ArrayList 变为同步的。
2、如果需要在中间插入或删除元素频繁的场景可能会使用 LinkedList 更为高效。
ArrayList 是 Java 集合框架中最常用的类之一适用于许多不同的应用场景从简单的列表到更复杂的数据结构。
LinkedList
LinkedList 是 Java 集合框架中的一个类它实现了双向链表的数据结构。与 ArrayList 不同LinkedList 不是基于动态数组实现的而是通过节点之间的链接来组织元素。以下是关于 LinkedList 的介绍和使用方法
特点
1、双向链表 每个节点包含数据元素和对前后节点的引用使得在链表中可以双向遍历。
2、动态插入和删除 由于链表的结构LinkedList 在中间插入或删除元素的操作比 ArrayList 更为高效。
3、非同步 LinkedList 不是同步的不适合在多线程环境中直接使用。在多线程环境中可以使用 Collections.synchronizedList 方法包装它或者考虑使用 LinkedBlockingDeque 等并发集合。
基本使用
1、创建 LinkedList 对象
import java.util.LinkedList;// 创建一个空的 LinkedList
LinkedListString linkedList new LinkedList();
2、添加元素
linkedList.add(Java);
linkedList.add(Python);
linkedList.add(C);
3、在指定位置插入元素
linkedList.add(1, JavaScript);
4、访问元素
String firstElement linkedList.getFirst();
System.out.println(First Element: firstElement);
5、删除元素
linkedList.remove(Python);
6、迭代 LinkedList
for (String element : linkedList) {System.out.println(element);
}
7、获取 LinkedList 的大小
int size linkedList.size();
System.out.println(Size: size);
8、使用迭代器逆向遍历
ListIteratorString iterator linkedList.listIterator(linkedList.size());
while (iterator.hasPrevious()) {String element iterator.previous();System.out.println(element);
}
注意事项
1、LinkedList 在需要频繁插入、删除元素或双向遍历的场景中表现更为出色。
2、如果对元素的随机访问较多可以考虑使用 ArrayList。
3、在大多数情况下考虑使用 List 接口来声明变量以便可以更轻松地更改底层实现。例如
ListString list new LinkedList(); // 或者 ListString list new ArrayList();
LinkedList 在某些特定的应用场景下非常有用但在其他场景中可能不如 ArrayList 效率高。 选择使用哪个取决于你的具体需求和对性能的要求。
Vector
Vector 是 Java 集合框架中的一个传统类它实现了动态数组的数据结构与 ArrayList 类似。然而与 ArrayList 不同的是Vector 是同步的因此其方法都是线程安全的。以下是关于 Vector 的介绍和使用方法
特点
1、同步性 Vector 是同步的这意味着它的方法都是线程安全的。在多线程环境中可以确保多个线程不会同时修改 Vector 对象。
2、动态数组 Vector 是基于动态数组的数据结构可以动态地增加或减少元素的数量。
3、初始容量和增长因子 Vector 可以在创建时指定初始容量它还具有一个增长因子用于在需要时自动增加容量。
基本使用
1、创建 Vector 对象
import java.util.Vector;// 创建一个空的 Vector
VectorString vector new Vector();// 创建指定初始容量的 Vector
VectorInteger intVector new Vector(10);
2、添加元素
vector.add(Java);
vector.add(Python);
vector.add(C);
3、访问元素
String firstElement vector.get(0);
System.out.println(First Element: firstElement);
4、删除元素
vector.remove(Python);
5、迭代 Vector
for (String element : vector) {System.out.println(element);
}
6、获取 Vector 的大小和容量
int size vector.size();
int capacity vector.capacity();
System.out.println(Size: size);
System.out.println(Capacity: capacity);
7、同步访问
由于 Vector 是同步的可以在多线程环境中安全使用但在单线程环境下使用 ArrayList 可能更高效。
注意事项
1、由于同步的开销除非需要线程安全否则建议使用 ArrayList 或者其他非同步的集合类。
2、如果需要在中间插入或删除元素频繁的场景可能会使用 LinkedList 更为高效。
总的来说Vector 在现代 Java 开发中不常用因为它的同步性能开销相对较高而且有更现代的替代品如 ArrayList 和 LinkedList它们在大多数情况下更为常见和高效。
Stack
Stack 是 Java 集合框架中的一个类它实现了后进先出LIFO的堆栈数据结构。Stack 继承自 Vector 类因此它保留了 Vector 的同步性但由于其特定的用途通常建议使用更现代的 Deque 接口的实现类 LinkedList 代替 Stack。以下是关于 Stack 的介绍和使用方法
特点
1、后进先出LIFO Stack 是一种后进先出的数据结构即最后添加的元素最先被移除。
2、继承自 Vector Stack 类继承自 Vector因此具有 Vector 的同步性。
基本使用
1、创建 Stack 对象
import java.util.Stack;// 创建一个空的 Stack
StackString stack new Stack();
2、压栈和弹栈
stack.push(Java);
stack.push(Python);
stack.push(C);// 弹出栈顶元素
String topElement stack.pop();
System.out.println(Top Element: topElement);
3、查看栈顶元素
String peekElement stack.peek();
System.out.println(Top Element (without removing): peekElement);
4、判断栈是否为空
boolean isEmpty stack.isEmpty();
System.out.println(Is Stack Empty? isEmpty);
5、获取栈的大小
int size stack.size();
System.out.println(Stack Size: size);
注意事项
1、Stack 的同步性使得在多线程环境中可以安全使用但如果不需要同步推荐使用 LinkedList 作为栈的替代品。
2、在现代 Java 编程中更常用的做法是使用 Deque 接口的实现类 LinkedList 来实现栈的功能因为它提供了更多灵活性和性能。
下面是使用 LinkedList 实现栈的示例
import java.util.LinkedList;// 创建一个空的栈
LinkedListString stack new LinkedList();// 压栈
stack.push(Java);
stack.push(Python);
stack.push(C);// 弹栈
String topElement stack.pop();
System.out.println(Top Element: topElement);
总体而言在现代 Java 编程中推荐使用 Deque 接口的实现类 LinkedList 或者 ArrayDeque 来实现栈的功能。
2、Set集合:
HashSet
HashSet 是 Java 集合框架中的一个类它实现了 Set 接口基于哈希表实现。以下是关于 HashSet 的介绍和使用方法
特点
1、无序性 HashSet 不保证元素的顺序即你添加元素的顺序不一定就是元素被存储的顺序。
2、唯一性 HashSet 中不能包含重复的元素。如果尝试将重复的元素添加到 HashSet 中添加操作将被忽略。
3、基于哈希表 HashSet 使用哈希表来存储元素因此具有快速的查找性能。
基本使用
1、创建 HashSet 对象
import java.util.HashSet;// 创建一个空的 HashSet
HashSetString hashSet new HashSet();
2、添加元素
hashSet.add(Java);
hashSet.add(Python);
hashSet.add(C);
3、判断元素是否存在
boolean containsJava hashSet.contains(Java);
System.out.println(Contains Java? containsJava);
4、删除元素
hashSet.remove(Python);
5、获取 HashSet 的大小
int size hashSet.size();
System.out.println(HashSet Size: size);
6、迭代 HashSet
for (String element : hashSet) {System.out.println(element);
}
注意事项
1、由于 HashSet 是基于哈希表实现的元素的存储顺序是不确定的。如果需要有序性可以考虑使用 LinkedHashSet。
2、HashSet 对元素的唯一性的判断是通过元素的 hashCode 和 equals 方法来完成的。因此如果你在自定义类中使用 HashSet确保正确实现了 hashCode 和 equals 方法。
3、HashSet 不是同步的如果需要在多线程环境中使用可以考虑使用 Collections.synchronizedSet 方法包装它或者使用 ConcurrentHashSet。
HashSet 是在很多场景下都很有用的集合类特别是在需要快速查找不重复元素的情况下。
LinkedHashSet
LinkedHashSet 是 Java 集合框架中的一个类它是 HashSet 的一个子类实现了 Set 接口。与 HashSet 不同的是LinkedHashSet 维护元素的插入顺序因此它提供了有序性。以下是关于 LinkedHashSet 的介绍和使用方法
特点
1、有序性 LinkedHashSet 会按照元素的插入顺序维护元素的顺序。因此迭代 LinkedHashSet 时会按照插入的顺序返回元素。
2、唯一性 与 HashSet 类似LinkedHashSet 中不能包含重复的元素。
基本使用
1、创建 LinkedHashSet 对象
import java.util.LinkedHashSet;// 创建一个空的 LinkedHashSet
LinkedHashSetString linkedHashSet new LinkedHashSet();
2、添加元素
linkedHashSet.add(Java);
linkedHashSet.add(Python);
linkedHashSet.add(C);
3、判断元素是否存在
boolean containsJava linkedHashSet.contains(Java);
System.out.println(Contains Java? containsJava);
4、删除元素
linkedHashSet.remove(Python);
5、获取 LinkedHashSet 的大小
int size linkedHashSet.size();
System.out.println(LinkedHashSet Size: size);
6、迭代 LinkedHashSet
for (String element : linkedHashSet) {System.out.println(element);
}
注意事项
1、LinkedHashSet 维护插入顺序的特性使得它适用于需要按照元素插入的顺序进行迭代的场景。
2、LinkedHashSet 不是同步的如果需要在多线程环境中使用可以考虑使用 Collections.synchronizedSet 方法包装它或者使用 ConcurrentLinkedHashSet。
总体而言LinkedHashSet 是在需要按照插入顺序保持元素的场景中很有用的集合类。
TreeSet
TreeSet 是 Java 集合框架中的一个类它实现了 SortedSet 接口是基于红黑树Red-Black Tree实现的有序集合。以下是关于 TreeSet 的介绍和使用方法
特点
1、有序性 TreeSet 会按照元素的自然顺序或者通过提供的比较器Comparator进行排序。 因此迭代 TreeSet 时会按照升序顺序返回元素。
2、唯一性 与 Set 接口相同TreeSet 中不能包含重复的元素。
基本使用
1、创建 TreeSet 对象
import java.util.TreeSet;// 创建一个空的 TreeSet
TreeSetString treeSet new TreeSet();
2、添加元素
treeSet.add(Java);
treeSet.add(Python);
treeSet.add(C);
3、判断元素是否存在
boolean containsJava treeSet.contains(Java);
System.out.println(Contains Java? containsJava);
4、删除元素
treeSet.remove(Python);
5、获取 TreeSet 的大小
int size treeSet.size();
System.out.println(TreeSet Size: size);
6、迭代 TreeSet
for (String element : treeSet) {System.out.println(element);
}
自定义排序
TreeSet 可以通过提供一个比较器Comparator来实现自定义排序。例如如果要按照字符串长度降序排序可以创建一个比较器并传递给 TreeSet 的构造函数
import java.util.TreeSet;
import java.util.Comparator;public class CustomComparatorExample {public static void main(String[] args) {// 创建一个基于字符串长度的降序排序的 TreeSetTreeSetString customTreeSet new TreeSet(Comparator.comparing(String::length).reversed());// 添加元素customTreeSet.add(Java);customTreeSet.add(Python);customTreeSet.add(C);// 迭代 TreeSetfor (String element : customTreeSet) {System.out.println(element);}}
}
注意事项
1、如果元素是自定义类的对象确保该类实现了 Comparable 接口或者在创建 TreeSet 时提供了比较器以便 TreeSet 知道如何对元素进行排序。
2、TreeSet 的排序是基于元素的自然顺序或者提供的比较器因此元素类型必须是可比较的。
3、TreeSet 不是同步的如果需要在多线程环境中使用可以考虑使用 Collections.synchronizedSortedSet 方法包装它或者使用 ConcurrentSkipListSet。
TreeSet 在需要有序集合的场景中非常有用尤其是当你需要按照自然顺序或者自定义的顺序迭代元素时。
3、Map映射:
HashMap
HashMap 是 Java 集合框架中的一个类它实现了 Map 接口用于存储键值对。以下是关于 HashMap 的介绍和使用方法
特点
1、键值对存储 HashMap 存储的是键值对key-value pair每个键都映射到一个值。
2、无序性 HashMap 中的键值对没有固定的顺序即你添加键值对的顺序不一定就是它们被存储的顺序。
3、唯一性 HashMap 中的键是唯一的一个键只能对应一个值。但值可以重复。
4、基于哈希表 HashMap 使用哈希表实现通过键的哈希码来快速定位键值对的存储位置从而实现高效的查找、插入和删除操作。
基本使用
1、创建 HashMap 对象
import java.util.HashMap;
import java.util.Map;// 创建一个空的 HashMap
HashMapString, Integer hashMap new HashMap();
2、添加键值对
hashMap.put(Java, 1);
hashMap.put(Python, 2);
hashMap.put(C, 3);
3、获取值
int javaValue hashMap.get(Java);
System.out.println(Javas value is: javaValue);
4、判断键是否存在
boolean containsJava hashMap.containsKey(Java);
System.out.println(Contains Java? containsJava);
5、删除键值对
hashMap.remove(Python);
6、获取 HashMap 的大小
int size hashMap.size();
System.out.println(HashMap Size: size);
7、迭代 HashMap
for (Map.EntryString, Integer entry : hashMap.entrySet()) {System.out.println(Key: entry.getKey() , Value: entry.getValue());
}
注意事项
1、HashMap 不是同步的如果需要在多线程环境中使用可以考虑使用 Collections.synchronizedMap 方法包装它或者使用 ConcurrentHashMap。
2、由于 HashMap 中的键值对没有固定的顺序如果需要有序性可以考虑使用 LinkedHashMap。
总体而言HashMap 是在很多场景下都非常有用的集合类特别是在需要键值对存储和快速查找的情况下。
LinkedHashMap
LinkedHashMap 是 Java 集合框架中的一个类它实现了 Map 接口是 HashMap 的一个具体实现。与 HashMap 不同的是LinkedHashMap 在内部使用双向链表维护插入顺序或者访问顺序使得它可以保留元素的插入顺序或者访问顺序。以下是关于 LinkedHashMap 的介绍和使用方法
特点
1、有序性 LinkedHashMap 可以保留元素的插入顺序或者访问顺序。通过构造函数可以选择使用插入顺序或者访问顺序。
2、基于哈希表和链表 LinkedHashMap 内部使用哈希表来存储键值对并通过双向链表来维护元素的顺序。
3、性能 与 HashMap 类似LinkedHashMap 具有快速的查找性能但相对于 HashMap在迭代时元素的顺序是有序的。
基本使用
1、创建 LinkedHashMap 对象
import java.util.LinkedHashMap;
import java.util.Map;// 创建一个空的 LinkedHashMap按照插入顺序
LinkedHashMapString, Integer linkedHashMap new LinkedHashMap();
2、添加键值对
linkedHashMap.put(Java, 1);
linkedHashMap.put(Python, 2);
linkedHashMap.put(C, 3);
3、获取值
int javaValue linkedHashMap.get(Java);
System.out.println(Javas value is: javaValue);
4、判断键是否存在
boolean containsJava linkedHashMap.containsKey(Java);
System.out.println(Contains Java? containsJava);
5、删除键值对
linkedHashMap.remove(Python);
6、获取 LinkedHashMap 的大小
int size linkedHashMap.size();
System.out.println(LinkedHashMap Size: size);
7、迭代 LinkedHashMap
for (Map.EntryString, Integer entry : linkedHashMap.entrySet()) {System.out.println(Key: entry.getKey() , Value: entry.getValue());
}
构造函数选择顺序
1、LinkedHashMap 的构造函数允许你选择使用插入顺序或者访问顺序。默认情况下是按照插入顺序
LinkedHashMapK, V linkedHashMap new LinkedHashMap();
2、如果需要按照访问顺序
LinkedHashMapK, V linkedHashMap new LinkedHashMap(16, 0.75f, true);
上述构造函数的第三个参数设置为 true 表示按照访问顺序。当使用 get 方法访问某个键时该键会被移到双向链表的末尾保持最近访问的元素在链表尾部。
总体而言LinkedHashMap 在需要保留元素插入顺序或者访问顺序的场景中非常有用。如果你需要在迭代时保持元素的有序性可以选择使用 LinkedHashMap。
TreeMap
TreeMap 是 Java 集合框架中的一个类它实现了 SortedMap 接口是基于红黑树Red-Black Tree实现的有序映射。以下是关于 TreeMap 的介绍和使用方法
特点
1、有序性 TreeMap 中的键值对是按照键的自然顺序或者通过提供的比较器进行排序的。因此迭代 TreeMap 时会按照升序顺序返回键值对。
2、唯一性 与 Map 接口相同TreeMap 中的键是唯一的一个键只能对应一个值。
3、基于红黑树 TreeMap 内部使用红黑树数据结构这是一种自平衡的二叉查找树。这使得 TreeMap 具有较好的查找、插入和删除性能。
基本使用
1、创建 TreeMap 对象
import java.util.TreeMap;// 创建一个空的 TreeMap
TreeMapString, Integer treeMap new TreeMap();
2、添加键值对
treeMap.put(Java, 1);
treeMap.put(Python, 2);
treeMap.put(C, 3);
3、获取值
int javaValue treeMap.get(Java);
System.out.println(Javas value is: javaValue);
4、判断键是否存在
boolean containsJava treeMap.containsKey(Java);
System.out.println(Contains Java? containsJava);
5、删除键值对
treeMap.remove(Python);
6、获取 TreeMap 的大小
int size treeMap.size();
System.out.println(TreeMap Size: size);
7、迭代 TreeMap
for (String key : treeMap.keySet()) {System.out.println(Key: key , Value: treeMap.get(key));
}
自定义排序
TreeMap 允许在创建时提供一个比较器Comparator以便进行自定义排序。例如如果要按照字符串长度降序排序
import java.util.TreeMap;
import java.util.Comparator;public class CustomComparatorExample {public static void main(String[] args) {// 创建一个基于字符串长度的降序排序的 TreeMapTreeMapString, Integer customTreeMap new TreeMap(Comparator.comparing(String::length).reversed());// 添加键值对customTreeMap.put(Java, 1);customTreeMap.put(Python, 2);customTreeMap.put(C, 3);// 迭代 TreeMapfor (String key : customTreeMap.keySet()) {System.out.println(Key: key , Value: customTreeMap.get(key));}}
}
注意事项
1、如果元素是自定义类的对象确保该类实现了 Comparable 接口或者在创建 TreeMap 时提供了比较器以便 TreeMap 知道如何对元素进行排序。
2、TreeMap 的排序是基于键的自然顺序或者提供的比较器因此键的类型必须是可比较的。
3、TreeMap 不是同步的如果需要在多线程环境中使用可以考虑使用 Collections.synchronizedSortedMap 方法包装它或者使用 ConcurrentSkipListMap。
TreeMap 在需要有序映射的场景中非常有用尤其是当你需要按照自然顺序或者自定义顺序迭代键值对时。
HashTable
HashTable 是 Java 集合框架中的一个类它实现了 Map 接口提供了键值对的存储和检索。HashTable 是早期的 Java 集合实现之一但在 Java Collections Framework 中已经被更先进的 HashMap 取代。尽管如此了解 HashTable 仍然有其价值。
特点
1、同步性 HashTable 是线程安全的所有的方法都是同步的。这是通过在每个方法上添加 synchronized 关键字来实现的。因此多个线程可以安全地同时访问 HashTable。
2、不允许空键或空值 HashTable 不允许空键key或空值value如果尝试插入空键或空值会抛出 NullPointerException。
3、基于拉链法的哈希表 HashTable 内部使用拉链法来解决哈希冲突即在哈希表的每个位置上维护一个链表。
基本使用
1、创建 HashTable 对象
import java.util.Hashtable;
import java.util.Map;// 创建一个空的 HashTable
HashtableString, Integer hashTable new Hashtable();
2、添加键值对
hashTable.put(Java, 1);
hashTable.put(Python, 2);
hashTable.put(C, 3);
3、获取值
int javaValue hashTable.get(Java);
System.out.println(Javas value is: javaValue);
4、判断键是否存在
boolean containsJava hashTable.containsKey(Java);
System.out.println(Contains Java? containsJava);
5、删除键值对
hashTable.remove(Python);
6、获取 HashTable 的大小
int size hashTable.size();
System.out.println(HashTable Size: size);
7、迭代 HashTable
for (Map.EntryString, Integer entry : hashTable.entrySet()) {System.out.println(Key: entry.getKey() , Value: entry.getValue());
}
注意事项
1、HashTable 是线程安全的但在多线程环境下使用可能会导致性能问题因为所有的方法都是同步的。在现代的 Java 中通常推荐使用 HashMap 代替 HashTable后者的同步性能开销较大。
2、HashTable 不允许空键或空值如果需要支持空键或空值可以考虑使用 HashMap。
3、考虑到 HashTable 的性能和一些限制通常更推荐使用 HashMap 或者 ConcurrentHashMap它们提供了更好的性能和更丰富的功能。
尽管 HashTable 不再是首选的集合实现了解它的特点对于理解 Java 集合框架的演变和一些基本的同步概念仍然有帮助。
4、Queue队列:
PriorityQueue
PriorityQueue 是 Java 集合框架中的一个类它实现了一个优先级队列priority queue。优先级队列是一种特殊的队列其中的元素按照其优先级进行排序。在 PriorityQueue 中优先级由元素的比较器或元素自身的自然顺序决定。以下是关于 PriorityQueue 的介绍和使用方法
特点
1、优先级排序 PriorityQueue 维护了一个基于堆的完全二叉树树中的每个节点表示队列中的一个元素。元素按照其优先级排列根节点具有最高优先级。
2、堆实现 在默认情况下PriorityQueue 是一个最小堆Min Heap。可以通过提供自定义的比较器来创建最大堆Max Heap。
基本使用
1、创建 PriorityQueue 对象
import java.util.PriorityQueue;// 创建一个默认的最小堆 PriorityQueue
PriorityQueueInteger minHeap new PriorityQueue();
2、添加元素
minHeap.add(5);
minHeap.add(3);
minHeap.add(8);
3、获取并移除队列头部的元素
int head minHeap.poll();
System.out.println(Head of the minHeap: head);
4、获取但不移除队列头部的元素
int peek minHeap.peek();
System.out.println(Peek of the minHeap: peek);
5、自定义比较器
import java.util.PriorityQueue;
import java.util.Comparator;// 创建一个最大堆 PriorityQueue提供自定义比较器
PriorityQueueInteger maxHeap new PriorityQueue(Comparator.reverseOrder());
自定义对象的比较
如果要在 PriorityQueue 中存储自定义对象确保对象实现了 Comparable 接口或者在创建 PriorityQueue 时提供了比较器。
import java.util.PriorityQueue;public class CustomObjectExample {public static void main(String[] args) {// 创建一个 Priority Queue 存储自定义对象PriorityQueuePerson personQueue new PriorityQueue();// 添加 Person 对象personQueue.add(new Person(Alice, 25));personQueue.add(new Person(Bob, 30));personQueue.add(new Person(Charlie, 22));// 获取并移除头部的 Person 对象Person headPerson personQueue.poll();System.out.println(Head of the personQueue: headPerson.getName() , Age: headPerson.getAge());}
}class Person implements ComparablePerson {private String name;private int age;public Person(String name, int age) {this.name name;this.age age;}public String getName() {return name;}public int getAge() {return age;}Overridepublic int compareTo(Person other) {// 按照年龄升序排序return Integer.compare(this.age, other.age);}
}
在上述示例中Person 类实现了 Comparable 接口并在 compareTo 方法中定义了对象之间的比较规则。这使得 Person 对象可以按照年龄升序排序。
LinkedList
略...
ArrayDeque
ArrayDeque 是 Java 集合框架中的一个双端队列double-ended queue。它实现了 Deque 接口提供了对队列两端进行高效操作的方法。以下是关于 ArrayDeque 的介绍和使用方法
特点
1、底层数据结构 ArrayDeque 使用可调整大小的数组作为其底层数据结构可以根据需要动态调整数组的大小。
2、双端队列 ArrayDeque 是一个双端队列允许在队列的两端进行添加push和移除pop操作。它还支持在队列的头部和尾部进行插入和删除操作。
3、不限制容量 与传统的队列不同ArrayDeque 不限制容量。它可以根据需要动态调整大小因此在实际使用中无需关心容量问题。
基本使用
1、创建 ArrayDeque 对象
import java.util.ArrayDeque;// 创建一个空的 ArrayDeque
ArrayDequeString arrayDeque new ArrayDeque();
2、添加元素
在队列尾部添加元素
arrayDeque.add(Element1);
arrayDeque.add(Element2);
在队列头部添加元素
arrayDeque.addFirst(FirstElement);
在队列尾部添加元素
arrayDeque.addLast(LastElement);
3、获取并移除元素
从队列头部获取并移除元素
String firstElement arrayDeque.pollFirst();
从队列尾部获取并移除元素
String lastElement arrayDeque.pollLast();
4、获取但不移除元素
获取队列头部的元素不移除
String peekFirstElement arrayDeque.peekFirst();
获取队列尾部的元素不移除
String peekLastElement arrayDeque.peekLast();
应用场景
1、双端队列操作 当需要在队列两端执行高效的插入、删除和获取元素操作时ArrayDeque 是一个很好的选择。
2、无限容量队列 ArrayDeque 不限制容量因此适用于需要不断添加元素而无需担心容量问题的情况。
3、栈的实现 由于 ArrayDeque 具有栈的特性可以用它来实现栈的功能。使用 addFirst 和 pollFirst 方法可以模拟栈的操作。
ArrayDequeInteger stack new ArrayDeque();
stack.addFirst(1); // 入栈
int topElement stack.pollFirst(); // 出栈
ArrayDeque 提供了一种灵活而高效的双端队列实现适用于多种场景。它是 Deque 接口的一个实现因此具备队列和栈的特性。在选择集合类时根据具体的需求和操作模式选择适当的实现类是很重要的。
5、Deque双端队列:
ArrayDeque
略...
LinkedList
略...
6、Collection集合接口:
List
略...
Set
略...
Queue
略...
7、Concurrent集合:
ConcurrentHashMap
ConcurrentHashMap 是 Java 集合框架中的一个线程安全的哈希表实现它继承自 HashMap 类实现了 ConcurrentMap 接口。相比于 HashMapConcurrentHashMap 提供了更高的并发性特别适用于多线程环境。以下是关于 ConcurrentHashMap 的介绍和使用方法
特点和优势
1、线程安全性 ConcurrentHashMap 是线程安全的多个线程可以同时读取和写入而不会导致数据不一致。
2、分段锁 ConcurrentHashMap 使用了分段锁机制将整个数据集分成多个段Segment每个段相当于一个小的 HashMap不同的段可以独立进行读写操作提高并发性能。
3、高并发读 由于读操作并不会涉及到锁所以多个线程可以同时读取。
4、低并发写 写操作只涉及到段级别的锁多个线程可以同时写入不同的段从而提高写入操作的并发性。
基本用法
1、创建 ConcurrentHashMap 对象
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;// 创建一个 ConcurrentHashMap
MapString, Integer concurrentHashMap new ConcurrentHashMap();
2、添加元素
concurrentHashMap.put(Key1, 1);
concurrentHashMap.put(Key2, 2);
3、获取元素
int value concurrentHashMap.get(Key1);
4、删除元素
concurrentHashMap.remove(Key2);
5、遍历元素
for (Map.EntryString, Integer entry : concurrentHashMap.entrySet()) {System.out.println(Key: entry.getKey() , Value: entry.getValue());
}
6、其他操作
ConcurrentHashMap 还提供了一些其他方法如 putIfAbsent、replace 等用于更复杂的操作。
应用场景
1、高并发读写 当需要在多线程环境下进行高并发的读写操作时ConcurrentHashMap 是一个很好的选择。
2、分布式场景 由于 ConcurrentHashMap 的分段锁机制它在分布式场景中也能够提供较好的性能。
在并发环境中ConcurrentHashMap 是一个非常有用的工具可以有效地提高多线程环境下的性能和并发控制。
ConcurrentLinkedQueue
ConcurrentLinkedQueue 是 Java 集合框架中的一个线程安全的队列实现它实现了 Queue 接口。它的设计目标是在多线程环境中提供高效的并发操作。以下是关于 ConcurrentLinkedQueue 的介绍和使用方法
特点和优势
1、线程安全性 ConcurrentLinkedQueue 是线程安全的支持并发读写操作无需额外的同步。
2、基于非阻塞算法 ConcurrentLinkedQueue 的实现基于非阻塞算法采用一种称为 Michael and Scott 的无锁算法不使用锁来保护共享数据而是使用 CASCompare And Swap操作。
3、高并发性 在多线程环境中ConcurrentLinkedQueue 提供了高效的并发性能特别适用于高并发读写的场景。
基本用法
1、创建 ConcurrentLinkedQueue 对象
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;// 创建一个 ConcurrentLinkedQueue
QueueString concurrentLinkedQueue new ConcurrentLinkedQueue();
2、添加元素
concurrentLinkedQueue.offer(Element1);
concurrentLinkedQueue.offer(Element2);
3、获取并移除元素
String element concurrentLinkedQueue.poll();
4、获取但不移除元素
String peekedElement concurrentLinkedQueue.peek();
5、遍历元素
for (String element : concurrentLinkedQueue) {System.out.println(element);
}
6、获取队列大小
int size concurrentLinkedQueue.size();
7、其他操作
ConcurrentLinkedQueue 还提供了一些其他方法如 remove、contains 等用于更复杂的操作。
应用场景
1、生产者-消费者模式 ConcurrentLinkedQueue 可以用于实现生产者-消费者模式其中多个线程可以安全地在队列中添加和获取元素。
2、无界队列 ConcurrentLinkedQueue 是一个无界队列适用于需要不断添加元素而无需担心容量问题的场景。
3、高并发读写 当需要在多线程环境中进行高并发读写操作时ConcurrentLinkedQueue 是一个很好的选择。
在多线程环境中ConcurrentLinkedQueue 提供了一种高效的队列实现特别适用于需要高并发性能的场景。
ConcurrentSkipListMap
ConcurrentSkipListMap 是 Java 集合框架中的一个线程安全的、有序的 Map 实现它实现了 ConcurrentNavigableMap 接口。ConcurrentSkipListMap 基于跳跃表Skip List数据结构提供了高效的并发访问能力。以下是关于 ConcurrentSkipListMap 的介绍和使用方法
特点和优势
1、线程安全性 ConcurrentSkipListMap 是线程安全的支持并发读写操作。
2、有序性 ConcurrentSkipListMap 的键是有序的它们按照自然顺序或者通过比较器进行排序。
3、高并发性 在多线程环境中ConcurrentSkipListMap 提供了高效的并发性能适用于高并发读写的场景。
4、支持导航操作 ConcurrentSkipListMap 实现了 ConcurrentNavigableMap 接口提供了一系列导航方法如 ceilingKey、floorKey 等。
基本用法
1、创建 ConcurrentSkipListMap 对象
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.Map;// 创建一个 ConcurrentSkipListMap
MapString, Integer concurrentSkipListMap new ConcurrentSkipListMap();
2、添加元素
concurrentSkipListMap.put(Key1, 1);
concurrentSkipListMap.put(Key2, 2);
3、获取元素
int value concurrentSkipListMap.get(Key1);
4、删除元素
concurrentSkipListMap.remove(Key2);
5、遍历元素
for (Map.EntryString, Integer entry : concurrentSkipListMap.entrySet()) {System.out.println(Key: entry.getKey() , Value: entry.getValue());
}
6、导航操作
// 获取大于等于给定键的最小键
String ceilingKey concurrentSkipListMap.ceilingKey(Key1);// 获取小于等于给定键的最大键
String floorKey concurrentSkipListMap.floorKey(Key2);
7、其他操作
ConcurrentSkipListMap 还提供了一些其他方法如 higherKey、lowerKey 等用于更复杂的导航操作。
应用场景
1、有序映射 当需要在多线程环境中维护一个有序的键值对集合时ConcurrentSkipListMap 是一个很好的选择。
2、高并发读写 当需要在多线程环境中进行高并发读写操作时ConcurrentSkipListMap 是一个适用的实现。
3、导航操作 当需要进行一些导航操作如查找大于等于给定键的最小键等ConcurrentSkipListMap 提供了相应的方法。
在需要有序、并发安全的键值对集合时ConcurrentSkipListMap 提供了一种高效的实现。
CopyOnWriteArrayList
CopyOnWriteArrayList 是 Java 集合框架中的一个线程安全的 List 实现它通过在修改操作时创建底层数组的副本来实现线程安全。这个副本用于写操作而读操作仍然在原数组上进行。由于读写分离CopyOnWriteArrayList 在读多写少的场景中具有较好的性能。以下是关于 CopyOnWriteArrayList 的介绍和使用方法
特点和优势
1、线程安全性 CopyOnWriteArrayList 是线程安全的支持并发读写操作。
2、写时复制 在写操作时CopyOnWriteArrayList 会创建底层数组的副本因此写操作不会影响正在进行的读操作。
3、适用于读多写少 由于读写分离的特性CopyOnWriteArrayList 在读多写少的场景中性能较好。
基本用法
1、创建 CopyOnWriteArrayList 对象
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;// 创建一个 CopyOnWriteArrayList
ListString copyOnWriteArrayList new CopyOnWriteArrayList();
2、添加元素
copyOnWriteArrayList.add(Element1);
copyOnWriteArrayList.add(Element2);
3、获取元素
String element copyOnWriteArrayList.get(0);
4、删除元素
copyOnWriteArrayList.remove(Element1);
5、遍历元素
for (String element : copyOnWriteArrayList) {System.out.println(element);
}
6、其他操作
CopyOnWriteArrayList 还提供了一些其他方法如 addAll、clear 等用于更复杂的操作。
应用场景
1、读多写少 CopyOnWriteArrayList 适用于读多写少的场景其中写操作的频率较低。
2、读写分离 当需要在多线程环境中同时进行读写操作时CopyOnWriteArrayList 提供了一种简单而有效的线程安全解决方案。
3、不要求实时更新 由于写操作并不会立即影响到正在进行的读操作适用于不要求实时更新的场景。
在使用 CopyOnWriteArrayList 时需要注意它的一些特性如写时复制带来的内存开销以及读取时可能看到过时的数据。因此选择是否使用 CopyOnWriteArrayList 取决于具体的应用场景和需求。
CopyOnWriteArraySet
CopyOnWriteArraySet 是 Java 集合框架中的一个线程安全的 Set 实现它是通过使用 CopyOnWriteArrayList 来实现的。它保证了在迭代过程中不会抛出 ConcurrentModificationException 异常因为写操作会在新的副本上进行而读操作则在原有的集合上进行。以下是关于 CopyOnWriteArraySet 的介绍和使用方法
特点和优势
1、线程安全性 CopyOnWriteArraySet 是线程安全的支持并发读写操作。
2、写时复制 在写操作时CopyOnWriteArraySet 会创建底层数组的副本因此写操作不会影响正在进行的读操作。
3、不抛异常 在迭代过程中即使集合发生了修改也不会抛出 ConcurrentModificationException 异常。
基本用法
1、创建 CopyOnWriteArraySet 对象
for (String element : copyOnWriteArraySet) {System.out.println(element);
}
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;// 创建一个 CopyOnWriteArraySet
SetString copyOnWriteArraySet new CopyOnWriteArraySet();
2、添加元素
copyOnWriteArraySet.add(Element1);
copyOnWriteArraySet.add(Element2);
3、删除元素
copyOnWriteArraySet.remove(Element1);
4、遍历元素
for (String element : copyOnWriteArraySet) {System.out.println(element);
}
5、获取集合大小
int size copyOnWriteArraySet.size();
6、其他操作
CopyOnWriteArraySet 还提供了一些其他方法如 addAll、clear 等用于更复杂的操作。
应用场景
1、读多写少 CopyOnWriteArraySet 适用于读多写少的场景其中写操作的频率较低。
2、读写分离 当需要在多线程环境中同时进行读写操作时CopyOnWriteArraySet 提供了一种简单而有效的线程安全解决方案。
3、不抛异常的迭代 如果需要在迭代过程中不抛出 ConcurrentModificationException 异常可以考虑使用 CopyOnWriteArraySet。
在实际使用时需要根据业务需求和性能要求来选择合适的集合类型。
8、其他:
BitSet
BitSet 是 Java 集合框架中的一种用于位操作的集合类。它以位为单位表示集合中的元素可以有效地存储和操作大量的位信息。主要用于处理一系列的开关状态或者标记。以下是关于 BitSet 的介绍和使用方法
创建 BitSet 对象
import java.util.BitSet;// 创建一个 BitSet默认大小为64位
BitSet bitSet new BitSet();
基本操作
1、设置位
bitSet.set(2); // 将索引2处的位设置为true
2、清除位
bitSet.clear(5); // 将索引5处的位设置为false
3、获取位状态
boolean isSet bitSet.get(3); // 获取索引3处的位状态
4、翻转位
bitSet.flip(4); // 翻转索引4处的位即从true变为false或从false变为true
5、获取位数位的总数
int numberOfBits bitSet.size(); // 获取位的总数
6、获取设置为true的位数
int numberOfSetBits bitSet.cardinality(); // 获取设置为true的位数
7、按位与、按位或、按位异或等位运算
BitSet anotherBitSet new BitSet();
anotherBitSet.set(2);// 按位与
bitSet.and(anotherBitSet);// 按位或
bitSet.or(anotherBitSet);// 按位异或
bitSet.xor(anotherBitSet);
8、其他操作
BitSet 还提供了许多其他的位操作方法如 andNot、nextSetBit、nextClearBit 等。
应用场景
1、位图索引 BitSet 可以用于实现位图索引用于快速查找某个元素是否存在。
2、标记状态 用于标记某个状态的开关例如网络端口的占用状态、任务完成状态等。
3、压缩存储 在一些特定场景下BitSet 可以用于压缩存储大量的布尔型信息。
示例
import java.util.BitSet;public class BitSetExample {public static void main(String[] args) {BitSet bitSet new BitSet();// 设置位bitSet.set(1);bitSet.set(3);// 获取位状态System.out.println(bitSet.get(1)); // 输出 trueSystem.out.println(bitSet.get(2)); // 输出 false// 翻转位bitSet.flip(2);System.out.println(bitSet.get(2)); // 输出 true// 获取位数System.out.println(bitSet.size()); // 输出 64// 获取设置为true的位数System.out.println(bitSet.cardinality()); // 输出 3}
}
BitSet 是一个用于位操作的强大工具特别适用于需要高效存储和操作大量位信息的场景。在使用时根据具体的需求选择合适的位操作方法。
Properties
Properties 类是 Java 集合框架中的一个特殊的类用于处理属性文件。它继承自 Hashtable 类因此具备了 Hashtable 的一些特性但主要用于管理键值对形式的配置信息。以下是关于 Properties 的介绍和使用方法
创建 Properties 对象
import java.util.Properties;// 创建一个 Properties 对象
Properties properties new Properties();
添加和获取属性
1、添加属性
// 添加属性
properties.setProperty(key1, value1);
properties.setProperty(key2, value2);
2、获取属性
// 获取属性值
String value properties.getProperty(key1);
System.out.println(value); // 输出 value1
3、读取和写入属性文件
从文件读取属性
import java.io.FileInputStream;
import java.io.IOException;// 从文件读取属性
try (FileInputStream input new FileInputStream(config.properties)) {properties.load(input);
} catch (IOException e) {e.printStackTrace();
}
将属性写入文件
import java.io.FileOutputStream;
import java.io.IOException;// 将属性写入文件
try (FileOutputStream output new FileOutputStream(config.properties)) {properties.store(output, This is a comment);
} catch (IOException e) {e.printStackTrace();
}
4、默认值
// 获取属性值如果属性不存在返回默认值
String value properties.getProperty(key3, default);
System.out.println(value); // 输出 default
5、遍历属性
// 遍历所有属性
for (String key : properties.stringPropertyNames()) {String value properties.getProperty(key);System.out.println(key : value);
}
6、应用场景
1、配置文件管理 主要用于读取和写入配置文件存储应用程序的配置信息。
2、国际化 在国际化中可以使用 Properties 存储不同语言的文本。
3、属性映射 用于管理键值对形式的属性类似于字典。
Properties 类是处理配置文件和属性映射的便捷工具在许多 Java 应用程序中广泛用于管理配置信息。
这些集合类提供了各种不同的数据结构和性能特性以满足不同的需求。根据你的具体需求和使用情境你可以选择适当的集合类来存储和管理数据。
