Java字符串、集合、Collectors类、Optional类常用方法

Java中的String类提供了丰富的方法来处理文本数据。以下是一些常用的字符串方法及其示例：

检查和搜索

length(): 返回字符串的长度。

  String text = "Hello world!";
  System.out.println(text.length()); // 12

contains(CharSequence s): 判断字符串是否包含指定的字符序列。

  String text = "Hello world!";
  System.out.println(text.contains("world")); // true

startsWith(String prefix): 判断字符串是否以指定的前缀开始。

  String text = "Hello world!";
  System.out.println(text.startsWith("Hello")); // true

endsWith(String suffix): 判断字符串是否以指定的后缀结束。

  String text = "Hello world!";
  System.out.println(text.endsWith("!")); // true

indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引。

  String text = "Hello world!";
  System.out.println(text.indexOf('o')); // 4

lastIndexOf(int ch): 返回指定字符在字符串中最后一次出现处的索引。

  String text = "Hello world!";
  System.out.println(text.lastIndexOf('o')); // 7

修改和替换

replace(CharSequence target, CharSequence replacement): 返回一个新的字符串，它是通过用replacement替换此字符串中出现的所有target得到的。

  String text = "Hello world!";
  String newText = text.replace("world", "everyone");
  System.out.println(newText); // "Hello everyone!"

toUpperCase(): 将字符串中的所有字符转换为大写。

  String text = "Hello world!";
  System.out.println(text.toUpperCase()); // "HELLO WORLD!"

toLowerCase(): 将字符串中的所有字符转换为小写。

  String text = "Hello World!";
  System.out.println(text.toLowerCase()); // "hello world!"

trim(): 返回字符串的副本，忽略前导空白和尾部空白。

  String text = "  Hello world!  ";
  System.out.println(text.trim()); // "Hello world!"

分割和连接

split(String regex): 根据给定正则表达式的匹配拆分此字符串。

  String text = "Hello world!";
  String[] words = text.split(" ");
  System.out.println(Arrays.toString(words)); // [Hello, world!]

substring(int beginIndex, int endIndex): 返回一个新的字符串，它是此字符串的一个子字符串。

  String text = "Hello world!";
  System.out.println(text.substring(0, 5)); // "Hello"

其他

equals(Object anObject): 将此字符串与指定的对象比较。

  String text1 = "Hello";
  String text2 = "Hello";
  System.out.println(text1.equals(text2)); // true

equalsIgnoreCase(String anotherString): 将此String与另一个String比较，忽略大小写考虑。

  String text1 = "hello";
  String text2 = "HELLO";
  System.out.println(text1.equalsIgnoreCase(text2)); // true

charAt(int index): 返回指定索引处的char值。

  String text = "Hello world!";
  System.out.println(text.charAt(0)); // 'H'

compareTo(String anotherString): 按字典顺序比较两个字符串。

  String text1 = "Hello";
  String text2 = "World";
  System.out.println(text1.compareTo(text2)); // 负数，text1字典顺序在text2之前

集合（Collection）

Java中的集合（Collection）框架主要包括List、Set和Map接口及其实现类，提供了一系列用于存储和操作对象组的方法。以下是一些常用的集合操作方法及示例：

List（列表）

List接口的实现类（如ArrayList、LinkedList等）提供了有序的集合操作。常用方法包括：

add(E e): 添加元素到列表末尾。

  List<String> list = new ArrayList<>();
  list.add("Apple");
  list.add("Banana");

get(int index): 返回列表中指定位置的元素。

  String item = list.get(0); // "Apple"

remove(int index): 移除列表中指定位置的元素。

  list.remove(1); // 移除"Banana"

size(): 返回列表中的元素数。

  int size = list.size(); // 1

Set（集合）

Set接口的实现类（如HashSet、LinkedHashSet、TreeSet等）提供了不允许重复元素的集合操作。常用方法包括：

add(E e): 添加元素到集合中。如果集合已包含该元素，则不添加。

  Set<String> set = new HashSet<>();
  set.add("Apple");
  set.add("Banana");
  set.add("Apple"); // 不会添加，因为"Apple"已存在

remove(Object o): 移除集合中的指定元素。

  set.remove("Banana");

contains(Object o): 如果集合包含指定的元素，则返回true。

  boolean hasApple = set.contains("Apple"); // true

size(): 返回集合中的元素数。

  int size = set.size(); // 1

Map（映射）

Map接口的实现类（如HashMap、LinkedHashMap、TreeMap等）提供了键值对的集合操作。常用方法包括：

put(K key, V value): 将指定的值与此映射中的指定键关联。

  Map<String, Integer> map = new HashMap<>();
  map.put("Apple", 10);
  map.put("Banana", 20);

get(Object key): 返回指定键所映射的值。

  int value = map.get("Apple"); // 10

remove(Object key): 移除指定键的映射关系。

  map.remove("Banana");

containsKey(Object key): 如果此映射包含指定键的映射关系，则返回true。

  boolean hasApple = map.containsKey("Apple"); // true

keySet(): 返回此映射中包含的键的Set视图。

  Set<String> keys = map.keySet(); // 包含所有键的Set

values(): 返回此映射中包含的值的Collection视图。

  Collection<Integer> values = map.values(); // 包含所有值的Collection

集合遍历

Java中集合的遍历方式多样，适用于不同类型的集合（如List、Set、Map等）。以下是一些常用的遍历方式及示例：

使用for循环遍历List

对于List集合，可以使用传统的for循环通过索引访问每个元素。

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

使用增强for循环遍历List和Set

增强for循环（也称为"for-each循环"）是遍历集合和数组的简洁方式。

for (String fruit : list) {
    System.out.println(fruit);
}

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Cherry");

for (String fruit : set) {
    System.out.println(fruit);
}

使用Iterator遍历List和Set

Iterator接口提供了遍历集合元素的方法。它可以用于List、Set等所有Collection接口的实现类。

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String fruit = iterator.next();
    System.out.println(fruit);
}

Iterator<String> setIterator = set.iterator();
while (setIterator.hasNext()) {
    String fruit = setIterator.next();
    System.out.println(fruit);
}

使用Stream API遍历List和Set（Java 8+）

Java 8引入的Stream API提供了一种高效且表达性强的方式来处理集合。

list.stream().forEach(System.out::println);
set.stream().forEach(System.out::println);

遍历Map

对于Map集合，可以遍历键集、值集或键值对。

• 遍历键集：

  Map<String, Integer> map = new HashMap<>();
  map.put("Apple", 10);
  map.put("Banana", 20);
  map.put("Cherry", 30);
  
  for (String key : map.keySet()) {
      System.out.println(key);
  }
  

• 遍历值集：

  for (Integer value : map.values()) {
      System.out.println(value);
  }
  

• 遍历键值对：

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

• 使用Java 8的forEach遍历Map：

  map.forEach((key, value) -> System.out.println(key + ": " + value));
  

Collectors类

Collectors类是Java 8引入的一个实用工具类，位于java.util.stream包中。它主要用于提供了一系列的静态方法，用于生成常见的收集器实例。这些收集器可以与Stream的collect()方法一起使用，以便对流中的元素进行各种汇总操作。以下是一些Collectors类中最常用的方法：

• toList()
  将流中的所有元素收集到一个List中。

List<String> list = stream.collect(Collectors.toList());

• toSet()
  将流中的所有元素收集到一个Set中，自动去重。

Set<String> set = stream.collect(Collectors.toSet());

• toMap()
  将流中的元素收集到一个Map中。需要提供两个函数：一个用于生成键，另一个用于生成值。

Map<Integer, String> map = stream.collect(Collectors.toMap(Item::getId, Item::getName));

• joining()
  连接流中的每个字符串元素，可以提供分隔符、前缀和后缀。

String result = stream.collect(Collectors.joining(", ", "[", "]"));

• groupingBy()
  根据某个属性对流中的元素进行分组，结果是一个Map，其中键是分组的属性，值是符合该分组的元素列表。

Map<Category, List<Item>> groupedByCategory = stream.collect(Collectors.groupingBy(Item::getCategory));

• partitioningBy()
  根据一个布尔表达式将流分成两部分，结果是一个Map<Boolean, List>，true键对应的是满足条件的元素列表，false键对应的是不满足条件的元素列表。

Map<Boolean, List<Item>> partitioned = stream.collect(Collectors.partitioningBy(item -> item.getPrice() > 100));

• counting()
  计算流中元素的数量。

long count = stream.collect(Collectors.counting());

• summarizingInt(), summarizingDouble(), summarizingLong()
  生成包含流中元素的统计信息，如总数、总和、最小值、平均值和最大值。

IntSummaryStatistics stats = stream.collect(Collectors.summarizingInt(Item::getPrice));

• reducing()
  基于流中元素进行归约操作，可以有多种形式，允许提供一个起始值，一个二元操作符，以及一个可选的转换函数。

int sum = stream.collect(Collectors.reducing(0, Item::getPrice, Integer::sum));

Optional

Optional 是 Java 8 引入的一个容器类，用于表示一个值存在或不存在。它提供了一种更好的方式来处理null，避免直接使用null引发的NullPointerException。以下是Optional类中一些最常用的方法：

• of(T value)
  创建一个包含非null值的Optional实例。如果value为null，则立即抛出NullPointerException。

Optional<String> optional = Optional.of("Hello");

• ofNullable(T value)
  创建一个Optional实例，如果value为null，则创建一个空的Optional对象。

Optional<String> optional = Optional.ofNullable(null);

• empty()
  获取一个空的Optional实例。

Optional<String> optional = Optional.empty();

• isPresent()
  如果存在值，则返回true，否则返回false

if (optional.isPresent()) {
    // 值存在
}

• ifPresent(Consumer<? super T> consumer)
  如果值存在，就执行给定的操作

optional.ifPresent(System.out::println);

• orElse(T other)
  如果存在值，则返回该值，否则返回一个默认值。

String value = optional.orElse("Default Value");

• orElseGet(Supplier<? extends T> supplier)
  如果存在值，则返回该值，否则返回由Supplier接口实现提供的值。

String value = optional.orElseGet(() -> "Default Value");

• orElseThrow(Supplier<? extends X> exceptionSupplier)
  如果存在值，则返回该值，否则抛出由Supplier接口实现提供的异常。

String value = optional.orElseThrow(IllegalStateException::new);

• map(Function<? super T, ? extends U> mapper)
  如果存在值，则对该值执行给定的映射函数。

Optional<Integer> length = optional.map(String::length);

• flatMap(Function<? super T, Optional> mapper)
  如果存在值，就应用提供的Optional-承载的映射函数，否则返回一个空的Optional。

Optional<Integer> length = optional.flatMap(s -> Optional.of(s.length()));

• filter(Predicate<? super T> predicate)
  如果存在值并且满足给定的谓词，则返回包含该值的Optional；否则返回一个空的Optional。

Optional<String> result = optional.filter(s -> s.length() > 5);

实际应用

修改前：

if (Objects.nonNull(param.getUsrId())) {
		String userName = userMap.get(param.getUsrId());
		param.setUsrName(userName);
	}

修改后：

Optional.ofNullable(param.getUsrId())
					.map(userMap::get)
					.ifPresent(param::setUsrName);

1. Optional.ofNullable(param.getUsrId())：首先，通过调用param.getUsrId()获取用户代码（usrId）。Optional.ofNullable方法用于创建一个Optional实例，如果usrId为null，则创建一个空的Optional对象；如果usrId不为null，则创建一个包含usrId的Optional对象。

2. .map(userMap::get)：然后，如果Optional对象不为空（即usrId不为null），则应用映射函数userMap::get。这个函数尝试从userMap中获取与usrId对应的值。userMap可能是一个映射，其中键是用户代码，值是用户名称。如果usrId在userMap中有对应的值，则map操作会返回一个包含该值的新Optional对象；如果没有找到对应的值，返回一个空的Optional对象。

3. .ifPresent(param::setUsrName)：最后，如果映射函数的结果（即userMap.get(usrId)的返回值）存在（不是空的Optional），则执行给定的操作param::setUsrName。这里，param::setUsrName是一个方法引用，它接受一个参数（用户名称）并将其设置为param对象的usrId属性。这个步骤确保了只有当usrId在userMap中有对应的用户名称时，才会更新param对象的usrName属性。

​ 这段代码安全地从一个映射中查找用户Id对应的用户名称，并将其设置到param对象的属性中，同时避免了因usrId可能为null或在映射中找不到对应值而导致的NullPointerException。