java8新特性学习笔记

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/leixingbang1989/article/details/82180128

java8新特性

Lambda表达式

主要作用:

  • 函数作为参数传入

  • 参数不需要声明类型

    package com.lei.java8;
    ​
    /**
     * Created by leixingbang on 2018/8/28.
     * Mail:leixingbang@qiyi.com
     * 示例为将一个方法作为参数传入
     */
    public class Java8Tester {
        public static void main(String[] args) {
            Java8Tester tester = new Java8Tester();
            //Lambda表达式需要声明类型
            MathOperation addMathOperation=(int a,int b)->{return  a+b;};
            //Lambda表达式,不需要输入类型
            MathOperation addMathOperation2=( a, b)->{return  a+b;};
    ​
            //将方法作为参数传入
            System.out.println(tester.operate(3, 4, addMathOperation));
        }
    ​
        /**
         * 定义接口
         */
        interface MathOperation {
            int operation(int a, int b);
        }
    ​
        private int operate(int a, int b, MathOperation mathOperation) {
            return mathOperation.operation(a, b);
        }
    }
    ​
    
            

函数式接口

函数式接口必须要有个抽象方法的声明,接口必须有且只有一个。

/**
 * 函数式接口必须要有抽象方法声明(@FunctionalInterface)
 * @FunctionalInterface该声明的作用是接口【有且只有一个方法】,
 * 如果定义了第二个方法。编译器会抛出异常
 * 只要包含【一个】抽象方法的接口,都可以做成lambda表达式。
 * @param <F>
 * @param <T>
 */
@FunctionalInterface
public interface Converter<F,T>{
    T convert(F from);
​
    public static void main(String[] args) {
        Converter<String,Integer>converter=(from)->Integer.valueOf(from);
        Integer value=converter.convert("111111");
        System.out.println(value);
        //下面为对类的静态方法进行引用
        Converter<String,Integer>cv2=Integer::valueOf;
        System.out.println(cv2.convert("321"));
        Something st=new Something();
        //对对象的方法进行引用[]
        Converter<String,String>stConverter=st::startsWith;
        System.out.println(stConverter.convert("abcde"));
    }
}

Streams

代表了元素的序列,在元素序列上可以进行各种操作。

/**
 * Created by leixingbang on 2018/8/28.
 * Mail:leixingbang@qiyi.com
 * java.util.Stream表示了元素的序列,在元素上可以进行各种操作。
 * Stream可以是中间操作,也可以是完结操作。中间操作会返回流对象本身
 */
public class FilterTest {
    public void main(String[] args) {
        List<String> lst=new ArrayList<>();
        lst.add("aaaa");
        lst.add("abc");
        lst.add("ffffffffff");
        lst.add("ddddfaaa");
        /**
         *(1) lst泛型的定义 String指定了其类型,使得编译器能够识别的类型
         *(2) filter对Stream中的元素进行过滤。取的所需要的数据
         *(3) sorted对元素进行过滤
         *(4) map对数据进行映射,将数据转化为对应类型(示例中为将其转化为student类型)
         */
        lst.stream().filter(s->s.startsWith("a")).map(student::new).sorted().forEach(h -> System.out.println(h.getName() + "---" + h.getAge()));
        lst.stream().filter(s->s.startsWith("a")).map(s -> {
            return new student(s);
        }).sorted().forEach(h -> System.out.println(h.getName() + "---" + h.getAge()));
    }
    class  student{
        private String name;
        private int age;
​
        public int getAge() {
            return age;
        }
​
        public void setAge(int age) {
            this.age = age;
        }
​
        public student(String name) {
            this.name = name;
        }
​
        public String getName() {
            return name;
        }
​
        public void setName(String name) {
            this.name = name;
        }
    }

 

展开阅读全文

没有更多推荐了,返回首页