以下是一些常见的 Java 数据类型和常用方法
数组（Array）
创建数组：int[] arr = new int[10];
获取数组长度：arr.length
遍历数组：for (int i = 0; i < arr.length; i++) {} 或 for (int num : arr) {}
列表（List）
创建列表：List<String> list = new ArrayList<>();
添加元素：list.add("item");
获取元素：list.get(index);
获取列表大小：list.size();
判断是否为空：list.isEmpty();
哈希映射（Map）
创建映射：Map<String, Integer> map = new HashMap<>();
添加键值对：map.put("key", 1);
获取值：map.get("key");
判断键是否存在：map.containsKey("key");
获取默认值：map.getOrDefault("key", defaultValue);
获取所有值：map.values();
字符串（String）
转换为字符数组：str.toCharArray();
排序字符数组：Arrays.sort(char[] array);
将字符数组转换为字符串：new String(char[] array);
获取字符串长度：str.length();
常用工具类
Arrays
Arrays 类位于 java.util 包中，提供了对数组的各种操作方法，如排序、填充等。 在使用前，需要导入该类：
import java.util.Arrays;public class ArraysExample {public static void main(String[] args) {int[] numbers = {5, 2, 8, 1, 3};Arrays.sort(numbers); // 对数组进行排序System.out.println(Arrays.toString(numbers)); // 输出：[1, 2, 3, 5, 8]}
}Arrays 类位于 java.util 包中，提供了多种静态方法来操作数组。常用方法包括：
Arrays.sort(T[] a)：对数组进行升序排序。
int[] numbers = {5, 2, 8, 1, 3};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers)); // 输出：[1, 2, 3, 5, 8]
Arrays.toString(T[] a)：将数组转换为字符串表示。
int[] numbers = {1, 2, 3};
System.out.println(Arrays.toString(numbers)); // 输出：[1, 2, 3]
Arrays.fill(T[] a, T val)：将数组的所有元素设置为指定值。
int[] numbers = new int[5];
Arrays.fill(numbers, 10);
System.out.println(Arrays.toString(numbers)); // 输出：[10, 10, 10, 10, 10]
Arrays.copyOf(T[] original, int newLength)：复制数组，返回一个新数组。
int[] original = {1, 2, 3};
int[] copy = Arrays.copyOf(original, 5);
System.out.println(Arrays.toString(copy)); // 输出：[1, 2, 3, 0, 0]
Arrays.asList(T... a)：将数组转换为列表。
String[] array = {"a", "b", "c"};
List<String> list = Arrays.asList(array);
System.out.println(list); // 输出：[a, b, c]
ArrayList
ArrayList 是 List 接口的实现类，位于 java.util 包中，提供了动态数组的功能。 在使用前，需要导入该类：
import java.util.ArrayList;
import java.util.List;public class ArrayListExample {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");System.out.println(list); // 输出：[Apple, Banana, Cherry]}
}ArrayList 是一个可变大小的数组实现，位于 java.util 包中，常用方法包括：
add(E e)：在列表末尾添加元素。
List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");
System.out.println(list); // 输出：[Hello, World]
add(int index, E element)：在指定位置插入元素。
list.add(1, "Java");
System.out.println(list); // 输出：[Hello, Java, World]
get(int index)：获取指定位置的元素。
String element = list.get(1);
System.out.println(element); // 输出：Java
remove(int index)：删除指定位置的元素。
list.remove(1);
System.out.println(list); // 输出：[Hello, World]
size()：获取列表的大小。
int size = list.size();
System.out.println(size); // 输出：2
contains(Object o)：检查列表是否包含指定元素。
boolean contains = list.contains("Hello");
System.out.println(contains); // 输出：true
clear()：清空列表中的所有元素。
boolean contains = list.contains("Hello");
System.out.println(contains); // 输出：trueHashMap
HashMap 是 Map 接口的实现类，位于 java.util 包中，提供了键值对映射的功能。 在使用前，需要导入该类：
import java.util.HashMap;
import java.util.Map;public class HashMapExample {public static void main(String[] args) {Map<String, Integer> map = new HashMap<>();map.put("Apple", 1);map.put("Banana", 2);map.put("Cherry", 3);System.out.println(map); // 输出：{Apple=1, Banana=2, Cherry=3}}
}HashMap 是一个基于哈希表的 Map 实现，位于 java.util 包中，常用方法包括：
put(K key, V value)：将键值对添加到映射中。
Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
System.out.println(map); // 输出：{Apple=1, Banana=2}
get(Object key)：获取指定键对应的值。
int value = map.get("Apple");
System.out.println(value); // 输出：1
remove(Object key)：删除指定键的键值对。
map.remove("Apple");
System.out.println(map); // 输出：{Banana=2}
containsKey(Object key)：检查映射中是否包含指定的键。
boolean contains = map.containsKey("Banana");
System.out.println(contains); // 输出：true
containsValue(Object value)：检查映射中是否包含指定的值。
boolean contains = map.containsValue(2);
System.out.println(contains); // 输出：true
size()：获取映射中的键值对数量。
int size = map.size();
System.out.println(size); // 输出：1
putIfAbsent(K key, V value)：如果指定的键尚未映射到值，则将其插入到映射中。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.putIfAbsent("apple", 2); // "apple" 已存在，值不会被覆盖
System.out.println(map.get("apple")); // 输出：1
remove(Object key, Object value)：仅当指定键映射到的值与给定值相等时，才删除该键值对。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
boolean removed = map.remove("apple", 1); // 返回 true，表示成功删除
System.out.println(removed); // 输出：true
replace(K key, V value)：仅当指定键已存在时，才替换其映射的值。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.replace("apple", 2); // "apple" 已存在，值被替换
System.out.println(map.get("apple")); // 输出：2
replace(K key, V oldValue, V newValue)：仅当指定键映射到的值与给定的旧值相等时，才替换为新值。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
boolean replaced = map.replace("apple", 1, 2); // 返回 true，表示成功替换
System.out.println(replaced); // 输出：true
compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)：如果指定键已存在，则根据给定函数更新其映射的值；如果键不存在，则插入键值对。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.compute("apple", (key, value) -> value == null ? 1 : value + 1);
System.out.println(map.get("apple")); // 输出：2
computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)：如果指定键尚未映射到值，则使用给定函数计算其值并插入。
Map<String, Integer> map = new HashMap<>();
map.computeIfAbsent("apple", key -> 1);
System.out.println(map.get("apple")); // 输出：1
computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)：如果指定键已映射到值，则根据给定函数更新其映射的值。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.computeIfPresent("apple", (key, value) -> value + 1);
System.out.println(map.get("apple")); // 输出：2
forEach(BiConsumer<? super K,? super V> action)：对映射中的每个键值对执行给定的操作。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
map.forEach((key, value) -> System.out.println(key + ": " + value));
// 输出：
// apple: 1
// banana: 2
keySet()：返回映射中所有键的集合视图。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
Set<String> keys = map.keySet();
System.out.println(keys); // 输出：[apple, banana]
values()：返回映射中所有值的集合视图。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
Collection<Integer> values = map.values();
System.out.println(values); // 输出：[1, 2]
entrySet()：返回映射中所有键值对的集合视图。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for (Map.Entry<String, Integer> entry : entries) {System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 输出：
// apple: 1
// banana: 2
isEmpty()：判断映射是否为空。
Map<String, Integer> map = new HashMap<>();
System.out.println(map.isEmpty()); // 输出：true
map.put("apple", 1);
System.out.println(map.isEmpty()); // 输出：false
clear()：删除映射中的所有键值对。
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
map
