java8新特性

java8新特性：

lamda表达式

方法引用

函数式接口

stream

Optional

public interface StringFun {

    String operation(String s);
}

public class StringReverse {

    public static String reverse(String s) {
        String s1 = "";
        for (int i = s.length() - 1; i >= 0; i--) {
            s1 += s.charAt(i);
        }
        return s1;
    }

    public String reverse1(String s) {
        String s1 = "";
        for (int i = s.length() - 1; i >= 0; i--) {
            s1 += s.charAt(i);
        }
        return s1;
    }

    public boolean isOddNum(int i) {
        return i % 2 == 0 ? false : true;
    }
}

public class java8Test {
    public String reverseString(StringFun stringFun, String s) {
        return stringFun.operation(s);
    }

    public String reverseString1(StringReverse stringReverse, String s) {
        return stringReverse.reverse1(s);
    }

    public boolean isOddNum(Predicate<Integer> predicate, Integer i) {
        return predicate.test(i);
    }

    public static void main(String[] args) {

        //lambda表达式
        List<String> names = new ArrayList<>();
        names.add("xiaoming");
        names.add("bonnie");
        names.add("wanghong");

        //java7排序
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        names.stream().forEach(name -> {
            System.out.println(name);
        });

        //java8排序
        Collections.sort(names, ((o1, o2) -> {
            return o2.compareTo(o1);
        }));
        names.stream().forEach(name -> {
            System.out.println(name);
        });

        java8Test test = new java8Test();
        StringReverse stringReverse = new StringReverse();

        System.out.println(test.reverseString((s -> {
            return s + "d";
        }), "abc"));

        //方法引用
        //引用某个类型的方法
        Collections.sort(names, String::compareTo);
        names.stream().forEach(name -> {
            System.out.println("方法引用" + name);
        });

        //引用静态方法
        String s = "abc";
        System.out.println(test.reverseString(StringReverse::reverse, s));

        //特定实例对象的方法引用
        System.out.println(test.reverseString(stringReverse::reverse1, s));

        //构造方法引用
        //语法：类名::new
        Supplier<StringReverse> stringSupplier = StringReverse::new;
        System.out.println(test.reverseString1(stringSupplier.get(), s));//stringSupplier.get()的值为StringRerverse实例

        //函数式接口：有且仅有一个抽象方法，但可以有多个非抽象的方法。函数式接口可以应用在lamda表达式和方法引用上
        //java.util.function中包含很多函数式接口，比如Predicate<T>接口是一个函数式接口，它接收一个参数T，返回一个布尔值
        //函数式接口应用于lamda表达式
        System.out.println(test.isOddNum(integer -> {
            if (integer % 2 == 0) {
                return false;
            }
            return true;
        }, 20));

        //函数式接口应用于方法引用(特定实例对象的方法引用)
        System.out.println(test.isOddNum(stringReverse::isOddNum, 31));

        //默认实现方法：在接口的非抽象方法前边加default关键字

        //stream流：对数组或者集合进行聚合操作（filter,map,reduce,find,match,sorted）。中间操作会返回流对象本身。
        //filter
        List<String> list = Arrays.asList("a", "", "b");
        list.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

        //forEach
        list.stream().forEach(System.out::println);
        list.stream().forEach(ss -> {
            System.out.println(ss + "1");
        });

        //map方法用于映射每个元素到对应的方法
        list.stream().map(s1->s1+s1).collect(Collectors.toList());

        //limit方法用于获取指定数量的流
        Random random=new Random();
        random.ints().limit(5).forEach(System.out::println);

        //sorted方法用于排序
        list.stream().sorted().collect(Collectors.toList());

        //Collectors实现了很多归约操作，如将流转换成集合和聚合元素
        list.stream().sorted().collect(Collectors.toList());
        System.out.println(list.stream().sorted().collect(Collectors.joining(",")));

        //产生统计结果的收集器如IntSummaryStatistics
        List<Integer> integers=Arrays.asList(3,2,5);
        IntSummaryStatistics summaryStatistics=integers.stream().mapToInt(x->x).summaryStatistics();
        System.out.println("最大值："+summaryStatistics.getMax());
        System.out.println("最小值："+summaryStatistics.getMin());
        System.out.println("平均值："+summaryStatistics.getAverage());
        System.out.println("之和："+summaryStatistics.getSum());

        //Optional类是一个可以为空的容器对象，解决了空指针异常的问题
        //ofNullable方法：如果不为空，则返回Optional描述的值，如果为空返回空的Optional
        Integer a=null;
        Integer b=new Integer(10);
        System.out.println(b+Optional.ofNullable(a).orElse(new Integer(2)));
        Optional.ofNullable(a).orElseThrow(NullPointerException::new);
        
    }
}