Java常用API

String

String s = "abc";

s.equals("abc"); // 比较
s.contains("ab"); // 包含
s.indexOf("c"); // 索引
s.charAt(0); // 按索引取值

s.startsWith("a"); // 以什么开头
s.endsWith("z"); // 以什么结尾

s.substring(2); // 提取子串
s.substring(2, 4);

s.trim(); // 去掉首位空白字符

s.isEmpty(); // 字符串长度为0
s.isBlank(); // 是否只包含空白字符

s.replace("b", "xyz"); // 替换子串

s.split(","); // 用逗号分割字符串, 得到字符数组

String[] arr = {"x", "y", "z"};
String.join(",", arr); // 用指定的字符串拼接字符数组

// 格式化字符串
String.format("Hello %s, your score is %.2f", "Tom", 95.5);

// 类型转换
String.valueOf(123); // "123"
String.valueOf(true); // "true"

字符串 - 字符数组 转换

char[] arr = "hello".toCharArray(); // 字符串转为字符数组
String s = new String(arr); // 字符数组转为字符串

Integer等包装类

自动拆箱 :vs: 自动装箱

Integer n = Integer.valueOf(100);
Integer n = 100; // 自动装箱

int x = n.intValue();
int x = n; // 自动拆箱

int/Integer - String 类型转换

// 字符串转为int
int x = Integer.parseInt("123"); // 123
Integer n = Intege.valueOf("123"); // 内部调用Integer.parseInt()

// int转为字符串
Integer.toString(123);
n.toString();

Arrays

Arrays.equals(arr1, arr2); // 比较两个数组是否相等
Arrays.sort(array); // 为数组排序
Arrays.stream(array); // 转换成对应的流
Arrays.asList(1, 2, 3); // 转换成对应的List， List<Integer>
Arrays.toString({1, 2, 3}); // 转换成对应的字符串， string.toCharArray()
Arrays.copyOf(array, 20); // 复制

Collections

Collections.sort(list);
Collections.sort(list, comparator);

Collections.shuffle(list); // 洗牌

Collections.reverse(); // 翻转

Stream

// 创建
Stream.of("a", "b", "c", "d");
IntStream.of(1, 2, 3, 4, 5);

Arrays.stream(new String[]{"a", "b", "c"});
Arrays.asList("a", "b", "c").stream();

Stream<Integer> stream = Stream.generate(supplier); // 基于Supplier接口

// map
IntStream.of(1, 2, 3, 4, 5).map(n -> n * n).sum();
Arrays.asList(" Apple", " pear", "ORANGE ", "BaNaNa").stream().map(String::trim).map(String::toLowerCase).forEach(System.out::println);

// filter
IntStream.of(1, 2, 3, 4, 5, 6, 7).filter(n -> n % 2 != 0).forEach(System.out::println);

// reduce 聚合， 会对stream进行计算，需要初始值；如果没有初始值，得到Optional对象
Stream.of(1, 2, 3, 4, 5).reduce(0, Integer::sum);
Stream.of(1, 2, 3, 4, 5).reduce(1, (acc, n) -> acc * n);
// 综合应用
List<String> props = Arrays.asList("profile=native", "debug=true", "logging=warning", "interval=500");
Map<String, String> map = props.stream()
    .map(kv -> {
        String[] ss = kv.split("\\=", 2);
        Map<String, String> aMap = new HashMap<>();
        aMap.put(ss[0], ss[1]);
        return aMap;
        // return Map.of(ss[0], ss[1]); // JDK9
    })
    .reduce(new HashMap<String, String>(), (m, kv) -> {
        m.putAll(kv);
        return m;
    });
map.forEach((k, v) -> System.out.println(k + " = " + v));

// 转成集合
Stream.of("Apple", "", "banana", null, " ", "Orange").filter(s -> s != null && !s.isEmpty()).collect(Collectors.toList()); // 转成List
Stream.of("Apple", "", "banana", null, " ", "Orange").filter(s -> s != null && s.isEmpty()).toArray(String[]::new); // 转成数组
Arrays.asList("profile=native", "debug=true", "logging=warning", "interval=500").stream().collect(Collectors.toMap(
                        s -> s.substring(0, s.indexOf("=")), // 指定如何将元素映射为key
                        s -> s.substring(s.indexOf("=") + 1) // 指定如何将元素映射为value
                )); // 转成Map

// 分组 .collect(Collectors.groupBy(分组依据，分组后处理方法))
List<Student> students = Arrays.asList(
                new Student("alan", 1, 100),
                new Student("bran", 1, 90),
                new Student("carl", 2, 95),
                new Student("david", 2, 85),
                new Student("erik", 3, 94),
                new Student("frank", 3, 86));
Map<Integer, List<Student>> studentMap = students.stream().collect(
    Collectors.groupingBy(Student::getClassId, Collectors.toList()));
studentMap.forEach((k, v) -> {
    System.out.println("Class: " + k);
    System.out.println("Students: ");
    v.forEach(System.out::println);
});

// sorted 要求比较的元素实现comparable接口，或自定义排序方法，或传入comparator实例
Stream.of("orange", "Banana", "apple").sorted().forEach(System.out::println);
// 自定义比较方法
Stream.of("orange", "Banana", "apple").sorted(String::compareToIgnoreCase).forEach(System.out::println);
// distinct 去重
Stream.of("A", "A", "B", "B", "c").distinct().forEach(System.out::println);
// skip, limit
Stream.of("A", "B", "A", "B", "c").skip(1).limit(2).forEach(System.out::println);
// concat 合并
Stream<String> stream = Stream.of("A", "B", "c");
Stream<String> stream1 = Stream.of("x", "Y", "z");
Stream.concat(stream, stream1).forEach(System.out::println);
// parallel 并行处理
// count
// max
// min
// allMatch
// anyMatch
// forEach
// flatMap

Math

Math.abs(-100); // 绝对值
Math.max(12, 11);
Math.min(1, 2);

Math.pow(2, 10); // 2的10次方
Math.sqrt(2);
Math.exp(2); // e的2次方
Math.log(4); // 以e为底的对数

Math.sin(3.14);
Math.cos(90);

// 常量
Math.PI;
Math.E;

// 随机数 0 <= x <= 1
Math.random();

Random

Random r = new Random();
r.nextInt();
r.nextInt(10); // 生成一个[0, 10)之间的int
r.nextDouble();

日期时间

Json

Commons

BeanUtils.copyProperties(teacher, teacherForm); // 两个bean间复制属性

Optional

Optional 类主要解决的问题是臭名昭著的空指针异常（NullPointerException）

理解、学习与使用 Java 中的 Optional - 张伯雨 - 博客园 (cnblogs.com)

// 创建Optional对象
Optional.empty(); // 创建空对象
Optional.of();
Optional.ofNullable();
Optional<User> opt1 = Optional.of(user);
Optional<User> opt2 = Optional.ofNullable(user); // user可以为null
Optional.ofNullable(name).orElse("foobar"); // 空的时候使用默认值

// 检查值是否为空
opt2.isPresent();
opt2.ifPresent(user -> user.getEmail()); // 当user不为空的时候才执行里面的方法

// 从Optional对象中取值
opt.get();
Optional.ofNullable(name).orElse("foobar"); // 为空的时候返回默认值
Optional.ofNullable(user).orElse(user2);

Optional.ofNullable(name).orElseGet(() -> return "foobar"); // 有值的时候返回值，没有的时候，执行orElseGet里面的方法，提供默认值

// 转换
Optional.ofNullable(user).map(u -> u.getEmail()).orElse("xxx@example.com");

// 过滤
Optional.ofNullable(user).filter(u -> u.getEmail() != null);

// 链式调用
Optional.ofNullable(user).flatMap(u -> u.getAddress()).flatMap(a -> a.getCountry()).map(c -> c.getIsoCode()).orElse("default");

hutools

Spring.Utils

org.springframework.beans.BeanUtils;