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新特性的使用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！