JDK8新特性学习

最新推荐文章于 2023-05-01 18:42:07 发布

Catcher_Ghost

最新推荐文章于 2023-05-01 18:42:07 发布

阅读量236

点赞数

分类专栏： JDK8

本文链接：https://blog.csdn.net/Catcher_Ghost/article/details/105506736

版权

JDK8 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

jdk8 时间处理

使用的都是线程安全的

 //获取格式为：今日日期:2020-04-14
        LocalDate today = LocalDate.now();
        System.out.println("今日日期:"+today);
        //获取单独的年月日
        int year = today.getYear();
        int month = today.getMonthValue();
        int day = today.getDayOfMonth();
        System.out.printf("Year : %d Month : %d day : %d \t %n", year, month, day);
        //获取时间格式为:今日日期时间:10:31:49
        LocalDateTime now = LocalDateTime.now();
        System.out.println("今日日期时间:"+now.format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        //时间格式为:今日时间:2020-04-14 10:38:04
        System.out.println("今日时间:"+now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

检查是否为闰年

ChronoUnit为日期枚举类

 LocalDate today = LocalDate.now();
        //检查是否是闰年
        System.out.println(today.isLeapYear());
        System.out.println(today.minus(1, ChronoUnit.YEARS).isLeapYear());

plus()方法

//获取当前日期
        LocalDate today = LocalDate.now();
        //获取一周后的日期
        LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS);
        System.out.println("下周: " + nextWeek);
        //获取一个月后的当前日期
        LocalDate nextMonth = today.plus(1, ChronoUnit.MONTHS);
        System.out.println("下个月: " + nextMonth);
        //获取一年后的当前日期
        LocalDate nextYear = today.plus(1, ChronoUnit.YEARS);
        System.out.println("一年后: " + nextYear);
        //获取10年后今天的日期
        LocalDate nextDecade = today.plus(1, ChronoUnit.DECADES);
        System.out.println("10年后: " + nextDecade);

时间转换

//时间转换
        String dayAfterTommorrow = "20200516";
        LocalDate formatted = LocalDate.parse(dayAfterTommorrow,
                DateTimeFormatter.BASIC_ISO_DATE);
        System.out.println(formatted);

lambda

1.什么是lambda表达式？
lambda表达式可以理解为一种匿名函数的代替,lambda允许函数作为一个方法的参数(函数作为方法参数的传递),将代码像数据一样传递,目的是简化代码的编号.
2.什么是函数式接口?
lambda表达式需要函数式接口的支持,所谓的函数式接口,是指只有一个抽象方法,另外JDK8也提供了一个注解,帮助我们编译时检查语法是否符合
@FunctionInterface
3.lambda表达式的使用案例:
lambda表达式的基本语法:
函数式接口变量名 = (参数1,参数2…)->{//方法体};

  //原始写法：
 Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("lambda1");
            }
        };
        new Thread(runnable).start();

//变种1：
        Runnable runnable1 = ()->{
            System.out.println("lambda2");
        };
        new Thread(runnable1).start();
//变种2：
        new Thread(()->{
            System.out.println("lambda3");
        }).start();

/带参数的传值方式:
//传统方式:
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        };
        TreeSet<String> treeSet = new TreeSet<>(comparator);
        //lambda表达式:
        Comparator<String> comparator1 = (o1,o2)->o1.length()-o2.length();
        TreeSet<String> treeSet1 = new TreeSet<>(comparator1);
        //更简单方式:
        TreeSet<String>treeSet2 = new TreeSet<String>((o1,o2)->o1.length()-o2.length());

4.lambda表达式注意事项
lambda引入了新的操作符:->(箭头操作符),->将表达式分成两部分
左侧:(参数1,参数2…)表示参数列表
右侧:{}内部是方法体
(1)形参列表的数据类型会自动推断;
(2)如果形参列表为空,只需保留()
(3)如果形参只有1个,()可以省略,是需要参数的名称即可
(4)如果执行语句只有1个,且无返回值,{}可以省略;若有返回值,则若想省略,则必须同时省略return,且执行语句也保证只有1句;
(5)lambda不会生成一个单独的内部类文件;
(6)lambda表达式访问了局部变量,则局部变量必须是final的,若是局部变量没有加final关键字,系统会自动添加,此后修改局部变量会报错.

流式编程–StreamAPI

2.1是什么Stream?
Stream是java8中处理数组、集合的抽象概念,它可以指定你希望对集合进行的操作,
可以执行非常复杂的查找、过滤和映射数据操作,使用Stream API对集合数据进行操作,就类似于
使用sql执行的数据库查询.
一个Stream表面上于一个集合很类似,集合中保存的数据,而流设置的是对数据的操作.
Stream的特点:
1.Stream自己不会存储元素
2.Stream不会改变源对象,相反,他们会返回一个持有结果的新Stream
3.Stream操作是延迟执行的,这意味着他们会等到需要结果时才执行.
Stream遵循"做什么,而不是怎么做"的原则,值需要描述需要做什么,而不是考虑程序是怎么样实现的.
2.2快速体验Stream API的特点:

 //传统方式:
     List<String> data = new ArrayList<String>();
     data.add("a");
     data.add("hello");
     data.add("Stream");
     long count = 0;
        for (String datum : data) {
            if(datum.length()>3){
                count++;
            }
        }
        System.out.println(count);
        //lambda表达式
        //1.链式编程
        //2.函数式接口
        //3.lambda表达式
        //s -> s.length() lambda表达式
        long count1 = data.stream().filter(s -> s.length() > 3).count();
        System.out.println(count1);

2.3使用StreamAPI的步骤
1.创建一个Stream.(创建)
2.在一个或多个步骤中,将初始化Stream转化成另一个Stream的中间操作.(中间操作)
3.使用一个终止操作产生一个结果,该操作会强制他之前的延迟操作立即执行,在这之后,该Stream就不会再被使用了.(终止操作)
2.4创建Stream的方式

 int[] array = new int[]{1,2,3};
        IntStream stream = Arrays.stream(array);
        long result = stream.filter(i->i>1).count();
        System.out.println(result);

2.5 Stream的中间操作
2.5.1筛选和切片(filter,limit,skip(n),distinct)

 List<Employee> employees = new ArrayList<>();
        employees.add(new Employee("zhangsan",20,8000));
        employees.add(new Employee("lisi",30,18000));
        employees.add(new Employee("wangwu",40,28000));
        employees.add(new Employee("wangwu",40,28000));
        //筛选:年龄超过30岁的员工
        Stream<Employee> employeeStream = employees.stream().filter(e -> e.getAge() > 30);
        //一般写法:
        employeeStream.forEach(e->System.out.println(e));
        //
        employeeStream.forEach(System.out::println);
         //获取第一个
        Stream<Employee> limit = employees.stream().limit(1);
        limit.forEach( System.out::println);
        //跳过两个
        Stream<Employee> skip = employees.stream().skip(2);
        skip.forEach(System.out::println);
         //自动调用equals和hashcode
        //使用这个方法必须在对象中重写equals和hashcode
        Stream<Employee> distinct = employees.stream().distinct();
        distinct.forEach(System.out::println);

2.5.2 映射(map)

 /**
         * 映射
         * map接收lambda
         * 将元素转换成其他形式或提取信息,接收一个函数式作为参数,
         * 该函数会被应用到每个元素上,将其映射成一个新的元素.
         */
        Stream<String> stream = employees.stream().map(e->e.getName());
        stream.forEach(System.out::println);

        //小写转为大写
        List<String>list = Arrays.asList("a","b","c","d");
        Stream<String> stream1 = list.stream().map(String::toUpperCase);
        stream1.forEach(System.out::println);

2.5.3 排序 (sorted)

//排序
        System.out.println("-------------按年龄自然排序----------------------");
        Stream<Integer> sorted = employees.stream().map(Employee::getAge).sorted();
        sorted.forEach(System.out::println);
     	System.out.println("-------------定制排序-----------------------------------");
        Stream<Employee> sorted1 = employees.stream().sorted((x, y) -> {
            if (x.getAge() == y.getAge()) {
                return x.getSalary() - y.getSalary();
            } else {
                return x.getAge() - y.getAge();
            }
        });
        sorted1.forEach(System.out::println);

2.6 终止操作
2.6.1遍历操作
forEach
2.6.2查找和匹配`

 /**
         * allMatch--检查是否匹配所有元素
         * anyMatch--检查是否至少匹配一个元素
         * noneMatch--检查是否没有匹配的元素
         * findFirst--返回第一个元素
         * count--返回流中元素的总个数
         * max--返回流中大值
         * min--返回流中的小值
         */

2.7 Stream的串行和并行

//初始化数据
        int max = 1000000;
        List<String> values = new ArrayList<>(max);
        for (int i = 0; i < max; i++) {
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }
        //串行计算
        long start = System.currentTimeMillis();
        long count = values.stream().sorted().count();
        System.out.println(count);
        long end = System.currentTimeMillis();
        long millis = end-start;
        System.out.println(millis);
        
        
        //初始化数据
        int max = 1000000;
        List<String> values = new ArrayList<>(max);
        for (int i = 0; i < max; i++) {
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }
        //串行计算  命令式的
        long start = System.currentTimeMillis();
        long count = values.parallelStream().sorted().count();
        System.out.println(count);
        long end = System.currentTimeMillis();
        long millis = end-start;
        System.out.println(millis);