Java 8新特性

1、接口里面不仅可以有抽象方法,还可以有默认方法

\quad 默认方法需使用default关键字修饰。接口中除了可以定义抽象方法,还可以定义静态常量和静态方法,java8以后还可以定义默认方法。接口中方法都是public的,故而可以省略public不写。如下例子:

public interface Formula {
    // 静态常量
    static final String s  = "Hello";
    // 静态方法
    static void say(){
        System.out.println("Hello");
    }
    // 抽象方法
    double calculate(int a);
    // 默认方法,Java8以后有
    default double sqrt(int a){
        return Math.sqrt(a);
    }
}
public class Main {
    public static void main(String[] args) {
        System.out.println(Formula.s);  // Hello
        Formula.say();  // Hello
        Formula formula = new Formula() {
            @Override
            public double calculate(int a) {
                return a * 2;
            }
        };
        System.out.println(formula.calculate(4));  // 8
        System.out.println(formula.sqrt(4));  // 2
    }
}

2、lambda表达式

什么是函数式接口?

\quad 如果一个接口中只有一个抽象方法(可以有多个默认方法),则这个方法可以完整地代表这个接口,这样的接口称为函数式接口。函数式接口(Functional Interface)就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为 lambda 表达式。
\quad 上面给出的接口Formula就只有一个抽象方法,因此是函数式接口,可以用lambda表达式简化。
\quad lambda表达式语法:(参数列表) -> {方法体}。注意:参数类型可以省略;如果方法体只有一句话,大括号可以不写,并省略return。如果参数只有一个,则可以省略括号。

public class lambdaTest {
    public static void main(String[] args) {
        Formula formula1 = new Formula() {
            @Override
            public double calculate(int a) {
                return a * 2;
            }
        };
        System.out.println(formula1.calculate(4));

        Formula formula2 = (int a) -> { return a * 2; };
        System.out.println(formula2.calculate(4));

        Formula formula3 = a -> {return a * 2;};
        System.out.println(formula3.calculate(4));

        Formula formula4 = a -> a * 2;
        System.out.println(formula4.calculate(4));
    }
}

排序场景中重写Comparator

public class test1 {
    public static void sort1(){
        List<Integer> arr = new ArrayList<>();
        arr.add(1); arr.add(3); arr.add(2);
        // 正常实现比较函数接口
        Collections.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(arr);
    }
    public static void sort2(){
        List<Integer> arr = new ArrayList<>();
        arr.add(1); arr.add(3); arr.add(2);
        // 使用标准得lambda表示进行简化 (参数列表)->{方法体}
        Collections.sort(arr, (Integer o1, Integer o2)->{return o2-o1;});
        System.out.println(arr);
    }

    public static void sort3(){
        List<Integer> arr = new ArrayList<>();
        arr.add(1); arr.add(3); arr.add(2);
        // 若方法体只有return语句则可以省略{}和return
        Collections.sort(arr, (Integer o1, Integer o2)->o2 - o1);
        System.out.println(arr);
    }

    public static void sort4(){
        List<Integer> arr = new ArrayList<>();
        arr.add(1); arr.add(3); arr.add(2);
        // 可以省略参数类型
        Collections.sort(arr, (o1, o2)->o2 - o1);
        System.out.println(arr);
    }
    
    public static void main(String[] args) {
        sort1();
        sort2();
        sort3();
        sort4();
    }
}

3、流式数据stream处理

\quad 看一下示例代码就行,很简单。

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 4, 8, 16, 1, 2);
        // 将list中每个元素减去1 并返回
        List<Integer> res = list.stream().map(item -> item - 1).collect(Collectors.toList());
        System.out.println(res);

        // 将list中小于5的数据打印出来
        list.stream().filter(item -> item < 5).forEach(item -> System.out.println(item));

        // 将list中数据降序排列,并输出
        list.stream().sorted((a, b) -> b - a).forEach(item -> System.out.println(item));

        // 输出list中元素范围在4-8范围内数个个数
        long count = list.stream().filter(item -> item >= 4 && item <= 8).count();
        System.out.println(count);

        // 输出list去重后的列表
        List<Integer> collect = list.stream().distinct().collect(Collectors.toList());
        System.out.println(collect);
    }
}

4、并行流

使用普通stream

public class ParrelStream {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        for(int i = 0; i < 10000000; i ++ ){
            nums.add(i);
        }
        long begin = System.currentTimeMillis();
        List<Integer> collect = nums.stream().sorted().collect(Collectors.toList());
        long end = System.currentTimeMillis();
        long time = end - begin;
        System.out.println("stream cost time: " + time);
    }
}

使用并行stream

public class ParrelStream {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        for(int i = 0; i < 10000000; i ++ ){
            nums.add(i);
        }
        long begin = System.currentTimeMillis();
        List<Integer> collect = nums.parallelStream().sorted().collect(Collectors.toList());
        long end = System.currentTimeMillis();
        long time = end - begin;
        System.out.println("stream cost time: " + time);
    }
}
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页