JavaSE:第十六章:java8新特性(下)

简介: JavaSE:第十六章:java8新特性

###开始操作的相关API

一、通过集合来获取Stream对象 ★

Stream stream = list.stream();

二、通过数组来获取Stream对象

Stream stream = Arrays.stream(数组);

三、通过一组指定的值来获取Stream对象

Stream stream = Stream.of(T…ts)

四、生成无限流

Stream stream= Stream.generate(Supplier sup);

/**
 * 此类用于演示Stream的使用步骤一:创建Stream对象
 * 引申:
 * Stream的使用步骤
 * 1、创建Stream对象,指向数据源
 * 2、中间操作,处理数据,返回一个新的Stream
 * 3、终止操作,执行
 * 创建Stream对象的方式
 * 1、通过集合对象创建Stream
 * 2、通过数组对象创建Stream
 * 3、通过一系列值创建Stream
 * 4、生成无限流
 */
public class TestStreamStart {
  // 1、通过集合对象创建Stream ★
  @Test 
  public void test1() {
    List<Employee> list = EmployeeData.getData();//集合
    //获取串行流对象stream
    Stream<Employee> stream = list.stream();
    //获取并行流对象parallelStream
//    Stream<Employee> parallelStream = list.parallelStream();
    //补充:终止操作
    stream.forEach(System.out::println);
  }
  // 2、通过数组对象创建Stream
  @Test 
  public void test2() {
    Stream<String> stream = Arrays.stream(new String[] {"白眉鹰王","青易斧王","紫衫龙王","金毛狮王"});
    stream.forEach(System.out::println);
  }
  // 3、通过一系列值创建Stream
  @Test 
  public void test3() {
    Stream<String> of = Stream.of("周芷若","小昭","殷离","赵敏");
    of.forEach(System.out::println);
  }
  // 4、生成无限流
  @Test 
  public void test4() {
    Stream<Double> stream = Stream.generate(Math::random);
    stream.forEach(System.out::println);
  }
  //案例:演示链式调用(流式编程)
  @Test 
  public void exec1() {
    //测试1
//    EmployeeData.getData().stream().forEach(System.out::println);
    //测试2
    Person p = new Person();
//    p.eat();
//    p.sleep();
//    p.play();
//    p.study();
    p.eat().sleep().play().study();
  }
}
class Person{
  public Person eat() {
    System.out.println("吃");
    return this;
  }
  public Person sleep() {
    System.out.println("睡");
    return this;
  }
  public Person play() {
    System.out.println("玩");
    return this;
  }
  public Person study() {
    System.out.println("学");
    return this;
  }
}

###中间操作的相关API

* filter(Predicate):根据条件过滤

* limit(long max):截取size<=max的元素

* skip(long s):跳过前s个

* distinct():返回去重后的元素集合,根据hashCode和equals方法判断重复项

* map(Function):映射成新元素

* flatMap(Function):映射成Stream类型的新元素

* sorted():自然排序

* sorted(Comparator):定制排序

*

/**
 * 此类用于演示Stream的使用步骤二:中间操作
 * 特点:
 * ①每个中间操作方法,都会返回一个持有结果的新的Stream对象
 * ②中间操作是“惰性求值”,必须等待终止操作后,才会有处理结果
 * ③Stream是一次性消费,每次消费后,则不能再次消费,除非重新创建新的Stream
 * ④中间操作可以实现链式调用!
 * 常见方法:
 * filter(Predicate):过滤
 * skip(n):去掉前几项
 * limit(n):获取前n项
 * distinct():去重
 * map(Function):映射
 * flatMap(Function):映射,返回Stream
 * sorted():自然排序,要求元素本身实现Comparable接口
 * sorted(Comparator):定制排序
 */
public class TestStreamMiddle {
  List<Employee> list;
  @Before 
  public void before() {
     list = EmployeeData.getData();
  }
  /*
   * 筛选与切片
   *  filter(Predicate p)——接收 Lambda , 从流中排除某些元素。
    limit(n)——截断流,使其元素不超过给定数量。
    skip(n) —— 跳过元素,返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个,则返回一个空流。与 limit(n) 互补
    distinct()——筛选,通过流所生成元素的 hashCode() 和 equals() 去除重复元素
   */
  @Test 
  public void test1() {
    //1.创建Stream对象
    Stream<Employee> stream = list.stream();
    //2.中间操作
    //方式一:filter过滤
//    Stream<Employee> filter = stream.filter(t->t.getGender()=='男');
    //方式二:limit限制,返回不超过指定条目数的数据
//    Stream<Employee> limit = stream.limit(5);
    //方法三:skip(n),跳过指定的n条数据
//    Stream<Employee> skip = stream.skip(3);
    //方法四:distinct()去重:两个元素通过equals判断,如果返回true,则为重复项,一般往往需要重写元素的equals和hashCode方法
    Stream<Employee> distinct = stream.distinct();
    //3.终止操作
    distinct.forEach(System.out::println);
  }
  /**
   * 映射
   * map:映射(将元素映射成任意类型)
   * flatMap:映射(将元素映射成Stream类型)
   */
  @Test 
  public void test2() {
    //1.创建Stream对象
    Stream<Employee> stream = list.stream();
    //2.中间操作
    //方法5:map
//    Stream<String> map = stream.map(Employee::getName);
//    Stream<String> filter = map.filter(s->s.contains("段"));
    Stream<Stream<Object>> map = stream.map(TestStreamMiddle::fromEmployeeToStream);
    //方法6:flatMap
//    Stream<Object> flatMap = stream.flatMap(TestStreamMiddle::fromEmployeeToStream);
    //3.终止操作
//    filter.forEach(System.out::println);
    map.forEach(System.out::println);
  }
  /*
   * 排序
   * sorted()——自然排序
     sorted(Comparator com)——定制排序
   */
  @Test 
  public void test3() {
    //1.开始操作
    Stream<Employee> stream = list.stream();
    //2.中间操作
    //方法7:sorted自然排序
//    Stream<Employee> sorted = stream.sorted();
    //方法8:sorted(Comparator) 定制排序
    Stream<Employee> sorted = stream.sorted((o1,o2)->Double.compare(o2.getSalary(), o1.getSalary()));
    //3.终止操作
    sorted.forEach(System.out::println);
  }
  //将Employee转换成Stream
  public static Stream<Object> fromEmployeeToStream(Employee e){
    return Stream.of(e.getName(),e.getAge(),e.getGender(),e.getSalary());
  }
  //案例:获取工资>6000的,第2条——第8条数据,并且去掉重复项,最后打印
  @Test 
  public void exec1() {
    EmployeeData.
    getData().
    stream().
    filter(t->t.getSalary()>6000).
    skip(1).
    limit(7).
    distinct().
    forEach(System.out::println);
  }
  //练习1:获取员工姓名长度大于2的员工的姓名。
  @Test 
  public void exec2() {
    list.stream().map(Employee::getName).filter(s->s.length()>2).forEach(System.out::println);
  }
  //练习2:获取员工工资>5000并且年龄<30的员工的工资
  @Test 
  public void exec3() {
    list.stream().filter(e->e.getAge()<30&&e.getSalary()>5000).map(Employee::getSalary).forEach(System.out::println);
  }
  //练习3:最老的三个员工的工资
  @Test 
  public void exec4() {
    list.stream().sorted((e1,e2)->Integer.compare(e2.getAge(),e1.getAge())).limit(3).map(Employee::getSalary).forEach(System.out::println);
  }
}

###终止操作的相关API

* allMatch:测试是否全部匹配

* anyMatch:测试是否至少有一个匹配

* noneMatch:测试是否所有的都不匹配

* findFirst:返回第一个

* findAny:返回并行流中的任意一个

* count:统计个数

* max(comparator):返回最大值

* min(comparator):返回最小值

* forEach(Consumer):内部迭代(遍历)

* reduce(BinaryOperator):归约,往往和map搭配使用

/**
 * 此类用于演示Stream的使用步骤三:终止操作
 * 常见方法:
 * reduce:归约   ★
 * forEach:内部迭代   ★
 * max:求最大值
 * min:求最小值
 * count:统计个数     ★
 * allMatch:检测是否所有元素都匹配指定条件
 * anyMatch:检测是否至少有一个元素匹配指定条件
 * noneMatch:检测是否所有元素都不匹配指定条件
 * findFirst:返回第一个元素
 * findAny:返回任意一个元素
 * collect:将Stream转换成集合对象
 */
public class TestStreamEnd {
  List<Employee> list;
  @Before 
  public void before() {
     list = EmployeeData.getData();
  }
  /**
   * 匹配与查找
   *  allMatch(Predicate p)——检查是否匹配所有元素
    anyMatch(Predicate p)——检查是否至少匹配一个元素
    noneMatch(Predicate p)——检查是否没有匹配的元素
    findFirst——返回第一个元素
    findAny——返回当前流中的任意元素
   */
  @Test 
  public void test1() {
    //1.开始操作:创建Stream对象
    Stream<Employee> stream = list.stream();
    //2.中间操作(支持0——n步)
    //3.终止操作
    boolean allMatch = stream.anyMatch(e->e.getSalary()>10000);
    System.out.println(allMatch);
  }
  /*
   * 统计和迭代
   * count
   * max
   * min
   * forEach
   */
  @Test 
  public void test2() {
    //1.开始操作:创建Stream对象
    Stream<Employee> stream = list.stream();
    //2.中间操作(支持0——n步)
    //3.终止操作
    //方法1:count统计
//    long count = stream.count();
//    System.out.println(count);
    //方法2:max求最大值
    Optional<Employee> max = stream.max((o1,o2)->o1.getAge()-o2.getAge());
    System.out.println(max);
  }
  /*
   * 归约
   * reduce:反复结合流中的元素
   */
  @Test 
  public void test3() {
    //1.开始操作:创建Stream对象
    Stream<Employee> stream = list.stream();
    //2.中间操作(支持0——n步)
    //3.终止操作
    Optional<Double> sum = stream.map(Employee::getSalary).reduce((t,u)->t+u);
    System.out.println(sum);
  }
  /*
   *收集
   * collect:收集
   */
  @Test 
  public void test4() {
    //1.开始操作:创建Stream对象
    Stream<Employee> stream = list.stream();
    //2.中间操作(支持0——n步)
    //3.终止操作
    List<Employee> collect = stream.collect(Collectors.toList());
    System.out.println(collect);
  }
  //练习2:员工姓名中包含“马”的员工个数
  @Test 
  public void exec2() {
    Optional<Integer> reduce = list.stream().filter(t->t.getName().contains("马")).map(t->1).reduce((t,u)->t+u);
    System.out.println(reduce);
  }
  //练习:返回最高的工资:
  @Test 
  public void exec1() {
    Optional<Double> max = list.stream().map(Employee::getSalary).max(Double::compare);
    System.out.println(max);
  }
}

JDK8对接口的改进

JDK8:

说明:接口中允许出现静态方法和默认方法

语法:

静态方法:
public static 返回类型 方法名(参数列表){
}
默认方法:
public default 返回类型 方法名(参数列表){
}

使用特点:

1、静态方法不能被实现类或子接口继承,只能通过所在的接口名调用!

2、默认方法具备继承性。可以被实现类或子接口继承过去

解决同名冲突的问题:

1、类优先原则

当父类或实现的接口中出现了同名并且已经实现好的方法时,如果子类中没有重写,则默认使用的是父类的方法

2、当实现的多个接口中出现了同名并且已经实现好的方法时,子类必须重写该方法,否则报错!

JDK9:

说明:接口中允许私有方法

语法:

private 返回类型 方法名(参数列表){
  //代码
}

Optional的特性

理解:

Optional实质上是一个容器,里面包装了具体类型的对象。可以避免对象出现空指针异常的现象

方法:

of
ofNullable
orElse

重复注解

说明:jdk8支持重复注解

语法:

在被修饰的数据上方:

@注解类名

@注解类名

示例:

public class TestJava8Ann {
  @MyAnn
  @MyAnn
//  @AnnArray({@MyAnn,@MyAnn})
  String name;
}
@Repeatable(AnnArray.class)
@interface MyAnn{
  //语法:类型 value() [default 值];
}
@interface AnnArray{
  MyAnn[] value();
}

##日期API

第一代日期:

Date类

SimpleDateFormat类

Date date = new Date();//当前时间
SimpleDateFormat  sdf = new SimpleDateFormat("yyyy-MM-dd hh::mm::ss");
String dateString = sdf.format(date);
/**
 * 此类用于演示第一代日期类
 *  Date
 *  new Date();
 *  getTime()
 *  SimpleDateFormat
 *  format
 *  parse
 */
public class TestDate1 {
  //创建Date对象,表示一个时间,精确到毫秒
  @Test 
  public void test1() {
    //代表当前系统时间
    Date d1 = new Date();
    System.out.println(d1);
    //获取距离1970-1-1的毫秒数
    System.out.println(d1.getTime());
  }
  //测试SimpleDateFormat,格式化或解析日期
  @Test 
  public void test2() throws ParseException {
    Date d=new Date();    
    //1.创建SimpleDateFormat对象
    //①使用默认的格式 18-8-8 下午4:25
//    SimpleDateFormat sdf = new SimpleDateFormat();
    //②使用指定的格式【建议】
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh小时mm分钟ss秒 S毫秒");   
    //-------------格式化日期(将日期转换成字符串)------------
    String format = sdf.format(d);
    System.out.println(format);   
    //------------解析字符串为日期(将字符串转换成日期)--------   
    String s = "2018年12月12日 12小时12分钟12秒 12毫秒";
    Date date = sdf.parse(s);   
    System.out.println(date);
  }
}

第二代日期:

Calendar抽象类:更侧重于获取和设置日历字段

    Calendar date = Calendar.getInstance();
    System.out.println(date);
    int year = date.get(Calendar.YEAR);
    int month = date.get(Calendar.MONTH);
    int day = date.get(Calendar.DAY_OF_MONTH);
    System.out.println(year+"年"+(month+1)+"月"+day+"日");
/**
 * 此类用于演示第二代日期类
 * Calendar
 */
public class TestDate2 {
  @Test 
  public void test1() {   
    //1.获取一个Calendar对象
    Calendar c = Calendar.getInstance();
//    System.out.println(c);    
    //2.获取日历字段    
    System.out.println("年:"+c.get(Calendar.YEAR));
    System.out.println("月:"+(c.get(Calendar.MONTH)+1));
    System.out.println("日:"+c.get(Calendar.DAY_OF_MONTH));
    System.out.println("小时:"+c.get(Calendar.HOUR));
    System.out.println("分钟:"+c.get(Calendar.MINUTE));
    System.out.println("秒:"+c.get(Calendar.SECOND));    
    System.out.println("------------------------------------------");
    //3.设置具体的时间   
    c.set(2000, 1, 1);
    System.out.println("年:"+c.get(Calendar.YEAR));
    System.out.println("月:"+(c.get(Calendar.MONTH)+1));
    System.out.println("日:"+c.get(Calendar.DAY_OF_MONTH));
    System.out.println("小时:"+c.get(Calendar.HOUR));
    System.out.println("分钟:"+c.get(Calendar.MINUTE));
    System.out.println("秒:"+c.get(Calendar.SECOND));
  }
}

第三代日期:

//1.LocalDate/LocalTime/LocalDateTime————>Calendar
@Test 
public void test1() {
  //①创建日期对象
  LocalDateTime ldt = LocalDateTime.now();
   //System.out.println(ldt);
  //②获取日历字段
  int year = ldt.getYear();
  int month = ldt.getMonthValue();
  int day = ldt.getDayOfMonth();
  int hour = ldt.getHour();
  int minute = ldt.getMinute();
  int second = ldt.getSecond();
  System.out.println(year+"年"+month+"月"+day+"日   "+hour+"小时"+minute+"分钟"+second+"秒");
}
//2.Instant————————>Date
@Test 
public void test2() { 
  //①创建Instant对象
  Instant now = Instant.now();  
  //②实现Instant和Date之间的转换
  //Instant——————>Date
  Date date = Date.from(now);
  System.out.println(date);
  //Date——————>Instant
  Instant instant = date.toInstant();
  System.out.println(instant);
}
//3.DateTimeFormatter——————>SimpleDateFormat
/*
 * 可以格式化LocalDateTime,也可以格式化Instant
 */
@Test 
public void test3() {
  LocalDateTime ldt = LocalDateTime.now();
  //①创建DateTimeFormatter对象
  DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd kk::mm::ss");
  //②格式化日期(日期——————>字符串)
  String format = dtf.format(ldt);
  System.out.println(format);
  //③解析日期(字符串——>日期)
  LocalDateTime parse = LocalDateTime.parse("2018-08-08 16::32::21", dtf);
  System.out.println(parse);
}

相关文章
|
19天前
|
Java API 数据处理
Java新特性:使用Stream API重构你的数据处理
Java新特性:使用Stream API重构你的数据处理
Java API 开发者
46 0
|
3月前
|
并行计算 Java API
Java List 集合结合 Java 17 新特性与现代开发实践的深度解析及实战指南 Java List 集合
本文深入解析Java 17中List集合的现代用法,结合函数式编程、Stream API、密封类、模式匹配等新特性,通过实操案例讲解数据处理、并行计算、响应式编程等场景下的高级应用,帮助开发者提升集合操作效率与代码质量。
158 1
|
3月前
|
安全 Java 微服务
Java 最新技术和框架实操:涵盖 JDK 21 新特性与 Spring Security 6.x 安全框架搭建
本文系统整理了Java最新技术与主流框架实操内容,涵盖Java 17+新特性(如模式匹配、文本块、记录类)、Spring Boot 3微服务开发、响应式编程(WebFlux)、容器化部署(Docker+K8s)、测试与CI/CD实践,附完整代码示例和学习资源推荐,助你构建现代Java全栈开发能力。
421 0
|
3月前
|
缓存 安全 Java
Java 并发新特性实战教程之核心特性详解与项目实战
本教程深入解析Java 8至Java 19并发编程新特性,涵盖CompletableFuture异步编程、StampedLock读写锁、Flow API响应式流、VarHandle内存访问及结构化并发等核心技术。结合电商订单处理、缓存系统、实时数据流、高性能计数器与用户资料聚合等实战案例,帮助开发者高效构建高并发、低延迟、易维护的Java应用。适合中高级Java开发者提升并发编程能力。
85 0
|
3月前
|
安全 Java API
Java 17 及以上版本核心特性在现代开发实践中的深度应用与高效实践方法 Java 开发实践
本项目以“学生成绩管理系统”为例,深入实践Java 17+核心特性与现代开发技术。采用Spring Boot 3.1、WebFlux、R2DBC等构建响应式应用,结合Record类、模式匹配、Stream优化等新特性提升代码质量。涵盖容器化部署(Docker)、自动化测试、性能优化及安全加固,全面展示Java最新技术在实际项目中的应用,助力开发者掌握现代化Java开发方法。
143 1
|
3月前
|
IDE Java API
Java 17 新特性与微服务开发的实操指南
本内容涵盖Java 11至Java 17最新特性实战,包括var关键字、字符串增强、模块化系统、Stream API、异步编程、密封类等,并提供图书管理系统实战项目,帮助开发者掌握现代Java开发技巧与工具。
194 2
|
3月前
|
Java 数据库连接 API
Java 8 + 特性及 Spring Boot 与 Hibernate 等最新技术的实操内容详解
本内容涵盖Java 8+核心语法、Spring Boot与Hibernate实操,按考试考点分类整理,含技术详解与代码示例,助力掌握最新Java技术与应用。
120 2

热门文章

最新文章

下一篇
oss教程