首页 > 编程语言> 文章详细

24_Java8

2022-07-05 18:35:18 阅读：97 来源： 互联网

标签：24 list System public println new Java8 out

Java8

Java8

一. Java8概述

Java8(又称JDK1.8)是Java语言开发的一个主要版本. Oracle公司于2014年3月18日发布Java8
- 支持Lambda表达式
- 函数式接口
- 新的Stream API
- 新的日期 API
- 其他特性

二. Lambda表达式

Lambda表达式: 特殊的匿名内部类, 语法更简洁
Lambda表达式允许把函数作为一个方法的参数(函数作为方法的参数传递), 将代码像数据一样传递
基本语法
- <函数式接口> <变量名> = (参数1, 参数2...) -> {//方法体};
Lambda引入了新的操作符: -> (箭头操作符), -> 将表达式分成两部分
- 左侧: (参数1, 参数2...)表示参数列表
- 右侧: {}内部是方法体
注意事项
- 形参列表的数据类型会自动推断
- 如果形参列表为空, 只需保留()
- 如果形参只有一个, ()可以省略, 只需要参数的名称即可
- 如果执行语句只有一句, 且无返回值, {}可以省略, 若有返回值, 则若想省去{}, 则必须同时省略return, 且执行语句也保证只有一句
- Lambda不会生成一个单独的内部类文件

public class TestLambda {

    public static void main(String[] args) {

        //1. 匿名内部类
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程1运行了...");
            }
        };
        new Thread(runnable1).start();

        //2. Lambda表达式
        //2.1 将匿名内部类简化为Lambda表达式
        Runnable runnable2 = () -> System.out.println("子线程2运行了...");
        new Thread(runnable2).start();
        //2.2 把Lambda表达式作为参数传递
        new Thread(() -> System.out.println("子线程3运行了...")).start();

        //3. Lambda表达式
        //匿名内部类
        Comparator<String> comparator1 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        };
        TreeSet<String> treeSet1 = new TreeSet<>(comparator1);

        //3.1 将匿名内部类简化为Lambda表达式
        Comparator<String> comparator2 = (o1, o2) -> o1.length() - o2.length();
        TreeSet<String> treeSet2 = new TreeSet<>(comparator2);


    }
}

三. 函数式接口

如果一个接口只有一个抽象方法, 则该接口称之为函数式接口, 函数式接口可以使用Lambda表达式, Lambda表达式会被匹配到这个抽象方法上
@FunctionalInterface 注解检测接口是否符合函数式接口

//函数式接口: 接口中只有一个抽象方法
@FunctionalInterface //验证是否是函数式接口
public interface Usb {

    void service();

}
public class Demo01 {

    public static void main(String[] args) {

        //1. 匿名内部类
        Usb mouse = new Usb() {
            @Override
            public void service() {
                System.out.println("鼠标开始工作了...");
            }
        };
        run(mouse);

        Usb keyBoard = () -> System.out.println("键盘开始工作了");
        run(keyBoard);
    }

    public static void run(Usb usb){
        usb.service();
    }
}

常用函数式接口

函数式接口	参数类型	返回类型	说明
Consumer消费型接口	T	void	void accept(T,t);对类型为T的对象应用操作
Supplier供给型接口	无	T	T get();返回类型为T的对象
Function<T,R>函数型接口	T	R	R apply(T,t);对类型为T的对象应用操作, 并返回类型为R的对象
Predicate断言型接口	T	boolean	boolean test(T t);确定类型为T的对象是否满足条件, 并返回boolean类型

public class Demo02 {

    public static void main(String[] args) {

//        //匿名内部类
//        Consumer<Double> consumer = new Consumer<Double>() {
//            @Override
//            public void accept(Double aDouble) {
//                System.out.println("聚餐消费: " + aDouble);
//            }
//        };
        //Lambda表达式
        //Consumer<Double> consumer = aDouble -> System.out.println("聚餐消费: " + aDouble);

        //Consumer 消费型接口
        happy(aDouble -> System.out.println("聚餐消费: " + aDouble), 1000);//聚餐消费: 1000.0
        happy(aDouble -> System.out.println("唱歌消费: " + aDouble), 2000);//唱歌消费: 2000.0
        happy(aDouble -> System.out.println("跳舞消费: " + aDouble), 3000);//跳舞消费: 3000.0

        //Supplier 供给型接口
        int[] arr = getNums(() -> new Random().nextInt(100), 5);
        System.out.println(Arrays.toString(arr));//[93, 9, 13, 1, 56] 5个随机数
        int[] arr2 = getNums(() -> new Random().nextInt(100), 10);
        System.out.println(Arrays.toString(arr2));//[53, 94, 55, 59, 76, 74, 21, 61, 32, 94] 10个随机数

        // Function 函数型接口
        String result1 = handleString(s -> s.toUpperCase(), "hello");//转换为大写
        System.out.println(result1);//HELLO
        String result2 = handleString(s -> s.trim(), "   hello   ");//去掉首尾空格
        System.out.println(result2);//hello

        // Predicate 断言型接口
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("李五");
        list.add("张四");
        List<String> result3 = filterNames(s -> s.startsWith("张"), list);//返回以"张"开头的字符串
        System.out.println(result3.toString());//[张三, 张四]
        List<String> result4 = filterNames(s -> s.length() > 1, list);//返回长度大于1的字符串
        System.out.println(result4);//[张三, 李四, 李五, 张四]
    }

    //1. Consumer 消费型接口
    public static void happy(Consumer<Double> consumer, double money){
        consumer.accept(money);
    }
    //2. Supplier 供给型接口
    public static int[] getNums(Supplier<Integer> supplier, int count){
        int[] arr = new int[count];
        for (int i = 0; i < count; i++) {
            arr[i] = supplier.get();
        }
        return arr;
    }
    //3. Function 函数型接口
    public static String handleString(Function<String, String> function, String str){
        return function.apply(str);
    }
    //4. Predicate 断言型接口
    public static List<String> filterNames(Predicate<String> predicate, List<String> list){
        List<String> resultList = new ArrayList<String>();
        for (String s : list) {
            if (predicate.test(s)){
                resultList.add(s);
            }
        }
        return resultList;
    }

}

折叠

四. 方法引用

方法调用时Lambda表达式的一种简写形式. 如果Lambda表达式方法体中只是调用一个人特定的已经存在的方法, 则可以使用方法引用
常见形式
- 对象::实例方法
- 类::静态方法
- 类::实例方法
- 类::new

public class Demo03 {

    public static void main(String[] args) {

        //1. 对象::实例方法
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("hello");

        Consumer<String> consumer2 = System.out::println;
        consumer2.accept("world");

        //2. 类::静态方法
        Comparator<Integer> com = (o1, o2) -> Integer.compare(o1, o2);
        Comparator<Integer> com2 = Integer::compare;

        //3. 类::实例方法
        Function<Person, String> function = person -> person.getName();
        Function<Person, String> function2 = Person::getName;

        System.out.println(function2.apply(new Person("张三", 13)));

        //4. 类::new
        Supplier<Person> supplier = () -> new Person();
        Supplier<Person> supplier2 = Person::new;

        Person person = supplier2.get();
        System.out.println(person.toString());
    }
}

五. Stream API

1. 什么是Stream

流(Stream)中保存对集合或数组数据的操作. 和集合类似, 但集合中保存的是数据

2. Stream特点

Stream自己不会存储元素
Stream不会改变源对象. 相反, 他们会返回一个持有结果的新Stream
Stream操作是延迟执行的. 这意味着他们会等到需要结果的时候才执行

3. Stream使用步骤

(1) 创建
- 新建一个流
(2) 中间操作
- 在一个或多个步骤中, 将初始Stream转化到另一个Stream的中间操作
(3) 终止操作
- 使用一个终止操作来产生一个结果. 该操作会强制它之前的延迟操作立即执行. 在这之后, 该Stream就不能使用了

(1) 创建Stream

通过Collection对象的stream()或parallelStream()方法
通过Arrays类的stream()方法
通过Stream接口的of(), iterate(), generate()方法
通过IntStream, LongStream, DoubleStream接口中的of, range, rangeClosed方法

public class Demo04 {

    public static void main(String[] args) {

        //1. 通过Collection对象的stream()或parallelStream()方法
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("瓜子");
        arrayList.add("花生");
        arrayList.add("啤酒");
        arrayList.add("饮料");
        Stream<String> stream = arrayList.parallelStream();//parallelStream 并行流
        //遍历
        stream.forEach(System.out::println);//方法引用

        //2. 通过Arrays类的stream()方法
        String[] arr = {"aaa", "bbb", "ccc"};
        Stream<String> stream2 = Arrays.stream(arr);
        stream2.forEach(System.out::println);

        //3. 通过Stream接口的of(), iterate(), generate()方法
        //3.1 of()
        System.out.println("----------of()----------");
        Stream<Integer> stream3 = Stream.of(10, 20, 30, 40, 50);
        stream3.forEach(System.out::println);

        //3.2 迭代流iterate()
        System.out.println("----------迭代流iterate()----------");
        Stream<Integer> iterate = Stream.iterate(0, x -> x + 2);
        iterate.limit(10).forEach(System.out::println);

        //3.3 生成流generate()
        System.out.println("----------生成流generate()----------");
        Stream<Integer> generate = Stream.generate(() -> new Random().nextInt(100));
        generate.limit(10).forEach(System.out::println);

        //4. 通过IntStream, LongStream, DoubleStream接口中的of, range, rangeClosed方法
        IntStream stream4 = IntStream.of(100, 200,300);
        stream4.forEach(System.out::println);
        IntStream range = IntStream.range(0, 50);
        range.forEach(System.out::println);
    }
}
折叠

(2) 中间操作

中间操作
- filter, limit, skip, distinct, sorted
- map
- parallel

public class Demo05 {

    public static void main(String[] args) {

        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("小一", 18));
        list.add(new Person("小三", 20));
        list.add(new Person("小二", 19));
        list.add(new Person("小四", 21));
        list.add(new Person("小二", 19));
        list.add(new Person("小四", 21));
        list.add(new Person("小五", 22));
        //中间操作一: 1. filter过滤, 2. limit限制, 3. skip跳过, 4. distinct去重, 5. sorted排序
        //1. filter过滤
        System.out.println("------filter------");
        list.stream()
                .filter(e -> e.getAge() > 20)
                .forEach(System.out::println);
        //2. limit限制
        System.out.println("------limit------");
        list.stream()
                .limit(2)
                .forEach(System.out::println);
        //3. skip跳过
        System.out.println("------skip------");
        list.stream()
                .skip(2)
                .forEach(System.out::println);
        //4. distinct去重(需重写hashcode和equals)
        System.out.println("------distinct------");
        list.stream()
                .distinct()
                .forEach(System.out::println);

        //5. sorted排序
        System.out.println("------sorted------");
        list.stream()
                .sorted((p1, p2) -> Double.compare(p1.getAge(), p2.getAge()))
                .forEach(System.out::println);

        //中间操作二: map
        System.out.println("------map------");
        list.stream()
                .map(e -> e.getName())
                .forEach(System.out::println);
        //中间操作三: parallel 并行: 采用多线程, 效率高
        System.out.println("------parallel------");
        list.parallelStream()
                .forEach(System.out::println);

    }
}
折叠

串行流和并行流的区别(并行流效率更高)

public class Demo06 {

    public static void main(String[] args) {

        //串行流和并行流的区别
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < 5000000; i++) {
            list.add(UUID.randomUUID().toString());
        }
        //串行
        long start1 = System.currentTimeMillis();
        long count1 = list.stream().sorted().count();
        System.out.println(count1);//5000000
        long end1 = System.currentTimeMillis();
        System.out.println("用时: " + (end1 - start1));//用时: 6750

        //并行
        long start2 = System.currentTimeMillis();
        long count2 = list.parallelStream().sorted().count();
        System.out.println(count2);//5000000
        long end2 = System.currentTimeMillis();
        System.out.println("用时: " + (end2 - start2));//用时: 3099


    }
}

(3) 终止操作

终止操作
- forEach, min, max, count
- reduce, collect

public class Demo07 {

    public static void main(String[] args) {

        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("one", 18));
        list.add(new Person("two", 20));
        list.add(new Person("three", 19));
        list.add(new Person("four", 21));
        list.add(new Person("five", 19));
        list.add(new Person("six", 21));
        list.add(new Person("seven", 22));

        //终止操作 forEach
        System.out.println("------forEach------");
        list.stream()
                .filter(p -> {
                    System.out.println("过滤了...");
                   return p.getAge() > 17;
                })
                .forEach(System.out::println);
        //终止操作 min max count
        System.out.println("------min------");
        Optional<Person> min = list.stream()
                .min((p1, p2) -> Double.compare(p1.getAge(), p2.getAge()));
        System.out.println(min.get());
        System.out.println("------max------");
        Optional<Person> max = list.stream()
                .max((p1, p2) -> Double.compare(p1.getAge(), p2.getAge()));
        System.out.println(max.get());
        System.out.println("------count------");

        long count = list.stream().count();
        System.out.println("学生个数: " + count);

        //终止操作 reduce 规约
        //计算所有学生的年龄和
        System.out.println("------reduce------");
        Optional<Integer> sum = list.stream()
                .map(p -> p.getAge())
                .reduce((x, y) -> x + y);
        System.out.println("年龄和为: " + sum.get());

        //终止方法 collect 收集
        //获取所有学生姓名, 封装成一个list集合
        List<String> names = list.stream()
                .map(Person::getName)
                .collect(Collectors.toList());
        for (String name : names) {
            System.out.println(name);
        }

    }
}
折叠

六. 新时间 API

之前时间API存在问题: 线程安全问题, 设计混乱
所有新的日期时间 API 类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从日期/时间中提取单独部分
Java 8 中新的时间与日期 API 中的所有类都是不可变且线程安全的，任何修改操作都会返回一个新的实例
新的 API 区分各种日期时间概念并且各个概念使用相似的方法定义模式，这种相似性非常有利于 API 的学习。总结一下一般的方法或者方法前缀：
- of：静态工厂方法，用于创建实例
- now：静态工厂方法，用当前时间创建实例
- parse：静态工厂方法，从字符串解析得到对象实例
- get：获取时间日期对象的部分状态。
- is：检查某些东西的是否是 true，例如比较时间前后
- with：返回一个部分状态改变了的时间日期对象拷贝
- plus：返回一个时间增加了的、时间日期对象拷贝
- minus：返回一个时间减少了的、时间日期对象拷贝
- to：转换到另一个类型
- at：把这个对象与另一个对象组合起来，例如 date.atTime(time)
- format：提供格式化时间日期对象的能力
本地化日期时间 API
- LocalDate
- LocalTime
- LocalDateTime
Instant: 时间戳
ZoneId: 时区
Date, Instant, LocalDateTime的转换
DateTimeFormatter: 格式化类

(1) DateTimeFormatter

DateTimeFormatter这个类它只提供了时间格式化的类型，就是按你指定的格式，或者按jdk默认的格式，需要进行调用的则是时间类本身来进行调用才能进行格式化

public class Demo01 {

    public static void main(String[] args) {

        //创建DateTimeFormatter
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //(1)把时间格式化成字符串
        String format = dtf.format(LocalDateTime.now());
        System.out.println(format);
        //(2)把字符串解析成时间
        LocalDateTime localDateTime = LocalDateTime.parse("2021-03-13 23:01:35", dtf);
        System.out.println(localDateTime);

    }
}
public class Demo02 {

    public static void main(String[] args) throws Exception{

        //SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");//SimpleDateFormat类是线程不安全的
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");//格式化输出 线程安全
        ExecutorService pool = Executors.newFixedThreadPool(10);
        Callable<LocalDate> callable = new Callable<LocalDate>() {
            @Override
            public LocalDate call() throws Exception {
                return LocalDate.parse("20210313", dtf);//将特定格式的文本字符串解析为时间并返回
            }
        };
        List<Future<LocalDate>> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Future<LocalDate> future = pool.submit(callable);
            list.add(future);
        }

        for (Future<LocalDate> future : list) {
            System.out.println(future.get());
        }
        pool.shutdown();
    }
}

(2) LocalDateTime

public class Demo03 {

    public static void main(String[] args) {

        //1. 创建本地时间
        LocalDateTime localDateTime = LocalDateTime.now();//用当前时间创建实例
        //LocalDateTime localDateTime1 = localDateTime.of();
        System.out.println(localDateTime);//完整日期
        System.out.println(localDateTime.getYear());//年
        System.out.println(localDateTime.getMonth());//月
        System.out.println(localDateTime.getDayOfMonth());//日
        System.out.println(localDateTime.getDayOfWeek());//星期几
        System.out.println(localDateTime.getHour());//时
        System.out.println(localDateTime.getMinute());//分
        System.out.println(localDateTime.getSecond());//秒

        //2. 添加两天
        LocalDateTime localDateTime1 = localDateTime.plusDays(2);//得到一个新的时间对象
        System.out.println(localDateTime1);

        //3. 减少一个月
        LocalDateTime localDateTime2 = localDateTime.minusMonths(2);
        System.out.println(localDateTime2);
    }
}

(3) Instant: 时间戳 + ZoneId: 时区

public class Demo04 {

    public static void main(String[] args) {

        //1. 创建 Instant 时间戳
        Instant instant = Instant.now();
        System.out.println(instant.toString());//2021-03-13T14:30:53.375Z 比北京时间少8小时
        System.out.println(instant.toEpochMilli());//1615645853375
        System.out.println(System.currentTimeMillis());//1615645853522

        //2. 添加, 减少时间
        Instant instant1 = instant.plusMillis(TimeUnit.HOURS.toMillis(8));//通过增加8小时，转化为北京时间
        System.out.println(instant1);
        System.out.println(Duration.between(instant, instant1).toMillis());//28800000 instant和instant1之间相差28800000毫秒,也就是8小时

        //3. ZoneId
        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
        for (String availableZoneId : availableZoneIds) {
            //System.out.println(availableZoneId);
        }
        System.out.println(ZoneId.systemDefault().toString());//Asia/Shanghai

        //4. Date ---> Instant ---> LocalDateTime
        System.out.println("---------Date ---> Instant ---> LocalDateTime---------");
        Date date = new Date();
        System.out.println(date);//Sat Mar 13 22:30:53 CST 2021
        Instant instant2 = date.toInstant();//Date转为Instant
        System.out.println(instant2);//2021-03-13T14:30:53.558Z

        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant2, ZoneId.systemDefault());
        System.out.println(localDateTime);//2021-03-13T22:30:53.558

        //5. LocalDateTime ---> Instant ---> Date
        System.out.println("---------LocalDateTime ---> Instant ---> Date---------");
        Instant instant3 = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
        System.out.println(instant3);
        Date from = Date.from(instant3);
        System.out.println(from);

    }
}

标签：24,list,System,public,println,new,Java8,out
来源： https://www.cnblogs.com/spyX/p/16447995.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9