java 基础

基础数据类型，方法，类，异常处理：Java 零基础入门学习（小白也能看懂！）_java零基础自学-CSDN博客

List

在Java中，List 接口是集合框架中非常重要的一个接口，它提供了存储和操作有序集合的方法。List 是一个接口，因此不能直接实例化，但可以通过其实现类（如 ArrayList, LinkedList, Vector 等）来使用。

List 接口的主要实现类

• ArrayList: 动态数组实现，适用于随机访问和迭代，对于频繁的增删操作效率较低。
• LinkedList: 双向链表实现，适用于频繁的增删操作，但对于随机访问效率较低。
• Vector: 与 ArrayList 类似，但 Vector 是线程同步的，适合多线程环境。
• CopyOnWriteArrayList: 线程安全的 List 实现，适用于读多写少的场景。

创建 List

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

public class ListExample {
    public static void main(String[] args) {
        // 创建一个空的 ArrayList
        List<String> names = new ArrayList<>();
        
        // 或者创建一个带有初始容量的 ArrayList
        List<String> namesWithInitialCapacity = new ArrayList<>(10);
        
        // 创建一个包含初始元素的 ArrayList
        List<String> initialNames = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
    }
}

添加元素

names.add("David");
names.add(1, "Eve"); // 在索引 1 处插入 "Eve"

获取元素

String firstElement = names.get(0); // 获取第一个元素 通过索引

删除元素

names.remove("David"); // 移除值为 "David" 的元素
names.remove(0); // 移除索引为 0 的元素

遍历 List

// 使用 for-each 循环
for (String name : names) {
    System.out.println(name);
}

// 使用传统的 for 循环
for (int i = 0; i < names.size(); i++) {
    System.out.println(names.get(i));
}

// 使用 Java 8 的 Stream API
names.stream().forEach(System.out::println);

查找元素

int index = names.indexOf("Charlie"); // 查找 "Charlie" 的索引位置
boolean contains = names.contains("Charlie"); // 判断是否包含 "Charlie"

替换元素

names.set(0, "Alex"); // 将索引 0 处的元素替换为 "Alex"

排序

Collections.sort(names); // 自然排序（对于 String，按字母顺序）
Collections.sort(names, Comparator.reverseOrder()); // 逆序排序

示例代码

下面是一个完整的示例代码，演示了如何使用 ArrayList：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("David");
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        
        // 输出原始列表
        System.out.println("Original list: " + names);
        
        // 在索引 1 处插入 "Eve"
        names.add(1, "Eve");
        
        // 查找 "Charlie" 的索引位置
        int index = names.indexOf("Charlie");
        System.out.println("Index of Charlie: " + index);
        
        // 判断是否包含 "Charlie"
        boolean contains = names.contains("Charlie");
        System.out.println("Contains Charlie: " + contains);
        
        // 替换索引 0 处的元素
        names.set(0, "Alex");
        
        // 自然排序
        Collections.sort(names);
        System.out.println("Sorted list: " + names);
        
        // 逆序排序
        Collections.sort(names, Comparator.reverseOrder());
        System.out.println("Reverse sorted list: " + names);
        
        // 移除 "Alex"
        names.remove("Alex");
        
        // 遍历列表
        System.out.println("Final list:");
        for (String name : names) {
            System.out.println(name);
        }
    }
}

总结
List 接口提供了丰富的操作方法，可以根据具体需求选择合适的实现类。ArrayList 适用于需要快速随机访问的场景，而 LinkedList 更适合需要频繁插入和删除元素的场景。通过上面的示例，你应该能够理解和使用 List 接口及其常见实现类。 

Map

在Java中，Map 接口是集合框架中的一个重要组成部分，用于存储键值对（key-value pairs）。Map 接口本身不能直接实例化，但可以通过其不同的实现类来使用。下面详细介绍几种常用的 Map 实现类及其基本操作。

主要的 Map 实现类

• HashMap: 最常用的 Map 实现类，提供了良好的性能，允许 null 键和 null 值，但不是线程安全的。
• LinkedHashMap: 保持了插入顺序，适合需要按照插入顺序或访问顺序进行遍历的情况。
• TreeMap: 按照键的自然顺序或自定义比较器进行排序，适合需要有序的键值对。
• ConcurrentHashMap: 线程安全的 Map 实现，适用于多线程环境，性能较好。
• WeakHashMap: 使用弱引用作为键，适合用于缓存场景，当没有强引用指向键时，键会被垃圾回收。

创建 Map 

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

public class MapExample {
    public static void main(String[] args) {
        // 创建一个空的 HashMap
        Map<String, Integer> scores = new HashMap<>();
        
    }
}

添加元素

scores.put("David", 95);
scores.put("Eve", 88);

获取元素

Integer score = scores.get("David"); // 获取 "David" 的分数
Integer scoreOrDefault = scores.getOrDefault("David", 0); // 如果不存在则返回默认值 0

删除元素

scores.remove("David"); // 移除键为 "David" 的元素

更新元素

scores.remove("David"); // 移除键为 "David" 的元素

检查元素

boolean containsKey = scores.containsKey("David"); // 是否包含键 "David"
boolean containsValue = scores.containsValue(92); // 是否包含值 92

遍历 Map

// 使用 for-each 循环遍历键
for (String key : scores.keySet()) {
    System.out.println(key + ": " + scores.get(key));
}

// 使用 for-each 循环遍历键值对
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 使用 Java 8 的 Stream API
scores.forEach((key, value) -> System.out.println(key + ": " + value));

示例代码

下面是一个完整的示例代码，演示了如何使用 HashMap：

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> scores = new HashMap<>();
        
        // 添加元素
        scores.put("Alice", 100);
        scores.put("Bob", 90);
        scores.put("Charlie", 85);
        
        // 输出原始 Map
        System.out.println("Original map: " + scores);
        
        // 更新元素
        scores.put("Charlie", 90);
        
        // 删除元素
        scores.remove("Bob");
        
        // 检查元素
        boolean containsKey = scores.containsKey("Charlie");
        System.out.println("Contains key 'Charlie': " + containsKey);
        
        // 获取元素
        Integer score = scores.get("Alice");
        System.out.println("Score of Alice: " + score);
        
        // 遍历 Map
        System.out.println("Final map:");
        for (Map.Entry<String, Integer> entry : scores.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

总结
Map 接口提供了丰富的操作方法，可以根据具体需求选择合适的实现类。HashMap 适用于大多数场景，而 LinkedHashMap 和 TreeMap 分别用于保持插入顺序或进行排序。ConcurrentHashMap 适用于多线程环境，WeakHashMap 适用于缓存场景。通过上面的示例，你应该能够理解和使用 Map 接口及其常见实现类。