Java 【JDK8特性】【lambda表达式、函数式接口、Optional、LocalDate、LocalTime、LocalDateTime、运算语法】

 1、Lambda表达式

---

 java8中一个非常重要的特性就是lambda表达式，我们可以把它看成是一种闭包，它允许把函数当做参数来使用，是面向函数式编程的思想，一定程度上可以使代码看起来更加简洁。例如以前我们使用匿名内部类来实现代码：

　　　　　//匿名内部类写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("内部类写法");
            }
        }).start();

使用lambda则更加简洁：

//lambda 写法
new Thread(() -> System.out.println("lambda写法")).start(); 

lambda表达式语法

(paramters) -> expression；

或者

    (paramters) -> {statements;}  
    展开如：
    (Type1 param1, Type2 param2, Type2 param2, ...) -> {
        statement1;
        statement2;
        statement3;
        ...
        return statementX;
    }   

lambda表达式特征

•  可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
•  可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
•  可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
•  可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

示例：

        //入参为空
        TestDemo no_param = () -> "hi, no param";
        TestDemo no_param2 = () -> { return "hi, no param"; };
        System.out.println(no_param.hi());

        //单个参数
        TestDemo2 param = name -> name;
        TestDemo2 param2 = name -> { return name;};
        System.out.println(param.hei("hei, grils"));

        //多个参数
        TestDemo3 multiple = (String hello, String name) -> hello + " " + name;
        //一条返回语句，可以省略大括号和return
        TestDemo3 multiple2 = (hello, name) -> hello + name;
        //多条处理语句，需要大括号和return
        TestDemo3 multiple3 = (hello, name) -> {
            System.out.println("进入内部");
            return hello + name;
        };
        System.out.println(multiple.greet("hello", "lambda"));

方法引用

　　在使用lambda时，如果方法体中只有一个方法的调用(包含构造方法)，则可以使用方法引用进一步简化
　　有以下几种类型
　　☆ 对象::实例方法，将lambda的参数当做方法的参数使用

objectName::instanceMethod

　　示例：

Consumer<String> sc = System.out::println;
//等效
Consumer<String> sc2 = (x) -> System.out.println(x);
sc.accept("618, 狂欢happy");

　　代码示例：

 

public class Test {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 30, 29, 47, 22);
        StringBuilder sb = new StringBuilder(); // 创建实例
        // map方法中使用的是 引用类的静态方法 ->  类名::静态方法名
        list.stream().map(String::valueOf).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                sb.append(s);
            }
        });

        // forEach方法中使用 引用对象的实例方法 -> 对象名::实例方法名
        list.stream().map(String::valueOf).forEach(sb::append);
    }
}

　　☆ 类::静态方法，将lambda的参数当做方法的参数使用
　　如果在重写方法的时候，方法体中只有一行代码，并且这行代码调用了某个类的静态方法，我们把要重写的抽象方法中所有的参数都按照顺序传入这个静态方法中，这个时候可以引用类的静态方法

ClassName::staticMethod      // 类名::静态方法名

　　示例：

//ClassName::staticMethod  类的静态方法：把表达式的参数值作为staticMethod方法的参数

Function<Integer, String> sf = String::valueOf;
//等效
Function<Integer, String> sf2 = (x) -> String.valueOf(x);
String apply1 = sf.apply(61888);

　　示例代码：

public class Test {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 30, 29, 47, 22);
        // 匿名内部类写法
        list.stream().map(new Function<Integer, String>() {
            @Override
            public String apply(Integer x) {
                return String.valueOf(x);
            }
        });
        // lambda简写
        list.stream().map(x -> String.valueOf(x));
        // 引用类的静态方法简写    
        list.stream().map(String::valueOf);
    }
}

　　☆ 类::实例方法，将lambda的第一个参数当做方法的调用者，其他的参数作为方法的参数。开发中尽量少些此类写法，减少后续维护成本。

ClassName::instanceMethod

　　示例：

//ClassName::instanceMethod  类的实例方法：把表达式的第一个参数当成instanceMethod的调用者，其他参数作为该方法的参数

BiPredicate<String, String> sbp = String::equals;
//等效
BiPredicate<String, String> sbp2 = (x, y) -> x.equals(y);
boolean test = sbp.test("a", "A");

构造函数

　　无参的构造方法就是类::实例方法模型，如：

Supplier<User> us = User::new;
//等效
Supplier<User> us2 = () -> new User();
//获取对象
User user = us.get();

　　当有参数时：

//一个参数,参数类型不同则会编译出错
Function<Integer, User> uf = id -> new User(id);
//或加括号
Function<Integer, User> uf2 = (id) -> new User(id);
//等效
Function<Integer, User> uf3 = (Integer id) -> new User(id);
User apply = uf.apply(61888);

//两个参数
BiFunction<Integer, String, User> ubf = (id, name) -> new User(id, name);
User 狂欢happy = ubf.apply(618, "狂欢happy");

继承及实现具有相同默认方法的父类或接口问题

　　接口A：

public interface A {

    String hi();

    String greet();

    default void hello() {
        System.out.println("A.hello");
    }

}

　　接口B：

public interface B {

    String hi();

    String hh();

    default void hello() {
        System.out.println("B.hello");
    }

}

　　类C实现A，B：

public class C implements A, B{

    @Override
    public String hi() {
        return "C.hi";
    }

    @Override
    public String greet() {
        return "C.greet";
    }

    @Override
    public String hh() {
        return "C.hh";
    }

    /**
  * 子类优先继承父类的方法， 如果父类没有相同签名的方法，才继承接口的默认方法。
  * 编译报错解决1：覆盖法
     */
    @Override
    public void hello() {
        System.out.println("C.hello");
    }

    /**
  * 编译报错解决2：指定实现的父接口
     */
//    @Override
//    public void hello() {
//        A.super.hello();
//        B.super.hello();
//    }

}

　　此时若不处理hello方法时，类C将编译出错，解决方式要么覆盖，要么指定实现父接口的该方法。
　　进一步测试继承具有相同方法的父类：
　　类D:

public class D {

    public void hello() {
        System.out.println("D.hello");
    }
}

　　类C继承类D:

public class C extends D implements A, B{

    @Override
    public String hi() {
        return "C.hi";
    }

    @Override
    public String greet() {
        return "C.greet";
    }

    @Override
    public String hh() {
        return "C.hh";
    }

    /**
     * 子类优先继承父类的方法， 如果父类没有相同签名的方法，才继承接口的默认方法。
     * 编译报错解决1：覆盖法
     */
//    @Override
//    public void hello() {
//        System.out.println("C.hello");
//    }

    /**
  * 编译报错解决2：指定实现的父接口
     */
//    @Override
//    public void hello() {
//        A.super.hello();34 //    }
}

　　此时若不覆盖或指定父接口的方法时，类C将继承类D的hello方法。

总结

　　java8引入lambda表达式是接收了函数式编程语言的思想，例如scala之类的，它将函数视为一等公民，可以使用高阶函数等。
　　和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。

　　和过程化编程相比，函数式编程里函数的计算可随时调用。

　　写在最后，lambda表达式可以使代码看起来简洁，但一定程度上增加了代码的可读性以及调试的复杂性，所以在使用时应尽量是团队都熟悉使用，要么干脆就别用，不然维护起来是件较痛苦的事。

2、Optional

---

java8 推出的Optional的目的就是为了杜绝空指针异常，帮助开发者开发出更优雅的代码，使用Optional不正确时，将会违背设计者的初衷。

Optional的构造方式：

　　1、Optional.of(T)  　　　　　　　　该方式的入参不能为null，否则会有NPE，在确定入参不为空时使用该方式。　　

　　2、Optional.ofNullable(T)　　　　    该方式的入参可以为null，当入参不确定为非null时使用。　　

　　3、Optional.empty()　　　　              这种方式是返回一个空Optional，等效Optional.ofNullable(null)

 如何正确使用Optional

　　尽量避免使用的地方：

　　　　1、避免使用Optional.isPresent()来检查实例是否存在，因为这种方式和null != obj没有区别，这样用就没什么意义了。　　　　

　　　　2、避免使用Optional.get()方式来获取实例对象，因为使用前需要使用Optional.isPresent()来检查实例是否存在，否则会出现NPE问题。　　　　

　　　　3、避免使用Optional作为类或者实例的属性，而应该在返回值中用来包装返回实例对象。　　　　

　　　　4、避免使用Optional作为方法的参数，原因同3。

　　正确使用方式：

　　　　1、实例对象存在则返回，否则提供默认值或者通过方法来设置返回值，即使用orElse/orElseGet方式：

// 存在则返回
User king = new User(1, "king");
Optional<User> userOpt = Optional.of(king);
User user =  userOpt.orElse(null);
System.out.println(user.getName());

 

// 不存在提供默认值
User user2 = null;
Optional<User> userOpt2 = Optional.ofNullable(user2);
User user3 = userOpt2.orElse(new User("张三")); // 如果User为null, 则返回orElse中提供的数据
System.out.println(user3.getName());

 

// 通过方法提供值
User user4 = userOpt2.orElseGet(() -> new User(0, "DEFAULT")); 
System.out.println(user4.getName())

　　不建议这样使用：

if(userOpt.isPresent()) {
      System.out.println(userOpt.get().getName());
} else {
      //。。。
}

　　2、使用ifPresent()来进行对象操作，存在则操作，否则不操作。

//实例存在则操作，否则不操作
userOpt.ifPresent(u -> System.out.println(u.getName()));
userOpt2.ifPresent(u -> System.out.println(u.getName()));

　　3、使用map/flatMap来获取关联数据

//使用map方法获取关联数据
System.out.println(userOpt.map(u -> u.getName()).orElse("Unknown"));
System.out.println(userOpt2.map(u -> u.getName()).orElse("Default"));
//使用flatMap方法获取关联数据
List<String> interests = new ArrayList<String>();
interests.add("a");interests.add("b");interests.add("c");
user.setInterests(interests);
List<String> interests2 = Optional.of(user)
       .flatMap(u -> Optional.ofNullable(u.getInterests()))
       .orElse(Collections.emptyList());
System.out.println(interests2.isEmpty());

总结

　　正确使用Optiona不仅可以避免NPE问题，还可以使代码看起来更加简洁。

① 创建Optional

public class Test {

    public static void main(String[] args) throws Exception {
        // 创建optional对象
        User user = getUser();
        // 通过Optional中的方法对对象进行包装
        Optional<User> optional = Optional.ofNullable(user);
        // 如果这个User对象不为空, 则会执行匿名内部类中的方法, 如果对象为空, 则不会执行
        optional.ifPresent(new Consumer<User>() {
            @Override
            public void accept(User user) {
                System.out.println(user.getName());
            }
        });
        
    }

    public static User getUser() {
        return new User(1, "张三");
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

　　☆ 在使用的时候还是比较繁琐，需要包装一下，那么可以在获取对象的方法上进行修改，直接返回Optional对象　　

　　实际的开发中，我们的数据很多都是从数据库中获取的，Mybatis从3.5版本开始已经支持Optional了，可以直接将Dao层方法的返回值类型定义为Optional类型，Mybatis会自己把数据封装成Optional对象返回，封装的过程也不需要自己操作。

public class Test {

    public static void main(String[] args) {
        // 创建optional对象
        Optional<User> optional = getUser();
        optional.ifPresent(x -> System.out.println(x.getName()));
    }

    public static Optional<User> getUser() {
        return Optional.ofNullable(new User(1, "张三"));
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

　　☆ 如果确定一个对象不是空的，则可以使用Optional的静态方法of()来把数据进行封装成Optional对象

public class Test {

    public static void main(String[] args) {
        User user = new User(1, "张三");
        Optional<User> optional = Optional.of(user);// 明确了对象不可能为空, 使用of方法是没问题的, 但是一旦对象为空, 则会报错, 因为of调用的Optional构造方法中校验为空就会抛空指针异常
        optional.ifPresent(x-> System.out.println(x.getName()));
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

　　☆ Optional的构造方法

    private Optional(T var1) {
        this.value = Objects.requireNonNull(var1);
    }
    // Objects.requireNonNull源码部分
    public static <T> T requireNonNull(T var0) {
        if (var0 == null) {
            throw new NullPointerException();
        } else {
            return var0;
        }
    }

　　☆ 如果一个方法的返回值类型为Optional类型，并且经过判断发现返回值为null，这个时候需要把null封装成Optional对象返回，则可以使用Optional的静态方法empty()来进行封装

public class Test {

    public static void main(String[] args) {
        Optional<User> userById = getUserById(2);
        // 当Optional中的值为null的时候是不会执行ifPresent内部的方法的
        userById.ifPresent(x -> System.out.println(x.getName()));
        System.out.println("结束");
    }

    public static Optional<User> getUserById(Integer id) {
        User user = new User(1, "张三");
        if (user.getId().equals(id)) {
            return Optional.of(user);
        }
        return Optional.empty();
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

② 安全消费值

　　调用Optional的ifPresent方法, 优雅的避免空指针异常，安全的消费数据

public class Test {

    public static void main(String[] args) {
        Optional<User> userById = getUserById(1);
        // ifPresent方法内部判断了当对象不为空才会执行消费操作, 保证了消费的安全
        userById.ifPresent(new Consumer<User>() {
            @Override
            public void accept(User user) {
                System.out.println(user.getName());
            }
        });
    }

    public static Optional<User> getUserById(Integer id) {
        User user = new User(1, "张三");
        if (user.getId().equals(id)) {
            return Optional.of(user);
        }
        return Optional.empty();
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

③ 获取值

public class Test {

    public static void main(String[] args) {
        Optional<User> optional = getUserById(1);
        // 使用get获取值的时候, 如果值为null, 则会直接抛异常
        User user = optional.get();
        System.out.println(user);
    }

    public static Optional<User> getUserById(Integer id) {
        User user = new User(1, "张三");
        if (user.getId().equals(id)) {
            return Optional.of(user);
        }
        return Optional.empty();
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

　　get方法的源码

    public T get() {
        if (this.value == null) {
            throw new NoSuchElementException("No value present");  // 当对象为null 直接抛异常
        } else {
            return this.value;
        }
    }

④ 安全的获取值

　　orElseGet

　　源码：

    public T orElseGet(Supplier<? extends T> var1) {
        return this.value != null ? this.value : var1.get();
    }

　　示例：

public class Test {

    public static void main(String[] args) {
        Optional<User> optional = getUserById(1);
        // 如果Optional中的值不为null, 则返回该值, 如果为null, 则返回Supplier中get方法提供的默认值
        User user = optional.orElseGet(new Supplier<User>() {
            @Override
            public User get() {
                return new User(2, "李四");
            }
        });
    }

    public static Optional<User> getUserById(Integer id) {
        User user = new User(1, "张三");
        if (user.getId().equals(id)) {
            return Optional.of(user);
        }
        return Optional.empty();
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

　　orElseThrow

　　源码：

    public <X extends Throwable> T orElseThrow(Supplier<? extends X> var1) throws X {
        if (this.value != null) {
            return this.value;
        } else {
            throw (Throwable)var1.get();
        }
    }

　　示例：

public class Test {

    public static void main(String[] args) {
        Optional<User> optional = getUserById(1);
        // 如果Optional中的值不为null, 则返回该值, 如果为null, 则抛出指定的异常
        try {
            User user = optional.orElseThrow(new Supplier<Throwable>() {
                @Override
                public Throwable get() {
                    return new RuntimeException("数据为null");
                }
            });
            System.out.println(user.getName());
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

    public static Optional<User> getUserById(Integer id) {
        User user = new User(1, "张三");
        if (user.getId().equals(id)) {
            return Optional.of(user);
        }
        return Optional.empty();
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

⑤ 过滤

　　使用filter方法对数据进行过滤，如果原本有数据，但是不符合判断，也会编程一个无数据的Optional对象

public class Test {

    public static void main(String[] args) {
        Optional<User> optional = getUserById(1);
        // 当optional中存在值, 则执行filter中的条件判断, 当有满足的条件, 则返回该值
        // 当optional中存在值, 则执行filter中的条件判断, 当没有有满足的条件, 则返回Optional.empty()
        // 当optional中不存在值, 则不会执行filter中的条件判断, 且会返回Optional.empty()
        Optional<User> userOptional = optional.filter(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return user.getName().equals("李四");
            }
        });
        // 在经过过滤之后, 也会返回空的值, 所以获取数据的时候也需要进行安全的获取值
        User user = userOptional.orElseGet(()-> new User(2, "李四"));
    }

    public static Optional<User> getUserById(Integer id) {
        User user = new User(1, "张三");
        if (user.getId().equals(id)) {
            return Optional.of(user);
        }
        return Optional.empty();
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

⑥ 判断

 　　在使用isPresent方法进行是否存在数据的判断，如果为空返回值为false，如果不为空，返回值为true，但是这种方式并不能体现Optional的好处，更推荐使用ifPresent方法

public class Test {

    public static void main(String[] args) {
        Optional<User> optional = getUserById(1);
        // 判断Optional中的值不为null
        if (optional.isPresent()) {
            System.out.println(optional.get());
        }
    }

    public static Optional<User> getUserById(Integer id) {
        User user = new User(1, "张三");
        if (user.getId().equals(id)) {
            return Optional.of(user);
        }
        return Optional.empty();
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

⑦ 数据转换

　　Optional还提供了map方法可以让我们对数据进行转换，并且转换得到的数据也还是被Optional包装好的，保证使用的安全

public class Test {

    public static void main(String[] args) {
        Optional<User> optional = getUserById(1);
        // 将Optional中的User转换成id
        Optional<Integer> idOptional = optional.map(new Function<User, Integer>() {
            @Override
            public Integer apply(User user) {
                return user.getId();
            }
        });
        // 如果这个Optional中的值不为null, 则打印
        idOptional.ifPresent(System.out::println);
    }

    public static Optional<User> getUserById(Integer id) {
        User user = new User(1, "张三");
        if (user.getId().equals(id)) {
            return Optional.of(user);
        }
        return Optional.empty();
    }
}

@Data
@AllArgsConstructor
class User {
    private Integer id;
    private String name;
}

 3、日期时间

---

 　　Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理。java.util.Date和SimpleDateFormatter都不是线程安全的，而LocalDate和LocalTime和最基本的String一样，是不变类型，不但线程安全，而且不能修改。以下为一些常用时间对象：

• • Instant：表示时刻，不直接对应年月日信息，需要通过时区转换

    • 　　

  • LocalDateTime: 表示与时区无关的日期和时间信息，不直接对应时刻，需要通过时区转换
  • LocalDate：表示与时区无关的日期，与LocalDateTime相比，只有日期信息，没有时间信息
  • LocalTime：表示与时区无关的时间，与LocalDateTime相比，只有时间信息，没有日期信息
  • ZonedDateTime： 表示特定时区的日期和时间
  • ZoneId/ZoneOffset：表示时区

LocalDate

　    LocalDate now = LocalDate.now();
        LocalDate now1 = LocalDate.now(Clock.systemUTC());

   System.out.println(now);
   System.out.println(now1);

        LocalDate of = LocalDate.of(2019, 3, 6);
        //严格按照ISO yyyy-MM-dd验证，03写成3都不行
        LocalDate parse = LocalDate.parse("2019-03-06");
   System.out.println(of);
   System.out.println(parse);
14 
        //当天开始时间
   System.out.println(now.atStartOfDay()); // 2024-03-19T00:00
        //当月第一天日期
   System.out.println(now.with(TemporalAdjusters.firstDayOfMonth()));
        //本月第二天日期
        System.out.println(now.withDayOfMonth(2));
        //当月最后一天
   System.out.println(now.with(TemporalAdjusters.lastDayOfMonth()));
   System.out.println(now.getDayOfMonth());
        //当月下一天
        System.out.println(now.plusDays(1));
        //当月上一天
        System.out.println(now.minusDays(1));
   System.out.println(now.getDayOfWeek());
        //当月下一周
        System.out.println(now.plusWeeks(1));
        //当月上一周
        System.out.println(now.minusWeeks(1));
        System.out.println(now.getMonth() + "-" + now.getMonthValue());
        //当月下一个月
        System.out.println(now.plusMonths(1));
        //当月上一个月
        System.out.println(now.minusMonths(1));

        //时间比较
        System.out.println(now.isEqual(LocalDate.of(2019, 03, 06)));

LocalTime 

LocalTime now = LocalTime.now();
//指定时区
LocalTime now1 = LocalTime.now(Clock.system(ZoneId.systemDefault()));
LocalTime now2 = LocalTime.now(Clock.systemUTC());

System.out.println(now);
System.out.println(now1);
System.out.println(now2);

System.out.println("************now************");
//清除毫秒位
System.out.println(now.withNano(0));
//获取当前的小时
System.out.println(now.getHour());
//解析时间时间也是按照ISO格式识别，但可以识别以下3种格式： 12:00 12:01:02 12:01:02.345
System.out.println(LocalTime.parse("11:58:12"));

//时间比较
LocalTime other = LocalTime.of(13, 45, 59);
System.out.println(now.isBefore(other));
System.out.println(now.isAfter(other));

LocalDateTime

LocalDateTime now = LocalDateTime.now();
LocalDateTime now1 = LocalDateTime.now(Clock.system(ZoneId.systemDefault()));
LocalDateTime now2 = LocalDateTime.now(Clock.systemUTC());

System.out.println(now);
System.out.println(now1);
System.out.println(now2); 
// 时间格式转换
System.out.println(now.format(DateTimeFormatter.ofPattern(PATTERN_1)));
System.out.println(now.format(DateTimeFormatter.ofPattern(PATTERN_2)));
System.out.println(now.format(DateTimeFormatter.ofPattern(PATTERN_3)));

Date转换为LocalDateTime

    /**
     * Date转换为LocalDateTime
     */
    public static LocalDateTime date2LocalDateTime() {
       Date date = new Date();
       return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
    }

LocalDateTime转换为Date

    /**
     * LocalDateTime转换为Date
     */
    public static Date localDateTime2Date() {
        LocalDateTime now = LocalDateTime.now();
        Instant instant = now.atZone(ZoneId.systemDefault()).toInstant();
        return Date.from(instant);
    }

日期时间比较

比如在15:30:30之前：
LocalTime.now().isBefore(LocalTime.of(15, 30,30))

或15:30:30之后：
LocalTime.now().isAfter(LocalTime.of(15, 30,30))

相等：
LocalTime.now().equal(LocalTime.of(15, 30,30))

LocalDateTime、LocalDate、LocalTime示例

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAdjusters;

public class Test {

    public static void main(String[] args) {
        LocalTime localTime = LocalTime.now(); // 时分秒
        LocalDate localDate = LocalDate.now(); // 年月日
        LocalDateTime localDateTime = LocalDateTime.now(); // 年月日时分秒
        System.out.println(localTime);      // 14:36:30.402
        System.out.println(localDate);      // 2024-03-19
        System.out.println(localDateTime);  // 2024-03-19T14:36:30.402

        // 获取当月第一天
        System.out.println(localDate.withDayOfMonth(1));                            // 2024-03-01
        System.out.println(localDate.with(TemporalAdjusters.firstDayOfMonth()));    // 2024-03-01
        System.out.println(localDate.with(ChronoField.DAY_OF_MONTH, 1L));         // 2024-03-01

        LocalDate ofLocalDate = LocalDate.of(2020, 10, 20);
        System.out.println(ofLocalDate); // 2020-10-20
        LocalTime ofLocalTime = LocalTime.of(10, 20, 30);
        System.out.println(ofLocalTime); // 10:20:30
        LocalDateTime ofLocalDateTime = LocalDateTime.of(2020, 10, 20, 10, 30, 20);
        System.out.println(ofLocalDateTime); // 2020-10-20T10:30:20

        // 字符串解析
        LocalDate parseLocalDate = LocalDate.parse("2022-03-03");
        System.out.println(parseLocalDate);     // 2022-03-03
        LocalTime parseLocalTime = LocalTime.parse("10:30:01");
        System.out.println(parseLocalTime);     // 10:30:01
        LocalDateTime parseLocalDateTime = LocalDateTime.parse("2022-03-03T10:30:01");
        System.out.println(parseLocalDateTime); // 2022-03-03T10:30:01

        // 获取年、月、日 (LocalDate中没有时分秒, 只能获取年月日)
        int year = localDate.getYear();
        int month = localDate.getMonth().getValue();
        int dayOfYear = localDate.getDayOfYear();
        int dayOfMonth = localDate.getDayOfMonth();
        int dayOfWeek = localDate.getDayOfWeek().getValue();
        System.out.println(year);       // 2024
        System.out.println(month);      // 3
        System.out.println(dayOfYear);  // 79   (当年的第几天)
        System.out.println(dayOfMonth); // 19   (当月的第几天, 几号)
        System.out.println(dayOfWeek);  // 2    (当周的第几天, 周几)

        // 修改年月日, 会返回新的对象, 不修改原LocalDate
        LocalDate withYear = localDate.withYear(2000);              // 修改成2000年
        LocalDate withMonth = localDate.withMonth(1);               // 修改成1月
        LocalDate withDayOfYear = localDate.withDayOfYear(78);      // 修改成一年的第78天
        LocalDate withDayOfMonth = localDate.withDayOfMonth(18);    // 修改成一个月的第18天
        System.out.println(withYear);       // 2000-03-19
        System.out.println(withMonth);      // 2024-01-19
        System.out.println(withDayOfYear);  // 2024-03-18
        System.out.println(withDayOfMonth); // 2024-03-18

        // 年月日加减
        LocalDate plusYears = localDate.plusYears(1);       // 加1年
        LocalDate plusMonths = localDate.plusMonths(1);     // 加1个月
        LocalDate plusDays = localDate.plusDays(1);         // 加1天
        LocalDate plusDaysOfWeek = localDate.plusDays(7);   // 加7天
        LocalDate plusWeeks = localDate.plusWeeks(1);       // 加一周(7天)
        LocalDate plusLocalDate = localDate.plusYears(1).plusMonths(1).plusDays(1);
        System.out.println(plusYears);      // 2025-03-19
        System.out.println(plusMonths);     // 2024-04-19
        System.out.println(plusDays);       // 2024-03-20
        System.out.println(plusDaysOfWeek); // 2024-03-26
        System.out.println(plusWeeks);      // 2024-03-26
        System.out.println(plusLocalDate);  // 2025-04-20
        System.out.println("===================================");

        LocalDate minusYears = localDate.minusYears(1);
        LocalDate minusMonths = localDate.minusMonths(1);
        LocalDate minusDays = localDate.minusDays(1);
        LocalDate minusWeeks = localDate.minusWeeks(1);
        LocalDate minusLocalDate = localDate.minusYears(1).minusMonths(1).minusDays(1);
        System.out.println(minusYears);     // 2023-03-19
        System.out.println(minusMonths);    // 2024-02-19
        System.out.println(minusDays);      // 2024-03-18
        System.out.println(minusWeeks);     // 2024-03-12
        System.out.println(minusLocalDate); // 2023-02-18
        System.out.println("===================================");


        // 获取时、分、秒 (LocalTime中没有年月日, 只能获取时分秒)
        int hour = localTime.getHour();
        int minute = localTime.getMinute();
        int second = localTime.getSecond();
        int nano = localTime.getNano();
        System.out.println(hour);       // 14
        System.out.println(minute);     // 36
        System.out.println(second);     // 30
        System.out.println(nano);       // 402000000

        // 修改时分秒
        LocalTime withHour = localTime.withHour(10);        // 修改为10点
        LocalTime withMinute = localTime.withMinute(20);    // 修改分为20分
        LocalTime withSecond = localTime.withSecond(30);    // 修改秒为30秒
        LocalTime withNano = localTime.withNano(0);         // 修改纳秒为0
        LocalTime withLocalTime = localTime.withHour(10).withMinute(20).withSecond(30).withNano(0); // 同时修改时分秒纳秒
        System.out.println(withHour);       // 10:36:30.402
        System.out.println(withMinute);     // 14:20:30.402
        System.out.println(withSecond);     // 14:36:30.402
        System.out.println(withNano);       // 14:36:30
        System.out.println(withLocalTime);  // 10:20:30

        // 时分秒加
        System.out.println(localTime);                      // 14:36:30.402 (当前时分秒)
        System.out.println(localTime.plusHours(1));         // 15:36:30.402 (基于当前时分秒加1小时)
        System.out.println(localTime.plusMinutes(1));       // 14:37:30.402 (基于当前时分秒加1分钟)
        System.out.println(localTime.plusSeconds(1));       // 14:36:31.402 (基于当前时分秒加1秒)
        System.out.println(localTime.plusNanos(1));         // 14:36:30.402000001 (基于当前时分秒加1纳秒)
        System.out.println(localTime.plusHours(1).plusMinutes(1).plusSeconds(1).plusNanos(1));  // 15:37:31.402000001 (基于当前时分秒加1小时1分1秒1纳秒)
        // 时分秒减
        System.out.println(localTime.minusHours(1));        // 13:36:30.402
        System.out.println(localTime.minusMinutes(1));      // 14:35:30.402
        System.out.println(localTime.minusSeconds(1));      // 14:36:29.402
        System.out.println(localTime.minusNanos(1));        // 14:36:30.401999999
        System.out.println(localTime.minusHours(1).minusMinutes(1).minusSeconds(1).minusNanos(1));  // 13:35:29.401999999
    }
}

ZoneId、ZonedDateTime时区

public static void main(String[] args) {
    ZoneId zoneId = ZoneId.systemDefault();
    System.out.println(zoneId.getId());     // Asia/Shanghai
    System.out.println(zoneId.toString());  // Asia/Shanghai
    System.out.println(zoneId);             // Asia/Shanghai

    // 获取全部时区Id
    System.out.println(ZoneId.getAvailableZoneIds());
    // [Asia/Aden, America/Cuiaba, Etc/GMT+9, Etc/GMT+8, Africa/Nairobi, America/Marigot, Asia/Aqtau, Pacific/Kwajalein, America/El_Salvador, Asia/Pontianak, Africa/Cairo, Pacific/Pago_Pago, Africa/Mbabane, Asia/Kuching, Pacific/Honolulu, Pacific/Rarotonga, America/Guatemala, Australia/Hobart, Europe/London, America/Belize, America/Panama, Asia/Chungking, America/Managua, America/Indiana/Petersburg, Asia/Yerevan, Europe/Brussels, GMT, Europe/Warsaw, America/Chicago, Asia/Kashgar, Chile/Continental, Pacific/Yap, CET, Etc/GMT-1, Etc/GMT-0, Europe/Jersey, America/Tegucigalpa, Etc/GMT-5, Europe/Istanbul, America/Eirunepe, Etc/GMT-4, America/Miquelon, Etc/GMT-3, Europe/Luxembourg, Etc/GMT-2, Etc/GMT-9, America/Argentina/Catamarca, Etc/GMT-8, Etc/GMT-7, Etc/GMT-6, Europe/Zaporozhye, Canada/Yukon, Canada/Atlantic, Atlantic/St_Helena, Australia/Tasmania, Libya, Europe/Guernsey, America/Grand_Turk, Asia/Samarkand, America/Argentina/Cordoba, Asia/Phnom_Penh, Africa/Kigali, Asia/Almaty, US/Alaska, Asia/Dubai, Europe/Isle_of_Man, America/Araguaina, Cuba, Asia/Novosibirsk, America/Argentina/Salta, Etc/GMT+3, Africa/Tunis, Etc/GMT+2, Etc/GMT+1, Pacific/Fakaofo, Africa/Tripoli, Etc/GMT+0, Israel, Africa/Banjul, Etc/GMT+7, Indian/Comoro, Etc/GMT+6, Etc/GMT+5, Etc/GMT+4, Pacific/Port_Moresby, US/Arizona, Antarctica/Syowa, Indian/Reunion, Pacific/Palau, Europe/Kaliningrad, America/Montevideo, Africa/Windhoek, Asia/Karachi, Africa/Mogadishu, Australia/Perth, Brazil/East, Etc/GMT, Asia/Chita, Pacific/Easter, Antarctica/Davis, Antarctica/McMurdo, Asia/Macao, America/Manaus, Africa/Freetown, Europe/Bucharest, Asia/Tomsk, America/Argentina/Mendoza, Asia/Macau, Europe/Malta, Mexico/BajaSur, Pacific/Tahiti, Africa/Asmera, Europe/Busingen, America/Argentina/Rio_Gallegos, Africa/Malabo, Europe/Skopje, America/Catamarca, America/Godthab, Europe/Sarajevo, Australia/ACT, GB-Eire, Africa/Lagos, America/Cordoba, Europe/Rome, Asia/Dacca, Indian/Mauritius, Pacific/Samoa, America/Regina, America/Fort_Wayne, America/Dawson_Creek, Africa/Algiers, Europe/Mariehamn, America/St_Johns, America/St_Thomas, Europe/Zurich, America/Anguilla, Asia/Dili, America/Denver, Africa/Bamako, Europe/Saratov, GB, Mexico/General, Pacific/Wallis, Europe/Gibraltar, Africa/Conakry, Africa/Lubumbashi, Asia/Istanbul, America/Havana, NZ-CHAT, Asia/Choibalsan, America/Porto_Acre, Asia/Omsk, Europe/Vaduz, US/Michigan, Asia/Dhaka, America/Barbados, Europe/Tiraspol, Atlantic/Cape_Verde, Asia/Yekaterinburg, America/Louisville, Pacific/Johnston, Pacific/Chatham, Europe/Ljubljana, America/Sao_Paulo, Asia/Jayapura, America/Curacao, Asia/Dushanbe, America/Guyana, America/Guayaquil, America/Martinique, Portugal, Europe/Berlin, Europe/Moscow, Europe/Chisinau, America/Puerto_Rico, America/Rankin_Inlet, Pacific/Ponape, Europe/Stockholm, Europe/Budapest, America/Argentina/Jujuy, Australia/Eucla, Asia/Shanghai, Universal, Europe/Zagreb, America/Port_of_Spain, Europe/Helsinki, Asia/Beirut, Asia/Tel_Aviv, Pacific/Bougainville, US/Central, Africa/Sao_Tome, Indian/Chagos, America/Cayenne, Asia/Yakutsk, Pacific/Galapagos, Australia/North, Europe/Paris, Africa/Ndjamena, Pacific/Fiji, America/Rainy_River, Indian/Maldives, Australia/Yancowinna, SystemV/AST4, Asia/Oral, America/Yellowknife, Pacific/Enderbury, America/Juneau, Australia/Victoria, America/Indiana/Vevay, Asia/Tashkent, Asia/Jakarta, Africa/Ceuta, Asia/Barnaul, America/Recife, America/Buenos_Aires, America/Noronha, America/Swift_Current, Australia/Adelaide, America/Metlakatla, Africa/Djibouti, America/Paramaribo, Asia/Qostanay, Europe/Simferopol, Europe/Sofia, Africa/Nouakchott, Europe/Prague, America/Indiana/Vincennes, Antarctica/Mawson, America/Kralendijk, Antarctica/Troll, Europe/Samara, Indian/Christmas, America/Antigua, Pacific/Gambier, America/Indianapolis, America/Inuvik, America/Iqaluit, Pacific/Funafuti, UTC, Antarctica/Macquarie, Canada/Pacific, America/Moncton, Africa/Gaborone, Pacific/Chuuk, Asia/Pyongyang, America/St_Vincent, Asia/Gaza, Etc/Universal, PST8PDT, Atlantic/Faeroe, Asia/Qyzylorda, Canada/Newfoundland, America/Kentucky/Louisville, America/Yakutat, America/Ciudad_Juarez, Asia/Ho_Chi_Minh, Antarctica/Casey, Europe/Copenhagen, Africa/Asmara, Atlantic/Azores, Europe/Vienna, ROK, Pacific/Pitcairn, America/Mazatlan, Australia/Queensland, Pacific/Nauru, Europe/Tirane, Asia/Kolkata, SystemV/MST7, Australia/Canberra, MET, Australia/Broken_Hill, Europe/Riga, America/Dominica, Africa/Abidjan, America/Mendoza, America/Santarem, Kwajalein, America/Asuncion, Asia/Ulan_Bator, NZ, America/Boise, Australia/Currie, EST5EDT, Pacific/Guam, Pacific/Wake, Atlantic/Bermuda, America/Costa_Rica, America/Dawson, Asia/Chongqing, Eire, Europe/Amsterdam, America/Indiana/Knox, America/North_Dakota/Beulah, Africa/Accra, Atlantic/Faroe, Mexico/BajaNorte, America/Maceio, Etc/UCT, Pacific/Apia, GMT0, America/Atka, Pacific/Niue, Australia/Lord_Howe, Europe/Dublin, Pacific/Truk, MST7MDT, America/Monterrey, America/Nassau, America/Jamaica, Asia/Bishkek, America/Atikokan, Atlantic/Stanley, Australia/NSW, US/Hawaii, SystemV/CST6, Indian/Mahe, Asia/Aqtobe, America/Sitka, Asia/Vladivostok, Africa/Libreville, Africa/Maputo, Zulu, America/Kentucky/Monticello, Africa/El_Aaiun, Africa/Ouagadougou, America/Coral_Harbour, Pacific/Marquesas, Brazil/West, America/Aruba, America/North_Dakota/Center, America/Cayman, Asia/Ulaanbaatar, Asia/Baghdad, Europe/San_Marino, America/Indiana/Tell_City, America/Tijuana, Pacific/Saipan, SystemV/YST9, Africa/Douala, America/Chihuahua, America/Ojinaga, Asia/Hovd, America/Anchorage, Chile/EasterIsland, America/Halifax, Antarctica/Rothera, America/Indiana/Indianapolis, US/Mountain, Asia/Damascus, America/Argentina/San_Luis, America/Santiago, Asia/Baku, America/Argentina/Ushuaia, Atlantic/Reykjavik, Africa/Brazzaville, Africa/Porto-Novo, America/La_Paz, Antarctica/DumontDUrville, Asia/Taipei, Antarctica/South_Pole, Asia/Manila, Asia/Bangkok, Africa/Dar_es_Salaam, Poland, Atlantic/Madeira, Antarctica/Palmer, America/Thunder_Bay, Africa/Addis_Ababa, Asia/Yangon, Europe/Uzhgorod, Brazil/DeNoronha, Asia/Ashkhabad, Etc/Zulu, America/Indiana/Marengo, America/Creston, America/Punta_Arenas, America/Mexico_City, Antarctica/Vostok, Asia/Jerusalem, Europe/Andorra, US/Samoa, PRC, Asia/Vientiane, Pacific/Kiritimati, America/Matamoros, America/Blanc-Sablon, Asia/Riyadh, Iceland, Pacific/Pohnpei, Asia/Ujung_Pandang, Atlantic/South_Georgia, Europe/Lisbon, Asia/Harbin, Europe/Oslo, Asia/Novokuznetsk, CST6CDT, Atlantic/Canary, America/Knox_IN, Asia/Kuwait, SystemV/HST10, Pacific/Efate, Africa/Lome, America/Bogota, America/Menominee, America/Adak, Pacific/Norfolk, Europe/Kirov, America/Resolute, Pacific/Kanton, Pacific/Tarawa, Africa/Kampala, Asia/Krasnoyarsk, Greenwich, SystemV/EST5, America/Edmonton, Europe/Podgorica, Australia/South, Canada/Central, Africa/Bujumbura, America/Santo_Domingo, US/Eastern, Europe/Minsk, Pacific/Auckland, Africa/Casablanca, America/Glace_Bay, Canada/Eastern, Asia/Qatar, Europe/Kiev, Singapore, Asia/Magadan, SystemV/PST8, America/Port-au-Prince, Europe/Belfast, America/St_Barthelemy, Asia/Ashgabat, Africa/Luanda, America/Nipigon, Atlantic/Jan_Mayen, Brazil/Acre, Asia/Muscat, Asia/Bahrain, Europe/Vilnius, America/Fortaleza, Etc/GMT0, US/East-Indiana, America/Hermosillo, America/Cancun, Africa/Maseru, Pacific/Kosrae, Africa/Kinshasa, Asia/Kathmandu, Asia/Seoul, Australia/Sydney, America/Lima, Australia/LHI, America/St_Lucia, Europe/Madrid, America/Bahia_Banderas, America/Montserrat, Asia/Brunei, America/Santa_Isabel, Canada/Mountain, America/Cambridge_Bay, Asia/Colombo, Australia/West, Indian/Antananarivo, Australia/Brisbane, Indian/Mayotte, US/Indiana-Starke, Asia/Urumqi, US/Aleutian, Europe/Volgograd, America/Lower_Princes, America/Vancouver, Africa/Blantyre, America/Rio_Branco, America/Danmarkshavn, America/Detroit, America/Thule, Africa/Lusaka, Asia/Hong_Kong, Iran, America/Argentina/La_Rioja, Africa/Dakar, SystemV/CST6CDT, America/Tortola, America/Porto_Velho, Asia/Sakhalin, Etc/GMT+10, America/Scoresbysund, Asia/Kamchatka, Asia/Thimbu, Africa/Harare, Etc/GMT+12, Etc/GMT+11, Navajo, America/Nome, Europe/Tallinn, Turkey, Africa/Khartoum, Africa/Johannesburg, Africa/Bangui, Europe/Belgrade, Jamaica, Africa/Bissau, Asia/Tehran, WET, Europe/Astrakhan, Africa/Juba, America/Campo_Grande, America/Belem, Etc/Greenwich, Asia/Saigon, America/Ensenada, Pacific/Midway, America/Jujuy, Africa/Timbuktu, America/Bahia, America/Goose_Bay, America/Virgin, America/Pangnirtung, Asia/Katmandu, America/Phoenix, Africa/Niamey, America/Whitehorse, Pacific/Noumea, Asia/Tbilisi, Europe/Kyiv, America/Montreal, Asia/Makassar, America/Argentina/San_Juan, Hongkong, UCT, Asia/Nicosia, America/Indiana/Winamac, SystemV/MST7MDT, America/Argentina/ComodRivadavia, America/Boa_Vista, America/Grenada, Asia/Atyrau, Australia/Darwin, Asia/Khandyga, Asia/Kuala_Lumpur, Asia/Famagusta, Asia/Thimphu, Asia/Rangoon, Europe/Bratislava, Asia/Calcutta, America/Argentina/Tucuman, Asia/Kabul, Indian/Cocos, Japan, Pacific/Tongatapu, America/New_York, Etc/GMT-12, Etc/GMT-11, America/Nuuk, Etc/GMT-10, SystemV/YST9YDT, Europe/Ulyanovsk, Etc/GMT-14, Etc/GMT-13, W-SU, America/Merida, EET, America/Rosario, Canada/Saskatchewan, America/St_Kitts, Arctic/Longyearbyen, America/Fort_Nelson, America/Caracas, America/Guadeloupe, Asia/Hebron, Indian/Kerguelen, SystemV/PST8PDT, Africa/Monrovia, Asia/Ust-Nera, Egypt, Asia/Srednekolymsk, America/North_Dakota/New_Salem, Asia/Anadyr, Australia/Melbourne, Asia/Irkutsk, America/Shiprock, America/Winnipeg, Europe/Vatican, Asia/Amman, Etc/UTC, SystemV/AST4ADT, Asia/Tokyo, America/Toronto, Asia/Singapore, Australia/Lindeman, America/Los_Angeles, SystemV/EST5EDT, Pacific/Majuro, America/Argentina/Buenos_Aires, Europe/Nicosia, Pacific/Guadalcanal, Europe/Athens, US/Pacific, Europe/Monaco]

    // 获取带时区的时间
    ZoneId zoneId1 = ZoneId.of("America/New_York");
    ZonedDateTime now = ZonedDateTime.now(zoneId1); // 获取指定时区(美国纽约)的时间
    System.out.println(now);        // 2024-03-19T03:12:37.262-04:00[America/New_York]

    // 获取世界标准时间
    ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
    System.out.println(now1);       // 2024-03-19T07:12:37.268Z

    // 获取系统默认时区对应的时间
    ZonedDateTime now2 = ZonedDateTime.now();
    System.out.println(now2);       // 2024-03-19T15:12:37.268+08:00[Asia/Shanghai]

    // ZonedDateTime转LocalDateTime
    System.out.println(now2.toLocalDateTime()); // 2024-03-19T15:14:37.157
    // ZonedDateTime转LocalDate
    System.out.println(now2.toLocalDate());
    // ZonedDateTime转LocalTime
    System.out.println(now2.toLocalTime());

    // ZonedDateTime包含了全部LocalDateTime、LocalDate、LocalTime获取、修改、增加、减少日期的操作
    // ZonedDateTime获取年月日时分秒
    System.out.println(now2.getYear());
    System.out.println(now2.getMonth());
    System.out.println(now2.getDayOfMonth());
    System.out.println(now2.getHour());
    System.out.println(now2.getMinute());
    System.out.println(now2.getSecond());
}

Instant

    public static void main(String[] args) {
        Instant now = Instant.now();
        System.out.println(now);                    // 2024-03-19T07:28:50.257Z
        // 时间戳, 总秒数
        System.out.println(now.getEpochSecond());   // 1710833330
        // 不到1秒的纳秒数
        System.out.println(now.getNano());          // 257000000

        Date date = new Date();
        // 获取当前毫秒值
        System.out.println(date.getTime());         // 1710833330299
    }

DateTimeFormatter

public static void main(String[] args) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

    LocalDateTime now = LocalDateTime.now();
    System.out.println(now); // 2024-03-19T15:36:56.256

    // 方式1: 按照指定格式格式化日期
    System.out.println(formatter.format(now)); // 2024年03月19日 15:36:56
    // 方式2:
    System.out.println(now.format(formatter)); // 2024年03月19日 15:36:56

    // 解析指定日期格式, 根据指定的格式化器解析
    String dateString = "2024年03月19日 15:36:56";
    LocalDate parseLocalDate = LocalDate.parse(dateString, formatter);
    LocalTime parseLocalTime = LocalTime.parse(dateString, formatter);
    LocalDateTime parseLocalDateTime = LocalDateTime.parse(dateString, formatter);
    System.out.println(parseLocalDate);     // 2024-03-19
    System.out.println(parseLocalTime);     // 15:36:56
    System.out.println(parseLocalDateTime); // 2024-03-19T15:36:56
}

时间、日期间隔　　

　　

 

　　

　　

    public static void main(String[] args) {

        LocalDate start = LocalDate.of(2029, 8, 10);
        LocalDate end = LocalDate.of(2030, 8, 15);

        // 计算两个日期 年月日的差值
        Period period = Period.between(start, end);
        System.out.println(period.getYears());  // 1
        System.out.println(period.getMonths()); // 0
        System.out.println(period.getDays());   // 5


        LocalDateTime from = LocalDateTime.of(2025, 11, 11, 10, 0, 0);
        LocalDateTime to = LocalDateTime.of(2025, 11, 12, 15, 0, 0);

        // 计算两个时间对象相差的年月日时分秒等信息 (两个日期间隔多少天、多少小时、多少分钟、多少秒、多少毫秒、多少纳秒)
        Duration duration = Duration.between(from, to);
        System.out.println(duration.toDays());      // 1
        System.out.println(duration.toHours());     // 29 (24+5小时)
        System.out.println(duration.toMinutes());   // 1740
        System.out.println(duration.getSeconds());  // 104400
        System.out.println(duration.toMillis());    // 104400000
        System.out.println(duration.toNanos());     // 104400000000000
    }

 

4、运算语法

---

　　分组并进行求和组合运算

　　示例代码：

List<String> items =
        Arrays.asList("apple", "apple", "banana",
                "apple", "orange", "banana", "papaya");

Map<String, Long> result =
        items.stream().collect(
                Collectors.groupingBy(
                        Function.identity(), Collectors.counting()
                )
        );

System.out.println(result);

　　运行结果：

　　　　{papaya=1, orange=1, banana=2, apple=3}

　　或者针对对象的复杂处理：

/* 先按slotId进行分组，再对分好组之后的数据进行求和5  */
Map<Long, Long> adNumMap = adSlotDataList.stream().collect(Collectors.groupingBy(AdSlotData::getSlotId, Collectors.summingLong(AdSlotData::getAdNum)));

　　List转换成Map

　　示例代码：

/**
 * List -> Map
 * 需要注意的是：
 * toMap 如果集合对象有重复的key，会报错Duplicate key ....
 *  apple1,apple12的id都为1。
 *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
 */
Map<Long, AdSlotData> adPVNumMap = adSlotDataList.stream().collect(Collectors.toMap(AdSlotData::getSlotId, adSlotData -> adSlotData, (k1, k2) -> k1));

5、函数接口

---

函数式接口新特性

　　　　java8中引入了函数式接口新特性，使用@FunctionalInterface标识，表示有且只有一个抽象方法，但可以有多个非抽象方法。

　　　　无论是否加上注解只要接口只有一个抽象方法，都是函数式接口。　　　　

　　　　示例：

package com.notes.java8.functionInterface;

/**
 * 文件描述 函数式接口:
 *      有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
 **/
@FunctionalInterface
public interface Hello {

    /**
     * abstract 方法，只能有一个
     */
    void hello();

    /**
  * 允许定义默认方法
     */
    default void hi(){
        System.out.println("this is default method");
    }

    /**
  * 允许定义静态方法
     */
    static void hei() {
        System.out.println("this is static method");
    }

    /**
  * 允许定义 java.lang.Object 里的 public 方法
     */
    @Override
    boolean equals(Object obj);
}

四大基本函数式接口

　　Function<T, R>

　　　　根据其中抽象方法的参数列表和返回值类型，可以得知可以在方法中对传入的参数计算和转换，把结果返回　　　　

　　　　接受一个入参T，返回R类型对象，使用apply方法获取方法执行的内容

R apply(T t);

　　eg：

User user = new User(88, "bb");
String name = uft.apply(user);
System.out.println(name);


/**
 * Function<T, R> lambda写法
 */
private static Function<User, String> uft = u -> u.getName();

　　BiFunction<T, R, U>

　　　　接收两个参数，返回一个结果

　　Consumer<T>

　　　　根据其中抽象方法的参数列表和返回值类型，可以得知可以在方法中对传入的参数进行消费
　　　　接受一个参数T，没有返回值，使用accept方法对参数执行操作

void accept(T t);

　　eg：

User user = new User(88, "bb");

uc.accept(user);

/**
  * Consumer<T> lambda写法
  */
private static Consumer<User> uc = u -> System.out.println(u.getName());

　　BiConsumer<T, U>

　　　　接口两个参数，没有返回值，也就是消费两个入参

　　Supplier<T>

　　　　根据其中抽象方法的参数列表和返回值类型，可以得知可以在方法中创建对象，把创建好的对象返回　　　　

　　　　没有入参，返回T类型结果，使用get方法获取返回结果

T get();

　　eg：

User user1 = us.get();
System.out.println(user1.getName());

/**
  * Supplier<T> lambda写法
  */
private static Supplier<User> us = () -> new User(1, "us");

 　　Predicate<T>

　　　　根据其中抽象方法的参数列表和返回值类型，可以得知可以在方法中对传入的参数条件判断，返回判断结果

　　　　接受一个入参，返回结果为true或者false,使用test方法进行测试并返回测试结果

boolean test(T t);

　　eg：

boolean test = up.test(user);
System.out.println(test);    

/**
  * Predicate<T>
  */
private static Predicate<User> up = u -> !u.getName().isEmpty(); 

　　其他的函数式接口可参见以下接口示意图：

          

　　常用的默认方法

　　　　and

　　　　在使用Predicate接口的时候，可能需要进行判断条件的拼接，而and方法就相当于使用&&来拼接两个判断条件

public class Test {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 30, 29, 47, 22);
        // Predicate接口中的and方法使用
        List<Integer> collect = list.stream().filter(
                new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer x) {
                        return x > 10;
                    }
                }.and(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer y) {
                        return y < 30;
                    }
                })
        ).collect(Collectors.toList());
　　　　　System.out.println(collect); // [29, 22]
        // lambda简化
        List<Integer> collect2 = list.stream().filter(
                ((Predicate<Integer>) x -> x > 10).and(y -> y < 30)
        ).collect(Collectors.toList());
    }
}

　　　　自定义方法

public class Test {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 30, 29, 47, 22);

        handle(list, new IntPredicate() {
            @Override
            public boolean test(int i) {
                return i > 10;
            }
        }, new IntPredicate() {
            @Override
            public boolean test(int i) {
                return i < 25;
            }
        });
        
        // lambda简化
        handle(list, i -> i > 10, i -> i < 25);
    }


    public static void handle(List<Integer> list, IntPredicate predicate, IntPredicate predicate2) {
        for (Integer x : list) {
            // 打印同时满足两个条件判断的值
            if (predicate.and(predicate2).test(x)) { // and方法返回的是一个Predicate, 需要调用test方法
                System.out.println(x);
            }
        }
    }
}

　　　　or

　　　　在使用Predicate接口的时候，可能需要进行判断条件的拼接，而 or 方法就相当于使用 || 来拼接两个判断条件

public class Test {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 30, 29, 47, 22);
        // Predicate接口中的or方法使用
        List<Integer> collect = list.stream().filter(
                new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer x) {
                        return x > 20;
                    }
                }.or(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer y) {
                        return y > 30;
                    }
                })
        ).collect(Collectors.toList());
        System.out.println(collect); // [30, 29, 47, 22]

        // lambda简化
        List<Integer> collect2 = list.stream().filter(
                ((Predicate<Integer>) x -> x > 20).or(y -> y > 30)
        ).collect(Collectors.toList());
        System.out.println(collect2);
    }
}

　　　　negate

　　　　Predicate接口中的方法，相当于在判断前面加了一个!，表示取反的意思

public class Test {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 30, 29, 47, 22);
        // 遍历打印元素不大于10，也就是小于10的所有元素
        list.stream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer x) {
                return x>10;
            }
        }.negate()).forEach(System.out::println); // 1  2
        
        // lambda简化
        list.stream().filter(((Predicate<Integer>) x -> x > 10).negate()).forEach(System.out::println);
    }
}

6、stream使

---

 1、流的介绍

　　Java8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性　　　　

　　而在Java 的集合 API 中，仅仅有极少量的辅助型方法，更多的时候是程序员需要用 Iterator 来遍历集合，完成相关的聚合应用逻辑。　　　　

　　所谓聚合操作就类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。

2、流的特点

　　Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator，用户只要给出需要对其包含的元素执行什么操作，Stream 会隐式地在内部进行遍历，做出相应的数据转换，比如 “过滤掉长度大于 10 的字符串”。而原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作。
　　Stream 如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了。和迭代器不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作，Stream 的并行操作依赖于 Java7 中的 Fork/Join 框架（JSR166y）来拆分任务和加速处理过程。

3、流的操作类型

　　中间操作（intermediate ）
　　　　一个流可以后面跟随零个或多个 intermediate 操作。其目的是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），仅仅调用到这类方法，并没有真正开始流的遍历。
　　　　对应方法有map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 skip、 parallel、 sequential、 unordered等

　　终止操作（terminal ）
　　　　一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用尽了，无法再被操作，这是流的最后一个操作。
　　　　Terminal 操作的执行，才会真正开始流的遍历，并且会生成一个结果或者一个错误。
　　　　对应方法有forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、iterator

　　短路操作（short-circuiting）
　　　　对于一个 intermediate 操作，如果它接受的是一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream。
　　　　对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果。
　　　　对应方法有anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

4、流的生成

　　流的来源可以是集合，数组，I/O channel， 产生器generator 等。
　　基本数值型，目前有三种对应的包装类型 Stream：IntStream、LongStream、DoubleStream。　　

　　示例：

public class Test {

    public static void main(String[] args) {
        /*************流的来源*************/
        // 1、of方法
        //      of(T... values)：返回含有多个T元素的Stream
        //      of(T t)：返回含有一个T元素的Stream
        Stream<String> single = Stream.of("a");
        Stream<String> multiple = Stream.of("a", "b", "c");

        // 2、generator方法，返回一个无限长度的Stream,其元素由Supplier接口的提供。
        Stream<String> generate = Stream.generate(() -> "a");
        Stream<Double> generateA = Stream.generate(new Supplier<Double>() {
            @Override
            　　　　public Double get() {
                　　　　　　return java.lang.Math.random();
            }
        });
        //  lambda写法
        Stream<Double> generateB = Stream.generate(() -> java.lang.Math.random());
        Stream<Double> generateC = Stream.generate(java.lang.Math::random);

        // 3、iterate方法，返回的也是一个无限长度的Stream，与generate方法不同的是，其是通过函数f迭代对给指定的元素种子而产生无限连续有序Stream，其中包含的元素可以认为是：seed，f(seed),f(f(seed))无限循环
        Stream<Integer> iterate = Stream.iterate(1, item -> item + 2);
        // 无限流处理
        iterate.limit(10).forEach(System.out::println);

        // 4、empty方法返回一个空的顺序Stream，该Stream里面不包含元素项。
        Stream<Object> empty = Stream.empty();

        // 5、Collection接口和数组的默认方法
        String chars[] = new String[] {"a", "b", "c"};
    Arrays.stream(chars).forEach(System.out::println);

        List list = Arrays.asList(chars);
   list.stream().forEach(System.out::println);
   }
}

① 流创建

public class Test {

    public static void main(String[] args) throws Exception {
        // 创建流
        // 1、单列集合,例如: list set..., 使用 集合对象.stream()
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Stream<Integer> stream = list.stream();
        // 流的过滤操作
        stream.filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer>3;
            }
        }).forEach(System.out::println); // 终结操作, 遍历流中的每个元素

        // 2、数组：使用Arrays.stream()或者Stream.of()
        Integer[] arr = {1,2,3,4,5};
        // 2.1
        Stream<Integer> arrStream = Arrays.stream(arr);
        arrStream.forEach(System.out::println);
        // 2.2
        Stream<Integer> integerStream = Stream.of(arr);
        integerStream.forEach(System.out::println);

        // 3、双列集合, 转换为单列集合再创建Stream
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("a", 1);
        hashMap.put("b", 2);
        hashMap.put("c", 3);
        Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();
        Stream<Map.Entry<String, Integer>> entryStream = entrySet.stream();
        entryStream.forEach(System.out::println);
    }
}

② 中间操作 

public class Test {

    public static void main(String[] args) throws Exception {
        // 中间操作

        // 1、filter, 满足指定条件的数据保留在流中
        List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 4, 5);

        // 需求：将集合中大于3的元素打印

        // 1.1 匿名内部类方式
        list.stream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 3;
            }
        }).forEach(System.out::println);
        // 1.1 lambda方式
        list.stream().filter(x -> x > 3).forEach(System.out::println);

        // 需求：将集合中元素转换成字符串打印, 如果集合中是对象, 也可以将流中原本每个元素为对象, 提取成对象中的属性, 从而进行操作

        // 2、map, 类型转换
        // 2.1 匿名内部类方式
        list.stream().map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return String.valueOf(integer);
            }
        }).forEach(System.out::println);
        // 2.2 lambda方式
        list.stream().map(String::valueOf).forEach(System.out::println);

        // 3、distinct, 去重, 依赖于Object的equals方法来判断是否相同的对象, 所以如果是自定义类型, 则需要重写equals方法。
        list.stream().distinct().forEach(System.out::println);

        // 4、sorted, 排序, 如果sorted()不带参数, 并且流中为自定义的类, 那么这个类需要实现Comparable接口
        list.stream().distinct().sorted().forEach(System.out::println); // sorted 默认升序
        list.stream().distinct().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer t1, Integer t2) {
                return t2 - t1; // 返回值小于0, 降序
            }
        }).forEach(System.out::println);

        // 5、limit, 设置流的最大长度, 超出的部分被抛弃
        list.stream().distinct().sorted().limit(3).forEach(System.out::println);

        // 6、skip, 跳过流中的前N个元素, 返回剩下的元素
        list.stream().distinct().sorted().skip(2).forEach(System.out::println);

        // 7、flatMap
        // map只能将一个对象转换成另外一个对象作为流中的元素, 而flatMap可以把一个对象转换成多个对象作为流中的元素
        List<List<Integer>> lists = new ArrayList<>();
        List<Integer> tempList1 = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> tempList2 = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> tempList3 = Arrays.asList(1, 2, 3, 4, 5);
        lists.add(tempList1);
        lists.add(tempList2);
        lists.add(tempList3);
        // 第一个泛型为流中每个元素类型, 第二个泛型为要转换的流的类型
        // 流中的元素类型由List<Integer> 转变成 Integer
        lists.stream().flatMap(new Function<List<Integer>, Stream<Integer>>() {
            @Override
            public Stream<Integer> apply(List<Integer> integers) {
                return integers.stream();
            }
        }).forEach(System.out::println);
    }

③ 终结操作

public class Test {

    public static void main(String[] args) throws Exception {
        // 终结操作
        List<Integer> list = Arrays.asList(1, 3, 3, 2, 2, 4, 5);

        // 1、forEach, 对流中的元素进行遍历操作
        list.stream().distinct().forEach(System.out::println);

        // 2、count, 获取流中的元素的个数
        long count = list.stream().distinct().count();

        // 3、max、min 获取流中的最值
        // max->匿名内部类方式
        Optional<Integer> max = list.stream().distinct().max(new Comparator<Integer>() {
            // 比较用来排序的两个参数.根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数.分别返回 -1、0 或 1
            // t1 要比较的第一个对象
            // t2 要比较的第二个对象
            // Compare的返回值反应的是两个参数的权重,返回值为1时,前者（o1）权重大,返回值为-1时,后者（o2）权重大.
            // 然后排序结果按照权重（注意这里不是值的大小）由小到大进行排序.即权重默认升序排列
            @Override
            public int compare(Integer t1, Integer t2) {
                return t1 - t2;
            }
        });
        System.out.println(max.get());
        // max->lambda方式
        Optional<Integer> max2 = list.stream().distinct().max(Comparator.comparingInt(t -> t));
        System.out.println(max2.get());

        // min->匿名内部类方式
        Optional<Integer> min = list.stream().distinct().min(new Comparator<Integer>() {
            @Override
            public int compare(Integer t1, Integer t2) {
                return t1 - t2;
            }
        });
        System.out.println(min.get());
        // min->lambda方式
        Optional<Integer> min2 = list.stream().distinct().min(Comparator.comparingInt(t -> t));
        System.out.println(min2.get());

        // 4、collect, 把流转换成一个集合

        // 4.1将流操作完之后转换成list集合
        List<Integer> listStream = list.stream().distinct().collect(Collectors.toList());
        // 4.2将流操作完之后转换成set集合
        Set<Integer> setStream = list.stream().distinct().collect(Collectors.toSet());
        // 4.3将流操作完之后转换成map集合
        Map<String, String> mapStream = list.stream().distinct().collect(
                Collectors.toMap(
                        // map的key转换方式, 流中的元素为Integer类型, 此处将Integer类型的元素转换成String类型作为map的key
                        // 如果流中的元素为对象, 那么可以使用对象的某个属性作为key
                        new Function<Integer, String>() {
                            @Override
                            public String apply(Integer integer) {
                                return String.valueOf(integer);
                            }
                        },
                        // map的value转换方式
                        new Function<Integer, String>() {
                            @Override
                            public String apply(Integer integer) {
                                return String.valueOf(integer);
                            }
                        }));
        // 简写方式2
        Map<String, String> mapStream2 = list.stream().distinct().collect(
                Collectors.toMap(item -> String.valueOf(item), item -> String.valueOf(item)));
        // 简写方式3
        Map<String, String> mapStream3 = list.stream().distinct().collect(Collectors.toMap(String::valueOf, String::valueOf));


        // 5、anyMatch, 判断流中的元素是否有至少一个符合条件的元素, 结果为boolean类型

        // 判断是否存在大于3的元素
        boolean anyMatch = list.stream().distinct().anyMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 3;
            }
        });
        // lambda表达式
        boolean anyMatch2 = list.stream().distinct().anyMatch(x -> x > 3);

        // 6、allMatch, 判断流中的元素是否全都符合匹配条件, 结果为boolean类型, 如果全都符合结果为true, 否则为false
        boolean allMatch = list.stream().distinct().allMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer x) {
                return x < 5;
            }
        });
        // lambda表达式
        boolean allMatch2 = list.stream().distinct().allMatch(x -> x < 5);

        // 7、noneMatch, 判断流中的元素是否全都不符合匹配条件, 如果都不符合结果为true, 否则为false
        boolean noneMatch = list.stream().distinct().noneMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer x) {
                return x > 6;
            }
        });
        boolean noneMatch2 = list.stream().distinct().noneMatch(x -> x > 6);

        // 8、findAny, 获取流中的任意一个元素, 该方法没有办法保证获取的一定是流中的第一个元素
        Optional<Integer> findAny = list.stream().distinct().filter(x -> x > 10).findAny();
        findAny.ifPresent(System.out::println); // 如果获取的元素不为空, 则打印

        // 9、findFirst, 获取流中的第一个元素
        Optional<Integer> findFirst = list.stream().distinct().findFirst();
        findFirst.ifPresent(System.out::println);

        // 10、reduce, 归并, 对流中的数据按照指定的计算方式计算出一个结果


        // 先修改流中的元素类型, 然后进行reduce处理
        // 第一个参数为计算的初始值, 第二个参数为数据处理的操作
        String reduce = list.stream().map(String::valueOf).reduce("0", new BinaryOperator<String>() {
            // result为每一次操作的初值, 第一次的时候为"", 也就是reduce的第一个参数的值
            // element为遍历流中的每一个元素, 拿到这个元素进行操作, 然后返回操作的结果
            // 这里的操作就是拿到初值, 然后将遍历的每一个元素与初值进行字符串拼接, 然后又赋值给result, 作为下一次遍历的初值
            @Override
            public String apply(String result, String element) {
                return result + "-" + element; // 将流中的元素进行字符串拼接操作
            }
        });
        System.out.println(reduce);

        // 需求：使用reduce计算流中的最大值
        Integer maxReduce = list.stream().distinct().reduce(Integer.MIN_VALUE, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer result, Integer item) {
                return Integer.max(result, item);
            }
        });
        System.out.println(maxReduce);
        // lambda简化
        Integer maxReduce2 = list.stream().distinct().reduce(Integer.MIN_VALUE, Integer::max);

        // 需求：使用reduce计算流中的最小值
        Integer minReduce = list.stream().distinct().reduce(Integer.MAX_VALUE, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer result, Integer item) {
                return Integer.min(result, item);
            }
        });
        System.out.println(maxReduce);
        // lambda简化
        Integer minReduce2 = list.stream().distinct().reduce(Integer.MAX_VALUE, Integer::min);
        System.out.println(minReduce2);

        // 需求：使用reduce计算集合的和
        List<String> sumList = Arrays.asList("1", "44", "33", "33", "22", "10");
        Integer sumReduce = sumList.stream().map(Integer::parseInt).reduce(0, new BinaryOperator<Integer>() {
            // result 初始值为reduce的第一个参数0, 每一次循环计算的结果会赋值给result
            // item 流中的元素, 会循环拿到每一个元素
            @Override
            public Integer apply(Integer result, Integer item) {
                return result + item;
            }
        });
        System.out.println(sumReduce);
        // lambda简化
        Integer sumReduce2 = sumList.stream().map(Integer::parseInt).reduce(0, Integer::sum);
        System.out.println(sumReduce2);
        // reduce单个参数的使用方式, 其实就是将流中的第一个元素作为计算结果(result)的初始值
        Optional<Integer> sumReduce3 = sumList.stream().map(Integer::parseInt).reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer result, Integer item) {
                return Integer.sum(result, item);
            }
        });
        sumReduce3.ifPresent(System.out::println);
    }

　　注意事项： 

• 惰性求值(如果没有终结操作，没有中间操作是不会得到执行的)
• 流是一次性的(一旦一个流对象经过一个终结操作后，这个流就不能再被使用)
• 不会影响原数据(在流中可以多数据做很多处理，但是正常情况下是不会影响原来集合中的元素的)

5、流的相关使用

　　当你熟悉使用Lambda表达式时，就可以很方便的进行流相关的操作了，提高代码的编写效率和程序的可读性。

public class Test {

    public static void main(String[] args) throws {
        /*************流的操作*************/
        //concat 将两个Stream连接在一起，合成一个Stream。若两个输入的Stream都时排序的，则新Stream也是排序的；若输入的Stream中任何一个是并行的，则新的Stream也是并行的；若关闭新的Stream时，原两个输入的Stream都将执行关闭处理。
        Stream.concat(Stream.of(1, 2, 3), Stream.of(4, 5)).forEach(integer -> System.out.print(integer + "  "));

        //distinct 去除掉原Stream中重复的元素，生成的新Stream中没有没有重复的元素。
        Stream.of(1, 1, 3, 4, 3).distinct().forEach(System.out::println);

        //filter 对原Stream按照指定条件过滤，过滤出满足条件的元素。
        Stream.of(1, 1, 3, 4, 3).filter(x -> x > 2).forEach(System.out::println);

        //map方法将对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素。
        //为了提高处理效率，官方已封装好了，三种变形：mapToDouble，mapToInt，mapToLong，将原Stream中的数据类型，转换为double,int或者long类型。
        Stream.of("a", "b", "c").map(item -> item.toUpperCase()) // .map(String::toUpperCase)
            .forEach(System.out::println);

        // flatMap方法与map方法类似，都是将原Stream中的每一个元素通过转换函数转换，
        // 不同的是，该换转函数的对象是一个Stream，也不会再创建一个新的Stream，而是将原Stream的元素取代为转换的Stream。
        List<User> users = UserUtil.getUsers(6);
        users.stream().flatMap(s -> s.getInterests().stream()).forEach(System.out::println);

        Stream.of("a", "b", "c").flatMap(s -> Stream.of(s.toUpperCase()));

        //peek 生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例)
        Stream.of("a", "b", "c")
            //优先执行
            .peek(s -> System.out.println("peek:" + s)).forEach(System.out::println);

        //skip 将过滤掉原Stream中的前N个元素，返回剩下的元素所组成的新Stream。
        // 如果原Stream的元素个数大于N，将返回原Stream的后的元素所组成的新Stream；
        // 如果原Stream的元素个数小于或等于N，将返回一个空Stream。
        Stream.of("a", "b", "c").skip(2).forEach(System.out::println);

        // sorted方法将对原Stream进行排序，返回一个有序列的新Stream。sorterd有两种变体sorted()，sorted(Comparator)，
        // 前者将默认使用Object.equals(Object)进行排序，而后者接受一个自定义排序规则函数(Comparator)，可自定义进行排序。
        Stream.of(5, 6, 3, 9, 1).sorted().forEach(System.out::println);

        System.out.println("+++++++++++++++++++++++++++++++");
        Stream.of(5, 6, 3, 9, 1).sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //asc
                return o1 - o2;
            }
        }).forEach(System.out::println);

        Stream.of(5, 6, 3, 9, 1)
            //desc
            .sorted(((o1, o2) -> o2 - o1)).forEach(System.out::println);
        System.out.println("+++++++++++++++++++++++++++++++");

        // count 将返回Stream中元素的个数。
        long count = Stream.of(1, 2, 3, 4, 5).count();
        System.out.println("count:" + count);

        // forEach 用于遍历Stream中的所元素，避免了使用for循环，让代码更简洁，逻辑更清晰。
        Stream.of("a", "b", "c").forEach(System.out::println);

        // forEachOrdered 与forEach类似，都是遍历Stream中的所有元素，
        // 不同的是，如果该Stream预先设定了顺序，会按照预先设定的顺序执行（Stream是无序的），默认为元素插入的顺序。
        Stream.of(5, 2, 1, 4, 3).forEachOrdered(integer -> System.out.println("integer:" + integer));

        // max 根据指定的Comparator，返回一个Optional，该Optional中的value值就是Stream中最大的元素。
        Optional<Integer> max = Stream.of(5, 2, 2, 3, 4, 8).max((o1, o2) -> o2 - o1);
        //        Optional<Integer> max3 = Stream.of(1, 2, 3, 4, 5)
        //                .max(Comparator.comparingInt(x -> x));
        Optional<Integer> max3 = Stream.of(1, 2, 3, 4, 5).max((o1, o2) -> o1 - o2);
        int max2 = Stream.of(1, 2, 3, 4, 5).mapToInt(x -> x).max().getAsInt();
        System.out.println("max = " + max.get() + "  max2 = " + max2 + "  max3 = " + max3.orElse(-1));

        UserUtil.getUsers(6).stream().sorted(Comparator.comparing(User::getName).thenComparing(User::getId)).forEach(u -> System.out.println(u.getName()));

        // min 根据指定的Comparator，返回一个Optional，该Optional中的value值就是Stream中最小的元素。
        Optional<Integer> min = Stream.of(1, 2, 3, 4, 5).min((o1, o2) -> o1 - o2);
        System.out.println("min:" + min.get());

        System.out.println("*********************reduce********************");
        // reduce
        //  1、reduce((sum, item) -> { ... }); //返回Optional，因为可能存在为空的情况，
        //  2、reduce(0, (sum, item) -> { ... }); /返回对应类型，不存在为空的情况
        //无初始值，第一个参数为stream的第一个元素，第二个参数为stream的第二个元素，计算的结果赋值给下一轮计算的sum
        Optional<Integer> optional = Stream.of(1, 2, 3, 4, 5).reduce((sum, item) -> {
            System.out.println("sum before:" + sum);
            System.out.println("item:" + item);
            sum = sum + item;
            System.out.println("sum after:" + sum);
            return sum;

            // return Integer.sum(sum, item);
        });
        //等效
        Optional<Integer> optional1 = Stream.of(1, 2, 3, 4, 5).reduce((sum, item) -> Integer.sum(sum, item));
        //等效
        Optional<Integer> optional2 = Stream.of(1, 2, 3, 4, 5).reduce(Integer::sum);
        System.out.println("integer = " + optional.orElse(-1));
        System.out.println("*****************************************");
        //给定初始值，第一个参数为初始值，第二个参数为stream的第一个元素，计算的结果赋值给下一轮计算的sum
        Integer reduce = Stream.of(1, 2, 3, 4, 5).reduce(5, (sum, item) -> {
            System.out.println("sum2 before:" + sum);
            System.out.println("item:" + item);
            sum = sum + item;
            System.out.println("sum2 after:" + sum);
            return sum;
        });
        //等效
        Integer reduce2 = Stream.of(1, 2, 3, 4, 5).reduce(0, (sum, item) -> Integer.sum(sum, item));
        //等效
        Integer reduce3 = Stream.of(1, 2, 3, 4, 5).reduce(0, Integer::sum);
        System.out.println("reduce = " + reduce);

        System.out.println("*********************collect********************");
        List<Integer> toList = Stream.of(1, 2, 3, 4).collect(Collectors.toList());
        List<Integer> toList2 = Stream.of(1, 2, 3, 4).collect(Collectors.toCollection(ArrayList::new));
        System.out.println("toList: " + toList);

        Set<Integer> toSet = Stream.of(1, 2, 3, 4).collect(Collectors.toSet());
        Set<Integer> toSet2 = Stream.of(1, 2, 3, 4).collect(Collectors.toCollection(() -> new TreeSet()));
        System.out.println("toSet: " + toSet);

        //(value1, value2) -> value1  用前面的value覆盖后面的value，保持不变
        List<User> userList = UserUtil.getUsers(5);
        userList.add(new User(2, "fjw"));
        Map<Integer,String> toMap = userList.stream().collect(Collectors.toMap(User::getId, User::getName, (value1, value2) -> value1));
        System.out.println("(value1, value2) -> value1");
        toMap.forEach((k, v) -> System.out.println(k + "-" + v));

        // 对value值进行了限定不能为null，否则抛出空指针异常
        //        userList.add(new User(3, null));
        //(value1, value2) -> value2  用后面的value覆盖前面的value
        Map<Integer,String> toMap2 = userList.stream().collect(Collectors.toMap(User::getId, User::getName, (value1, value2) -> value2));
        System.out.println("(value1, value2) -> value2");
        toMap2.forEach((k, v) -> System.out.println(k + "-" + v));

        // 解决value值为null方式
        userList.add(new User(4, null));
        Map<Integer,String> toMap3 = userList.stream().collect(HashMap::new, (m, u) -> m.put(u.getId(), u.getName()), HashMap::putAll);
        toMap3.forEach((k, v) -> System.out.println(k + "-" + v));

        Optional<Integer> maxBy = Stream.of(1, 2, 3, 4).collect(Collectors.maxBy(Comparator.comparingInt(o -> o)));
        System.out.println("maxBy:" + maxBy.get());
　　// 统计流中元素的数量, 等价于 Long counting = Stream.of(1, 2, 3, 4).count();
        Long counting = Stream.of(1, 2, 3, 4).collect(Collectors.counting());
        System.out.println("counting:" + counting);

        // 分割数据块
        Map<Boolean,List<Integer>> partitioningBy = Stream.of(1, 2, 3, 4, 5).collect(Collectors.partitioningBy(item -> item > 3));
        // partitioningBy : {false=[1, 2, 3], true=[4, 5]}
        System.out.println("partitioningBy : " + partitioningBy);
       // 根据分组条件进行分组, 然后统计每个分组的数量
        Map<Boolean,Long> collect = Stream.of(1, 2, 3, 4).collect(Collectors.partitioningBy(item -> item > 3, Collectors.counting()));
        System.out.println("collect: " + collect); // {false=3, true=1}

        // 数据分组
        Map<Boolean,List<Integer>> groupingBy = Stream.of(1, 2, 3, 4, 5).collect(Collectors.groupingBy(item -> item > 3));
        // partitioningBy : {false=[1, 2, 3], true=[4, 5]}
        System.out.println("groupingBy : " + groupingBy);

        // 字符串
        String joining = Stream.of("a", "b", "c", "d").collect(Collectors.joining(","));
        System.out.println(joining); // a,b,c,d

        String joining2 = Stream.of("a", "b", "c", "d").collect(Collectors.joining(",", "[", "]"));
        System.out.println(joining2);  // [a,b,c,d]
        // 根据id分组
        Map<Integer,List<User>> collect3 = userList.stream().collect(Collectors.groupingBy(User::getId));
        // 将id映射为id集合  List<Integer> collect1 = users.stream().map(User::getId).collect(Collectors.toList());
        List<Integer> collect1 = userList.stream().collect(Collectors.mapping(User::getId, Collectors.toList())); // [1, 2, 3]
        // 根据id分组后将name映射成集合
        Map<Integer, List<String>> collect2 = userList.stream().collect(Collectors.groupingBy(User::getId, Collectors.mapping(User::getName, Collectors.toList())));
        System.out.println(collect2); //  {1=[zhangsan], 2=[lisi], 3=[wangwu], 4=[zhangsan]}       id -> name176     }
}

6、stream基本数据类型优化

　　在stream的方法很多都使用了泛型，所以涉及到的参数和返回值都是引用类型。　　

　　即使操作的都是整数，但是实际用到的都是它们的包装类，JDK5中引入的自动装箱和自动拆箱让我们使用包装类的时候就好像使用基本数据类型一样方便，但是拆箱装箱是会消耗时间的，虽然消耗的时间少，但是大量的数据不断的重复拆箱装箱，这个时间就不能无视它了。　　

　　例如：mapToInt、mapToLong、mapToDouble、flatMapToInt、flatMapToDouble等　　将流程的包装类型先转换成基本类型，然后进行计算

public class Test {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 30, 29, 47, 22);
        // 通过mapToInt将流中的数据在转换的时候，包装类型转为基本类型，后续的处理也都是基本数据类型，减少装箱拆箱带来的耗时
        list.stream().mapToInt(x -> x + 10)
                .filter(x -> x > 25)
                .map(x -> x + 3)
                .forEach(System.out::println);
    }
}

7、并行流

public class Test {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 30, 29, 47, 22, 11, 14, 13, 55, 92, 53);
        // 串行计算
        Optional<Integer> reduce = list.stream().filter(x -> x > 10).reduce(Integer::sum);
        reduce.ifPresent(System.out::println); // 366

        // 并行计算
        Optional<Integer> reduce2 = list.stream().parallel().filter(x -> x > 10).reduce(Integer::sum);
        reduce2.ifPresent(System.out::println); // 366
    }
}

 

base64

　　java 1.8中引入了Base64，不在需要引入第三方库就可以使用base64了。

                

　　在需要用到base64进行加密解密的时候就可以使用了

String text = "base64 in java8 lib";
//编码
String encode = Base64.getEncoder().encodeToString(text.getBytes(StandardCharsets.UTF_8));
System.out.println(encode);

//解码
String decode = new String(Base64.getDecoder().decode(encode), StandardCharsets.UTF_8);
System.out.println(decode);