Java教程

Java8新特性的使用

本文主要是介绍Java8新特性的使用,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

文章目录

    • 1. Lambda表达式
      • 1.1. 四大基础函数式接口
        • 1.1.1. Function <T,R> 函数接口
        • 1.1.2. Predicate<T> 断言接口
        • 1.1.3. Consumer<T> 消费者接口
        • 1.1.4. Supplier<T> 供应商接口
      • 1.2. 自定义接口方法
    • 2. 函数式参数
    • 3. Stream流运算和链式编程
      • 3.1. map 和 forEach、flatMap
        • 3.1.1. map
        • 3.1.2. forEach
        • 3.1.3. flatMap
      • 3.2. filter
      • 3.3. limit
      • 3.4. sorted
      • 3.5. 综合案例

1. Lambda表达式

在Java8开始引入的语法规则,这个属于基础语法,这个语法可以理解成是一个语法糖,是对匿名内部类的包装实现,这是非常重要的使用,在Java8中许多地方使用了这个特性,这个使用一般不能单独使用,要依靠接口函数来实现,上面说了是匿名内部类的包装实现,这个理解对下面的局部变量的理解的非常重要的。

函数式接口要求这个接口只能有一个必须实现的函数,其他方法要么是默认方法,要么是静态方法,用lambda表达式实现的只会是这个必须实现的函数。

表达式组成由()标识参数的接收参数的口子,用->连接函数体{};这里有一个特性,当入参只有一个参数的时候,()可以省略,例如 a->{return a;};如果函数体只有一行,{}也可以省略,如果还有返回值,修饰词return也可以省略,例如:a-> a。

1.1. 四大基础函数式接口

所在路径:java.util.function

1.1.1. Function <T,R> 函数接口

这个接口是以接收T类型的参数,返回R类型的结果,只接受一个参数

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    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;
    }
}

由上面的源码,可以知道,这个接口的使用需要实现apply方法,原来使用的方式:

public class TestFunction {
    public static void main(String[] args) {
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        };

        System.out.println(function.apply("123"));
    }
}

使用lambda表达式:

public class TestFunction {
    public static void main(String[] args) {
        Function<String, Integer> function = s -> Integer.valueOf(s);
        System.out.println(function.apply("123"));
    }
}

这样大大简化了我们的写法,同时他们是等价的;

1.1.2. Predicate<T> 断言接口

接收一个T类型参数,返回一个布尔型返回值

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

通过源码,这个接口实现的是test函数;

原来的写法:

public class TestPredicate {
    public static void main(String[] args) {
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return StringUtils.isNotBlank(s);
            }
        };
        System.out.println(predicate);
    }
}

使用lambda表达式:

public class TestPredicate {
    public static void main(String[] args) {
        Predicate<String> predicate = s -> StringUtils.isNotBlank(s);
        System.out.println(predicate);
    }
}

这就简化了我们的写法,上下两种是等价的,这个方法可以用来校验。

1.1.3. Consumer<T> 消费者接口

这个接口接收一个T类型的参数,没有返回值:

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

通过上面的源码,要实现的方法是accept.

原来接口的使用:

public class TestConsumer {
    public static void main(String[] args) {
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("测试 consumer");
    }
}

使用lambda表达式:

public class TestConsumer {
    public static void main(String[] args) {
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("测试 consumer");
    }
}

这个消费者接口一般用来处理任务,不用返回值。

1.1.4. Supplier<T> 供应商接口

这是一个无参的接口函数,返回值是T类型。

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

通过源码,这里要实现的是get方法

使用原来的方法来实现:

public class TestSupplier {
    public static void main(String[] args) {
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return String.valueOf(Math.random());
            }
        };
        System.out.println(supplier.get());
    }
}

使用lambda表达式:

public class TestSupplier {
    public static void main(String[] args) {
        Supplier<String> supplier = () -> String.valueOf(Math.random());
        System.out.println(supplier.get());
    }
}

这些就是四个标准接口函数,在学习Java8的时候这些是基础的。

1.2. 自定义接口方法

我们可以根据上面的接口来自己定义自己的函数接口,首先定义一个自定义接口,接口要求有三个泛型,两个参数,一个返回值,效果如下;

@FunctionalInterface
interface CustomizeFunction<T, V, R> {
    R customize(T t, V v);
}

自定义接口的使用:

public class TestCustomize {
    public static void main(String[] args) {
        CustomizeFunction<Integer,Float, BigDecimal> customizeFunction = (t,v)->{
            BigDecimal tt = BigDecimal.valueOf(t);
            BigDecimal vv = BigDecimal.valueOf(v);
            return tt.add(vv).setScale(2, RoundingMode.HALF_UP);
        };

        System.out.println(customizeFunction.customize(2,0.2f));
    }
}

这样就完成了对自定义接口的使用了。

2. 函数式参数

说完了函数式接口,在Java里,可以把这些函数当作参数来传入使用,例如多线的Thread类的使用,例子如下:

public static void main(String[] args) {
    new Thread(()->{
        System.out.println(Thread.currentThread().getName());
    }).start();
}

从这里可以看到Thread接收的是一个lambda表达式,这样的表达式是可以当作参数使用的;这里理解也是,比较简单的,上面说到这个表达式是为了处理匿名类的,我们把上面的写法拆开看;

public class test {
    public static void main(String[] args) {
        Runnable runnable = () -> {
            System.out.println(Thread.currentThread().getName());
        };
        new Thread(runnable).start();
    }
}

这样就可以看出,本质传递的就是一个对象,但是上面的写法表象就是传递了一个表达式,一个函数。

这里我们使用自定义接口来测试。

public class TestCustomize {
    public static void main(String[] args) {

        CustomizeClass<Integer, Float, BigDecimal> integerFloatCustomizeClass = new CustomizeClass<>();

        integerFloatCustomizeClass.task((t, v) -> {
            BigDecimal tt = BigDecimal.valueOf(t);
            BigDecimal vv = BigDecimal.valueOf(v);
            return tt.add(vv).setScale(2, RoundingMode.HALF_UP);
        }, 2, 1.11f);
    }
}

@FunctionalInterface
interface CustomizeFunction<T, V, R> {
    R customize(T t, V v);
}

class CustomizeClass<T, V, R> {
    void task(CustomizeFunction<T, V, R> c, T t, V v) {
        System.out.println(c.customize(t, v));
    }
}

从上面可以知道,定义了一个自定义类,里面有一个方法,这个方法有三个参数,一个是自定义的函数式接口,两个运行参数,这两个参数又是函数式参数的入参,然后调用这个函数式参数的方法,完成任务,打印计算结果。

3. Stream流运算和链式编程

在Java8中使用流元素对数据进行操作,可以快速完成运算结果,这里要知道一个点,就是操作是对数据计算的,并不会改变数据本身,调用赋值方法除外。下面给个例子:

public class testA {
    public static void main(String[] args) {
        List<User> list = Arrays.asList(
                new User("1", User.SexEnum.Female, 12)
                , new User("2", User.SexEnum.Female, 22)
                , new User("3", User.SexEnum.Female, 17)
                , new User("4", User.SexEnum.Female, 32)
                , new User("5", User.SexEnum.Female, 45)
                , new User("6", User.SexEnum.Female, 23)
                , new User("7", User.SexEnum.Female, 14)
                , new User("8", User.SexEnum.Female, 11));

        list.stream().map(e -> e.setSex(User.SexEnum.Male)).forEach(System.out::println);
        list.forEach(System.out::println);
    }
}

这里可以对List的数据进行批量赋值,上面我们说了,链式是不能改变数据源的,但是后面却改变了,是不对吗,当然不是,这里要知道,赋值不是流操作导致的,是User的set方法导致的,这个一定要区分出来,否则后面会难以理解一些操作,例如:

public class testA {
    public static void main(String[] args) {
        List<User> list = Arrays.asList(
                new User("1", User.SexEnum.Female, 12)
                , new User("2", User.SexEnum.Female, 22)
                , new User("3", User.SexEnum.Female, 17)
                , new User("4", User.SexEnum.Female, 32)
                , new User("5", User.SexEnum.Female, 45)
                , new User("6", User.SexEnum.Female, 23)
                , new User("7", User.SexEnum.Female, 14)
                , new User("8", User.SexEnum.Female, 11));

        list.stream().filter(e -> e.getAge() >= 18).forEach(e -> System.out.println("stream" + e));
        list.forEach(e -> System.out.println("list" + e));
    }
}

这个操作是通过筛选来处理年龄大于等于18的操作,操作结果:

streamUser{name='2', sex=Female, age=22}
streamUser{name='4', sex=Female, age=32}
streamUser{name='5', sex=Female, age=45}
streamUser{name='6', sex=Female, age=23}
listUser{name='1', sex=Female, age=12}
listUser{name='2', sex=Female, age=22}
listUser{name='3', sex=Female, age=17}
listUser{name='4', sex=Female, age=32}
listUser{name='5', sex=Female, age=45}
listUser{name='6', sex=Female, age=23}
listUser{name='7', sex=Female, age=14}
listUser{name='8', sex=Female, age=11}

从上面可以知道,数据源没有变化,输出结果是处理后的,这里就要注意,要使用处理后的结果,一定要注意接收。

上面不难看出,这些操作十分类似于SQL语法,所以我们可以通过这个操作来处理流数据,因为优化的缘故,流运算效果要比普通的逻辑写法效率高很多。同时这里也看出来,这里的许多写法使用到了上面的lambda表达式,和函数式参数,同时通过.来连接的编程方式,被称为链式编程。

下面简单的介绍一些常用的方法。

3.1. map 和 forEach、flatMap

这两个方法使用的比较高,两个都有遍历的效果,但是也有不同,他们的入参不同导致了性质不同:

3.1.1. map

这个方法的入参是这样的

<R> Stream<R> map(Function<? super T,? extends R> mapper)  

这个不难看出,这个方法是有返回值的,同时他的返回结果是一个流数据。遍历后处理的结果集合会被返回。

3.1.2. forEach

这个方法如下:

void forEach(Consumer<? super T> action)  

这个可以看出,方法是没有返回值的,同时对处理结果不会收集,使用的是消费者接口。

通过上面可以看出一个有对返回的操作收集结果,一个不会。

3.1.3. flatMap

这个方法如下:

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)  

这个方法也会一个一个遍历,同时还会把处理结果返回出来:但是看map会发现函数式参数返回的结果是不同的,一个返回的是元素,一个返回的是集合,表现如下,也就是说map无论返回的是什么都当作一个元素里替换原来的值,flatMap无论返回的是什么,都当做集合来合并原来的集合,然后剔除原来的数。下面一个例子来说明:

public class testB {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1,2,3,4);

        System.out.println(JSON.toJSONString(list1.stream().map(e -> {
            List<Integer> list2 = new ArrayList<>();
            list2.add(e);
            list2.add(e + 10);
            return list2;
        }).collect(Collectors.toList())));

        System.out.println(JSON.toJSONString(list1.stream().flatMap(e -> {
            List<Integer> list2 = new ArrayList<>();
            list2.add(e);
            list2.add(e + 10);
            return list2.stream();
        }).collect(Collectors.toList())));
    }

}

为了好看出关系,这里用JSON来输出:

[[1,11],[2,12],[3,13],[4,14]]
[1,11,2,12,3,13,4,14]

这样就好理解了,例如1来说,map是把返回的值作为元素来替换1的,从对象类型理解就是用List替换原来Integer类型的值,但是flatMap是把值插入了原来的位置,是集合的合并。

一个是单纯的替换,一个是数据的扁平化处理。

3.2. filter

这个方法是筛选功能:

Stream<T> filter(Predicate<? super T> predicate)  

这个方法会遍历流数据,把符合条件的数据组建成新的集合,这个入参的断言接口函数;

public class testB {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1,2,3,4);
        System.out.println(JSON.toJSONString(list1.stream().filter(e->e>2).collect(Collectors.toList())));
    }
}

返回结果:

[3,4]

3.3. limit

方法如下,是限制数量的函数,类似于mysql的limit,但是这个参数只有一个参数:

Stream<T> limit(long maxSize)  

使用方法:

public class testB {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1,2,3,4);
        System.out.println(JSON.toJSONString(list1.stream().limit(2).collect(Collectors.toList())));
    }
}

输出结果:

[1,2]

3.4. sorted

这个方法用来排序使用的。无参以自然排序,有参的可以使用比较大小的参数来比较

Stream<T> sorted()  
Stream<T> sorted(Comparator<? super T> comparator)  

案例如下:

public class testB {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1,5,2,6,3,4);
        System.out.println(JSON.toJSONString(list1.stream().sorted().collect(Collectors.toList())));
        System.out.println(JSON.toJSONString(list1.stream().sorted((e1,e2)->e2.compareTo(e1)).collect(Collectors.toList())));
    }
}

运行结果:

[1,2,3,4,5,6]
[6,5,4,3,2,1]

但是推荐使用Comparator的方法实现,这个也是推荐的方法:

public class testB {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1,5,2,6,3,4);
        System.out.println(JSON.toJSONString(list1.stream().sorted(Comparator.naturalOrder()).collect(Collectors.toList())));
        System.out.println(JSON.toJSONString(list1.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList())));
    }
}

这样也可以实现,同时推荐使用这个方法,实现正反排序。当然自定义也是可以的,例如先排序奇数再排序偶数,这就要自定义了。

public class testB {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1,5,2,6,3,4);
        System.out.println(JSON.toJSONString(list1.stream().sorted((e1,e2)->{
            Integer ee1;
            Integer ee2;
            if (e1%2==0){
                ee1 = e1+10;
            }else {
                ee1 = e1- 10;
            }
            if (e2%2==0){
                ee2 = e2+10;
            }else {
                ee2 = e2- 10;
            }
            return ee1.compareTo(ee2);
        }).collect(Collectors.toList())));

    }
}

结果如下:

[1,3,5,2,4,6]

其他的高级使用就不去一个个介绍了。

3.5. 综合案例

有一组用户信息,先男女性别互换,获取年龄大于18岁的,按年龄排序倒序,按性别分组;

测试代码:

public class testA {
    public static void main(String[] args) {
        List<User> list = Arrays.asList(
                new User("1", User.SexEnum.Female, 12)
                , new User("2", User.SexEnum.Female, 22)
                , new User("3", User.SexEnum.Female, 17)
                , new User("4", User.SexEnum.Male, 32)
                , new User("5", User.SexEnum.Female, 45)
                , new User("6", User.SexEnum.Male, 23)
                , new User("7", User.SexEnum.Male, 14)
                , new User("8", User.SexEnum.Male, 11));

        System.out.println(JSON.toJSONString(
                list.stream().map(e->e.setSex(User.SexEnum.Female.equals(e.getSex())?User.SexEnum.Male:User.SexEnum.Female))
                        .filter(e->e.getAge()>18)
                        .sorted((e1,e2)->e2.getAge().compareTo(e1.getAge()))
                        .collect(Collectors.groupingBy(User::getSex))
        ));
    }
}

测试结果如下:

{
    "Male": [
        {
            "age": 45, 
            "name": "5", 
            "sex": "Male"
        }, 
        {
            "age": 22, 
            "name": "2", 
            "sex": "Male"
        }
    ], 
    "Female": [
        {
            "age": 32, 
            "name": "4", 
            "sex": "Female"
        }, 
        {
            "age": 23, 
            "name": "6", 
            "sex": "Female"
        }
    ]
}

这样就完成了案例的测试了。在Java8里,这样的链式计算使用是非常频繁的,也是一种非常基础的使用。

这篇关于Java8新特性的使用的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!