java 数组 集合 使用技巧

java 集合 的子类的区别，分别在什么场景下使用

在Java中，集合框架提供了多个实现了不同接口的集合类。这些集合类分为两个主要的接口：List 和 Set，以及一个继承自 Map 的接口。

1. List 接口的主要子类：

• ArrayList：

  • 使用数组实现，支持快速随机访问。
  • 适合读取操作较多的场景，但不适合大量的插入、删除操作。

• LinkedList：

  • 使用双向链表实现，对于频繁的插入、删除操作性能较好。
  • 适合在中间插入、删除元素的场景，但不适合大量随机访问。

• Vector：

  • 是线程安全的，但性能相对较差，较少在现代Java开发中使用。

使用场景：

• 使用 ArrayList：当需要快速随机访问元素，读取操作较多的情况下。
• 使用 LinkedList：当需要频繁执行中间插入、删除操作，而不关心随机访问的性能。

2. Set 接口的主要子类：

• HashSet：

  • 使用哈希表实现，元素无序。
  • 适合快速查找元素，但不关心元素的顺序。

• LinkedHashSet：

  • 使用哈希表和链表实现，元素按插入顺序排序。
  • 适合需要保持插入顺序的场景。

• TreeSet：

  • 使用红黑树实现，元素按照自然顺序或指定的比较器排序。
  • 适合需要有序集合的场景。

使用场景：

• 使用 HashSet：当只关心元素的唯一性，而不关心顺序。
• 使用 LinkedHashSet：当需要保持插入顺序的唯一性元素集合。
• 使用 TreeSet：当需要有序的唯一性元素集合。

3. Map 接口的主要子类：

• HashMap：

  • 使用哈希表实现，键值对无序。
  • 适合快速查找键值对，但不关心顺序。

• LinkedHashMap：

  • 使用哈希表和链表实现，键值对按插入顺序排序。
  • 适合需要保持插入顺序的键值对集合。

• TreeMap：

  • 使用红黑树实现，键值对按照键的自然顺序或指定的比较器排序。
  • 适合需要有序键值对的场景。

使用场景：

• 使用 HashMap：当只关心键值对的唯一性，而不关心顺序。
• 使用 LinkedHashMap：当需要保持插入顺序的唯一性键值对集合。
• 使用 TreeMap：当需要有序的唯一性键值对集合。

综合考虑使用场景、性能需求和功能需求，选择适合的集合子类。

java 集合各种并发类 请提供示例代码

Java 提供了一些并发集合类，这些类通常用于在多线程环境中安全地操作集合。以下是一些常见的并发集合类及其示例代码：

1. ConcurrentHashMap：

ConcurrentHashMap 是线程安全的哈希表实现，适合在高并发环境中使用。

import java.util.concurrent.ConcurrentHashMap;

// 创建 ConcurrentHashMap
ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();

// 添加键值对
concurrentHashMap.put("Apple", 10);
concurrentHashMap.put("Banana", 5);

// 替换值
concurrentHashMap.replace("Apple", 15);

// 遍历 ConcurrentHashMap
concurrentHashMap.forEach((key, value) -> System.out.println(key + ": " + value));

2. CopyOnWriteArrayList：

CopyOnWriteArrayList 是一个线程安全的动态数组，适合在读操作远远多于写操作的场景。

import java.util.concurrent.CopyOnWriteArrayList;

// 创建 CopyOnWriteArrayList
CopyOnWriteArrayList<String> copyOnWriteArrayList = new CopyOnWriteArrayList<>();

// 添加元素
copyOnWriteArrayList.add("Apple");
copyOnWriteArrayList.add("Banana");

// 遍历 CopyOnWriteArrayList
for (String item : copyOnWriteArrayList) {
    System.out.println(item);
}

3. ConcurrentSkipListMap：

ConcurrentSkipListMap 是线程安全的有序映射表实现，基于跳表（SkipList）数据结构。

import java.util.concurrent.ConcurrentSkipListMap;

// 创建 ConcurrentSkipListMap
ConcurrentSkipListMap<String, Integer> concurrentSkipListMap = new ConcurrentSkipListMap<>();

// 添加键值对
concurrentSkipListMap.put("Apple", 10);
concurrentSkipListMap.put("Banana", 5);

// 获取键值对
int quantity = concurrentSkipListMap.get("Apple");

// 遍历 ConcurrentSkipListMap
concurrentSkipListMap.forEach((key, value) -> System.out.println(key + ": " + value));

4. BlockingQueue：

BlockingQueue 接口及其实现类，如 LinkedBlockingQueue、ArrayBlockingQueue，用于在多线程环境中进行阻塞式队列操作。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

// 创建 LinkedBlockingQueue
BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>();

// 添加元素
blockingQueue.put("Apple");
blockingQueue.put("Banana");

// 获取并移除元素
String item = blockingQueue.take();

// 获取队列大小
int size = blockingQueue.size();

5. ConcurrentLinkedQueue：

ConcurrentLinkedQueue 是线程安全的非阻塞式队列实现。

import java.util.concurrent.ConcurrentLinkedQueue;

// 创建 ConcurrentLinkedQueue
ConcurrentLinkedQueue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();

// 添加元素
concurrentLinkedQueue.add("Apple");
concurrentLinkedQueue.add("Banana");

// 获取并移除元素
String item = concurrentLinkedQueue.poll();

// 获取队列大小
int size = concurrentLinkedQueue.size();

这些是一些常见的并发集合类及其示例代码。在多线程环境中，选择合适的并发集合类能够帮助你更安全地操作共享数据。

java 数组常见用法

在Java中，数组是一种常见的数据结构，它允许你在单个变量名下存储多个相同类型的元素。以下是一些 Java 数组的常见用法：

1. 声明和初始化数组：

// 声明和初始化数组
int[] intArray = new int[5]; // 创建一个包含5个整数的数组

// 直接初始化数组
int[] numbers = {1, 2, 3, 4, 5};
String[] names = {"Alice", "Bob", "Charlie"};

2. 访问数组元素：

// 访问数组元素
int value = intArray[2]; // 获取索引为2的元素值
System.out.println(value); // 输出：0，因为刚刚创建的数组所有元素默认初始化为0

// 修改数组元素
intArray[2] = 42;

3. 数组长度：

// 获取数组长度
int length = intArray.length;
System.out.println("数组长度：" + length);

4. 遍历数组：

// 使用 for 循环遍历数组
for (int i = 0; i < intArray.length; i++) {
    System.out.println(intArray[i]);
}

// 使用增强型 for 循环（for-each）遍历数组
for (int num : numbers) {
    System.out.println(num);
}

5. 多维数组：

// 声明和初始化二维数组
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// 访问二维数组元素
int element = matrix[1][2]; // 获取第二行第三列的元素值

6. 数组工具类：

Java提供了一些数组工具类方法，如Arrays类，可用于对数组进行排序、查找等操作。

import java.util.Arrays;

int[] arr = {4, 2, 7, 1, 9};

// 排序数组
Arrays.sort(arr);

// 在数组中查找元素
int index = Arrays.binarySearch(arr, 7);

7. 动态数组（ArrayList）：

如果需要动态调整数组大小，可以使用 ArrayList 类。

import java.util.ArrayList;

// 创建 ArrayList
ArrayList<Integer> arrayList = new ArrayList<>();

// 添加元素
arrayList.add(10);
arrayList.add(20);

// 获取元素
int element = arrayList.get(0);

8. 数组拷贝：

// 使用 Arrays.copyOf 方法拷贝数组
int[] sourceArray = {1, 2, 3, 4, 5};
int[] destinationArray = Arrays.copyOf(sourceArray, sourceArray.length);

// 使用 System.arraycopy 方法拷贝数组
int[] destArray = new int[sourceArray.length];
System.arraycopy(sourceArray, 0, destArray, 0, sourceArray.length);

这些是 Java 数组的一些基本用法，根据具体需求，你可能会用到更多高级的数组操作。

java ArrayList 常见用法，请提供示例代码

ArrayList 是 Java 中 java.util 包下的动态数组实现，它提供了一种动态调整大小的数组结构。以下是一些常见的 ArrayList 用法及相应的示例代码：

1. 声明和初始化 ArrayList：

import java.util.ArrayList;

// 声明和初始化 ArrayList
ArrayList<String> list = new ArrayList<>();

// 直接初始化 ArrayList
ArrayList<Integer> numbers = new ArrayList<>(List.of(1, 2, 3, 4, 5));

2. 添加和删除元素：

// 添加元素
list.add("Apple");
list.add("Banana");
list.add("Orange");

// 删除元素
list.remove("Banana");

3. 获取元素和遍历：

// 获取元素
String fruit = list.get(0);

// 使用 for-each 遍历 ArrayList
for (String item : list) {
    System.out.println(item);
}

// 使用 Java 8 Stream 遍历 ArrayList
list.forEach(item -> System.out.println(item));

4. 查找元素和判断是否包含：

// 查找元素的索引
int index = list.indexOf("Orange");

// 判断是否包含某元素
boolean contains = list.contains("Apple");

5. 获取 ArrayList 大小：

// 获取 ArrayList 大小
int size = list.size();

6. 清空 ArrayList：

// 清空 ArrayList
list.clear();

7. ArrayList 转为数组：

// ArrayList 转为数组
String[] array = new String[list.size()];
list.toArray(array);

8. ArrayList 排序：

// 对 ArrayList 进行排序
ArrayList<Integer> numbers = new ArrayList<>(List.of(5, 3, 1, 4, 2));
Collections.sort(numbers);

9. ArrayList 复制：

// 复制 ArrayList
ArrayList<String> copyList = new ArrayList<>(list);

10. 判断 ArrayList 是否为空：

// 判断 ArrayList 是否为空
boolean isEmpty = list.isEmpty();

这些是 ArrayList 的一些基本用法。在实际开发中，根据具体业务需求，你可能会使用到更多的方法和操作。请注意，ArrayList 是线程不安全的，如果在多线程环境中使用，应该考虑使用线程安全的替代类，例如 CopyOnWriteArrayList。

java linkedlist常见用法，请提供示例代码

LinkedList 是 Java 中 java.util 包下的双向链表实现，它提供了对列表中元素的快速插入和删除操作。以下是一些常见的 LinkedList 用法及相应的示例代码：

1. 声明和初始化 LinkedList：

import java.util.LinkedList;

// 声明和初始化 LinkedList
LinkedList<String> linkedList = new LinkedList<>();

// 直接初始化 LinkedList
LinkedList<Integer> numbers = new LinkedList<>(List.of(1, 2, 3, 4, 5));

2. 添加和删除元素：

// 在末尾添加元素
linkedList.add("Apple");
linkedList.add("Banana");
linkedList.add("Orange");

// 在指定位置插入元素
linkedList.add(1, "Grapes");

// 在头部添加元素
linkedList.addFirst("Pineapple");

// 删除指定位置的元素
linkedList.remove(2);

// 删除指定元素
linkedList.remove("Banana");

// 删除头部元素
linkedList.removeFirst();

3. 获取元素和遍历：

// 获取头部元素
String firstElement = linkedList.getFirst();

// 使用 for-each 遍历 LinkedList
for (String item : linkedList) {
    System.out.println(item);
}

// 使用迭代器遍历 LinkedList
Iterator<String> iterator = linkedList.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

4. 查找元素和判断是否包含：

// 查找元素的索引
int index = linkedList.indexOf("Orange");

// 判断是否包含某元素
boolean contains = linkedList.contains("Apple");

5. 获取 LinkedList 大小：

// 获取 LinkedList 大小
int size = linkedList.size();

6. 清空 LinkedList：

// 清空 LinkedList
linkedList.clear();

7. LinkedList 转为数组：

// LinkedList 转为数组
String[] array = new String[linkedList.size()];
linkedList.toArray(array);

8. LinkedList 复制：

// 复制 LinkedList
LinkedList<String> copyList = new LinkedList<>(linkedList);

9. 在链表头部和尾部执行操作：

// 在头部添加元素
linkedList.addFirst("Head");

// 在尾部添加元素
linkedList.addLast("Tail");

// 获取头部元素
String headElement = linkedList.getFirst();

// 获取尾部元素
String tailElement = linkedList.getLast();

这些是 LinkedList 的一些基本用法。与 ArrayList 不同，LinkedList 在插入和删除元素方面有更好的性能，但在随机访问元素时性能较差。在实际开发中，根据具体业务需求，你可能会使用到更多的方法和操作。

java set常见用法，请提供示例代码

在Java中，Set 是一个接口，它表示不包含重复元素的集合。常用的实现类包括 HashSet、LinkedHashSet 和 TreeSet。以下是一些常见的 Set 用法及相应的示例代码：

1. HashSet 的基本用法：

import java.util.HashSet;
import java.util.Set;

// 创建 HashSet
Set<String> hashSet = new HashSet<>();

// 添加元素
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Orange");

// 元素不允许重复，添加重复元素不会产生影响
hashSet.add("Apple");

// 遍历 HashSet
for (String item : hashSet) {
    System.out.println(item);
}

// 判断元素是否存在
boolean contains = hashSet.contains("Banana");

2. LinkedHashSet 的基本用法：

LinkedHashSet 继承自 HashSet，它保留了元素插入的顺序。

import java.util.LinkedHashSet;
import java.util.Set;

// 创建 LinkedHashSet
Set<String> linkedHashSet = new LinkedHashSet<>();

// 添加元素
linkedHashSet.add("Apple");
linkedHashSet.add("Banana");
linkedHashSet.add("Orange");

// 遍历 LinkedHashSet，保留元素插入的顺序
for (String item : linkedHashSet) {
    System.out.println(item);
}

3. TreeSet 的基本用法：

TreeSet 是一个基于红黑树的 NavigableSet 实现，元素按照自然顺序或者指定的比较器顺序进行排序。

import java.util.Set;
import java.util.TreeSet;

// 创建 TreeSet
Set<String> treeSet = new TreeSet<>();

// 添加元素
treeSet.add("Apple");
treeSet.add("Banana");
treeSet.add("Orange");

// 遍历 TreeSet，元素按照自然顺序排序
for (String item : treeSet) {
    System.out.println(item);
}

4. 判断 Set 是否为空：

boolean isEmpty = hashSet.isEmpty();

5. 获取 Set 大小：

int size = hashSet.size();

6. 删除元素：

// 删除指定元素
hashSet.remove("Banana");

// 清空 Set
hashSet.clear();

7. Set 转为数组：

String[] array = new String[hashSet.size()];
hashSet.toArray(array);

8. 使用 Set 进行交集、并集和差集操作：

Set<String> set1 = new HashSet<>(List.of("Apple", "Banana", "Orange"));
Set<String> set2 = new HashSet<>(List.of("Banana", "Pineapple", "Grapes"));

// 交集
Set<String> intersection = new HashSet<>(set1);
intersection.retainAll(set2);

// 并集
Set<String> union = new HashSet<>(set1);
union.addAll(set2);

// 差集
Set<String> difference = new HashSet<>(set1);
difference.removeAll(set2);

这些是 Set 接口及其实现类的一些基本用法。在实际开发中，根据具体业务需求，你可能会使用到更多的方法和操作。

java list常见用法，请提供示例代码

在Java中，List 是一个接口，它表示有序、可重复的元素集合。常见的实现类有 ArrayList、LinkedList 和 Vector。以下是一些常见的 List 用法及相应的示例代码：

1. ArrayList 的基本用法：

import java.util.ArrayList;
import java.util.List;

// 创建 ArrayList
List<String> arrayList = new ArrayList<>();

// 添加元素
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Orange");

// 在指定位置插入元素
arrayList.add(1, "Grapes");

// 遍历 ArrayList
for (String item : arrayList) {
    System.out.println(item);
}

// 获取元素
String element = arrayList.get(2);

// 判断元素是否存在
boolean contains = arrayList.contains("Banana");

2. LinkedList 的基本用法：

import java.util.LinkedList;
import java.util.List;

// 创建 LinkedList
List<String> linkedList = new LinkedList<>();

// 添加元素
linkedList.add("Apple");
linkedList.add("Banana");
linkedList.add("Orange");

// 在指定位置插入元素
linkedList.add(1, "Grapes");

// 遍历 LinkedList
for (String item : linkedList) {
    System.out.println(item);
}

// 获取元素
String element = linkedList.get(2);

// 判断元素是否存在
boolean contains = linkedList.contains("Banana");

3. Vector 的基本用法：

Vector 是一个线程安全的动态数组，但在性能上不如 ArrayList。

import java.util.List;
import java.util.Vector;

// 创建 Vector
List<String> vector = new Vector<>();

// 添加元素
vector.add("Apple");
vector.add("Banana");
vector.add("Orange");

// 在指定位置插入元素
vector.add(1, "Grapes");

// 遍历 Vector
for (String item : vector) {
    System.out.println(item);
}

// 获取元素
String element = vector.get(2);

// 判断元素是否存在
boolean contains = vector.contains("Banana");

4. 判断 List 是否为空：

boolean isEmpty = arrayList.isEmpty();

5. 获取 List 大小：

int size = arrayList.size();

6. 删除元素：

// 删除指定位置的元素
arrayList.remove(1);

// 删除指定元素
arrayList.remove("Banana");

// 清空 List
arrayList.clear();

7. List 转为数组：

String[] array = new String[arrayList.size()];
arrayList.toArray(array);

8. 子列表的操作：

List<String> subList = arrayList.subList(1, 3); // 获取索引1到2的子列表

9. 使用 Collections 工具类进行排序：

import java.util.Collections;

// 对 ArrayList 进行排序
List<Integer> numbers = new ArrayList<>(List.of(5, 3, 1, 4, 2));
Collections.sort(numbers);

这些是 List 接口及其实现类的一些基本用法。在实际开发中，根据具体业务需求，你可能会使用到更多的方法和操作。

java map常见用法，请提供示例代码

在Java中，Map 是一个接口，它表示键值对的集合。Map 的常见实现类包括 HashMap、LinkedHashMap、TreeMap 等。以下是一些常见的 Map 用法及相应的示例代码：

1. HashMap 的基本用法：

import java.util.HashMap;
import java.util.Map;

// 创建 HashMap
Map<String, Integer> hashMap = new HashMap<>();

// 添加键值对
hashMap.put("Apple", 10);
hashMap.put("Banana", 5);
hashMap.put("Orange", 8);

// 获取值
int appleQuantity = hashMap.get("Apple");

// 遍历 HashMap
for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 判断键是否存在
boolean containsKey = hashMap.containsKey("Banana");

2. LinkedHashMap 的基本用法：

LinkedHashMap 继承自 HashMap，它保留了插入顺序。

import java.util.LinkedHashMap;
import java.util.Map;

// 创建 LinkedHashMap
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();

// 添加键值对
linkedHashMap.put("Apple", 10);
linkedHashMap.put("Banana", 5);
linkedHashMap.put("Orange", 8);

// 遍历 LinkedHashMap，保留插入顺序
for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

3. TreeMap 的基本用法：

TreeMap 是基于红黑树的 NavigableMap 实现，它按照键的自然顺序或者通过比较器进行排序。

import java.util.Map;
import java.util.TreeMap;

// 创建 TreeMap
Map<String, Integer> treeMap = new TreeMap<>();

// 添加键值对
treeMap.put("Apple", 10);
treeMap.put("Banana", 5);
treeMap.put("Orange", 8);

// 遍历 TreeMap，元素按照自然顺序排序
for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

4. 判断 Map 是否为空：

boolean isEmpty = hashMap.isEmpty();

5. 获取 Map 大小：

int size = hashMap.size();

6. 删除键值对：

// 删除指定键的键值对
hashMap.remove("Banana");

// 清空 Map
hashMap.clear();

7. 获取键集、值集和键值对集合：

// 获取键集
Set<String> keySet = hashMap.keySet();

// 获取值集
Collection<Integer> values = hashMap.values();

// 获取键值对集合
Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();

8. 使用默认值或函数进行操作：

// 获取指定键的值，如果键不存在则返回默认值
int quantity = hashMap.getOrDefault("Grapes", 0);

// 使用 compute 方法更新值
hashMap.compute("Banana", (key, value) -> value + 2);

这些是 Map 接口及其实现类的一些基本用法。在实际开发中，根据具体业务需求，你可能会使用到更多的方法和操作。