在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); // 15Integer 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);