在Java/Android中，List的属性和方法

1. List接口的基本信息

List是一个有序的集合（也称为序列），允许重复元素，可以通过索引访问元素。主要实现类：ArrayList

2. List的核心方法

添加元素

List<String> list = new ArrayList<>();

// 添加元素到末尾
boolean added = list.add("Apple"); // 返回true

// 在指定位置插入元素
list.add(1, "Banana"); // 在索引1位置插入

// 添加所有元素
List<String> fruits = Arrays.asList("Orange", "Grape");
boolean allAdded = list.addAll(fruits); // 添加集合中的所有元素

// 在指定位置添加集合
list.addAll(0, fruits); // 在开头添加

删除元素

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));

// 按元素删除
boolean removed = list.remove("B"); // 返回true

// 按索引删除
String removedElement = list.remove(0); // 返回被删除的元素"A"

// 删除所有元素
list.clear();

// 删除指定集合中的所有元素
list.removeAll(Arrays.asList("C", "D"));

// 保留指定集合中的元素（删除其他）
list.retainAll(Arrays.asList("A", "B"));

查询和访问

List<String> list = Arrays.asList("Apple", "Banana", "Orange", "Apple");

// 获取元素
String element = list.get(1); // "Banana"

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

// 检查是否为空
boolean isEmpty = list.isEmpty();

// 检查是否包含元素
boolean contains = list.contains("Apple"); // true

// 查找元素索引
int firstIndex = list.indexOf("Apple"); // 0
int lastIndex = list.lastIndexOf("Apple"); // 3

// 检查是否包含集合中的所有元素
boolean containsAll = list.containsAll(Arrays.asList("Apple", "Banana"));

修改元素

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

// 修改指定位置的元素
String oldElement = list.set(1, "NewB"); // 返回旧元素"B"

遍历操作

List<String> list = Arrays.asList("A", "B", "C", "D");

// 1. for循环
for (int i = 0; i < list.size(); i++) {
    System.out.println("索引 " + i + ": " + list.get(i));
}

// 2. 增强for循环
for (String item : list) {
    System.out.println("元素: " + item);
}
List<String> result1 = list.stream()
    .filter(s -> s.length() > 5)    // 中间操作
    .collect(Collectors.toList());  // 必须加终端操作

List<String> result2 = list.stream()
    .map(String::toUpperCase)       // 中间操作  
    .collect(Collectors.toList());  // 必须加终端操作

3. Java 8+ 新增的Stream方法

list.stream() 是 Java 8 引入的 Stream API 的核心功能，它允许你以声明式的方式处理集合数据，支持函数式编程风格的操作。

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");

// 创建Stream并执行操作
List<String> result = list.stream()           // 创建Stream
    .filter(s -> s.length() > 5)              // 中间操作
    .map(String::toUpperCase)                 // 中间操作
    .collect(Collectors.toList());            // 终端操作

收集 collect

List<String> result = list.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());
    
List<String> result1 = list.stream()
   .filter(s -> s.length() > 5)    // 中间操作
   .collect(Collectors.toList());  // 必须加终端操作

遍历和消费 forEach() / forEachOrdered()

List<String> list = Arrays.asList("a", "b", "c");

// forEach - 遍历元素（不保证顺序）
list.stream().forEach(System.out::println);

// forEachOrdered - 保证顺序遍历（在并行流中重要）
list.parallelStream()
    .forEachOrdered(System.out::println); // 保证输出顺序 a, b, c

匹配检查 allMatch() / anyMatch() / noneMatch()

List<Integer> numbers = Arrays.asList(2, 4, 6, 8, 10);
List<String> words = Arrays.asList("apple", "banana", "cherry");

// allMatch - 所有元素都满足条件
boolean allEven = numbers.stream().allMatch(n -> n % 2 == 0); // true
boolean allLong = words.stream().allMatch(s -> s.length() > 5); // false

// anyMatch - 至少一个元素满足条件
boolean anyEven = numbers.stream().anyMatch(n -> n % 2 == 0); // true
boolean containsA = words.stream().anyMatch(s -> s.contains("a")); // true

// noneMatch - 没有元素满足条件
boolean noneOdd = numbers.stream().noneMatch(n -> n % 2 != 0); // true
boolean noneShort = words.stream().noneMatch(s -> s.length() < 3); // true

查找元素 findFirst() / findAny()

List<String> list = Arrays.asList("a", "b", "c", "d");

// findFirst - 返回第一个元素
Optional<String> first = list.stream()
    .filter(s -> s.startsWith("b"))
    .findFirst(); // Optional["b"]

// findAny - 返回任意元素（在并行流中效率更高）
Optional<String> any = list.parallelStream()
    .filter(s -> s.length() == 1)
    .findAny(); // 可能是 "a", "b", "c", "d" 中的任意一个

聚合计算 count() / min() / max()

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<String> words = Arrays.asList("apple", "banana", "cherry");

// count - 计数
long count = numbers.stream().count(); // 5
long filteredCount = numbers.stream()
    .filter(n -> n > 3)
    .count(); // 2

// min - 最小值
Optional<Integer> min = numbers.stream().min(Integer::compareTo); // Optional[1]
Optional<String> shortestWord = words.stream()
    .min(Comparator.comparing(String::length)); // Optional["apple"]

// max - 最大值
Optional<Integer> max = numbers.stream().max(Integer::compareTo); // Optional[5]
Optional<String> longestWord = words.stream()
    .max(Comparator.comparing(String::length)); // Optional["banana"]

// 实际应用
List<Order> orders = getOrders();
Optional<Order> mostExpensive = orders.stream()
    .max(Comparator.comparing(Order::getTotalAmount));

long highValueOrders = orders.stream()
    .filter(order -> order.getTotalAmount() > 1000)
    .count();

归约操作 reduce()

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 1. 最基本的reduce - 需要起始值和累加器
Integer sum = numbers.stream()
    .reduce(0, (a, b) -> a + b); // 15

Integer product = numbers.stream()
    .reduce(1, (a, b) -> a * b); // 120

// 2. 没有起始值的reduce - 返回Optional
Optional<Integer> sumOpt = numbers.stream()
    .reduce(Integer::sum); // Optional[15]

// 3. 复杂的reduce - 用于不同类型转换
String concatenated = numbers.stream()
    .reduce("", 
        (str, num) -> str + num,  // 累加器
        (str1, str2) -> str1 + str2 // 组合器（并行流使用）
    ); // "12345"

// 实际应用：复杂计算
List<BigDecimal> prices = Arrays.asList(
    new BigDecimal("19.99"),
    new BigDecimal("29.99"),
    new BigDecimal("9.99")
);

BigDecimal total = prices.stream()
    .reduce(BigDecimal.ZERO, BigDecimal::add); // 59.97

// 查找最长字符串
List<String> strings = Arrays.asList("a", "bb", "ccc");
Optional<String> longest = strings.stream()
    .reduce((s1, s2) -> s1.length() >= s2.length() ? s1 : s2);

数组转换 toArray()

List<String> list = Arrays.asList("a", "b", "c");

// 转换为Object数组
Object[] objectArray = list.stream().toArray();

// 转换为特定类型数组
String[] stringArray = list.stream().toArray(String[]::new);

// 带过滤和转换的数组
Integer[] numbers = list.stream()
    .map(String::length)
    .toArray(Integer[]::new);

// 实际应用
List<User> users = getUsers();
String[] userNames = users.stream()
    .map(User::getName)
    .filter(name -> name != null)
    .toArray(String[]::new);