Java8新特性-2

package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Function<T, R> {
    //将Function对象应用到输入的参数上，然后返回计算结果。
    R apply(T t);
    //将两个Function整合，并返回一个能够执行两个Function对象功能的Function对象。
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    // 
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Supplier<Person> personSupplier = Person::new;
personSupplier.get();   // new Person

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker")); // Hello luke

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2);             // > 0
comparator.reversed().compare(p1, p2);  // < 0

方法的持有者::方法名称

// 例子一
Converter<String, Integer> converter = Integer::valueOf; // 静态方法引用
Integer converted = converter.convert("123");
System.out.println(converted.getClass());

/**
 * @author Shier 2023/2/19 22:46
 */
public class ConstructReferences {
    public static void main(String[] args) {
        Something something = new Something();
        Converter<String, String> converter = something::startsWith; // 对象方法的引用
        String converted = converter.convert("Java");
        System.out.println(converted);    // "J"
    }
}
class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0)); // 
    }
}

类名::new

class Person {
    String name;
    String age;
    Person() {}
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

interface PersonFactory<P extends Person> {
    P create(String name, int age);
}

public class ConstructReferences {
    public static void main(String[] args) {
        PersonFactory<Person> personFactory = Person::new;
        personFactory.add("shier", 19);
    }
}

/**
 * @author Shier
 */
public class OptionalExample {
    public static void main(String[] args) {
        // 返回一个非空的Optional对象，为空则会出现NPE异常
        Optional<String> optional1 = Optional.of("hello");
        // 返回一个包含指定对象的Optional对象，为空则返回Optional对象
        Optional<String> optional2 = Optional.ofNullable(null);
        // 判断Optional实例对象是否为空
        System.out.println(optional1.isPresent()); // true
        System.out.println(optional2.isPresent()); // false
        // 包含非空对象则返回非空对象，否则就是NPE
        System.out.println(optional1.get()); // hell
        System.out.println(optional2.orElse("world")); // world
        // 非空则进行转换，返回的是一个转换后的Optional对象
        Optional<String> optional3 = optional1.map(s -> s.toUpperCase());
        System.out.println(optional3.get()); // HELLO
        // 如果包含非空对象，则对其进行转换并返回转换结果
        Optional<Integer> optional4 = optional1.flatMap(s -> Optional.of(s.length()));
        System.out.println(optional4.get()); // 5
    }
}

List<String> stringList = new ArrayList<>();
stringList.add("ddd2");
stringList.add("aaa2");
stringList.add("bbb1");
stringList.add("aaa1");
stringList.add("bbb3");
stringList.add("ccc");
stringList.add("bbb2");
stringList.add("ddd1");

// 测试 Filter(过滤)
stringList
        .stream()
        .filter((s) -> s.startsWith("a"))// 以a开头的
        .forEach(System.out::println);//aaa2 aaa1 使用了函数式接口中方法的引用
stringList.stream().filter((str) -> str.endsWith("1")).forEach(System.out::println);// bbb1 aaa1 ddd1

      // 排序
        stringList.stream().sorted()
                .filter((s) -> s.startsWith("a"))// 以a开头的
                .forEach(System.out::println); //aaa1 aaa2 使用了函数式接口中方法的引用
        System.out.println("Sorted倒序排序:");
        stringList.stream().sorted((a, b) -> b.compareTo(a))
                .filter((s) -> s.startsWith("a"))
                .forEach(System.out::println); //aaa2 aaa1

// 测试映射
stringList.stream().map(s -> s.toUpperCase()).sorted().forEach(System.out::println);
stringList.stream().map(String::toUpperCase).sorted().forEach(System.out::println);

List<Integer> numbers1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
boolean hasEven1 = numbers1.stream().allMatch(n -> n % 2 == 0);
System.out.println("number1: " + hasEven1); // true

 List<Integer> numbers1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 List<Integer> numbers2 = Arrays.asList(1, 3, 5, 7, 9);
 boolean hasEven1 = numbers1.stream().noneMatch(n -> n % 2 == 0);
 boolean hasEven2 = numbers2.stream().noneMatch(n -> n % 2 == 0);
 System.out.println("number1: " + hasEven1); // false
 System.out.println("number2: " + hasEven2); // true

// 测试计数 Count 操作
long count = stringList.stream().filter(s -> s.startsWith("a")).count();
System.out.println(count); // 2

// 规约
Optional<String> reduce = stringList.stream().sorted().reduce((a, b) -> a + "-" + b);
System.out.println(reduce);

int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}

/**
 * @author Shier 2023/2/20 14:19
 */
public class ParallelStreamTest {
    public static void main(String[] args) {
        int max = 1000000;
        List<String> values = new ArrayList<>(max);
        for (int i = 0; i < max; i++) {
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }
        // 串行排序
        long startTime = System.currentTimeMillis();
        long count = values.stream().sorted().count();
        long endTime = System.currentTimeMillis();
        System.out.println("串行执行时间：" + (endTime - startTime) + "ms"); // 665ms
        // 并行排序
        long startParallelTime = System.currentTimeMillis();
        long count2 = values.parallelStream().sorted().count();
        long endParallelTime = System.currentTimeMillis();
        System.out.println("并行执行时间：" + (endParallelTime - startParallelTime) + "ms"); // 332ms
    }
}

/**
 * 定义一个容器注解类Authors
 */
public @interface Authors {
    Author[] value();
}

/**
 * @author Shier 2023/2/20 14:39
 * 使用容器注解类的注解@Repeatable说明是可重复的
 */
@Repeatable(Authors.class)
public @interface Author {
    String name();
}

/**
 * 第一种写完整的
 * 在使用容器注解来声明值，最外层的为复数形式的注解类，也就是第一个步骤创建的类，里面的Author是第二步创建的可重复的注解类
 */
@Authors({
        @Author(name = "shier"),
        @Author(name = "小十二"),
})
public class Article {}
/**
 * 第二种简单写法
 */
@Author(name = "shier")
@Author(name = "小十二")
public class Article {}