public static IntStream stream(int[] array) ； public static LongStream stream(long[] array) ； public static DoubleStream stream(double[] array)； //举例 Integer[] array = new Integer[]{3,4,8,16,19,27,23,99,76,232,33,96}; long count = Arrays.stream(array).filter(i->i>20).count();

public static Stream of(T... values) : 返回一个流 //举例 Integer[] array = new Integer[]{3,4,8,16,19,27,23,99,76,232,33,96}; long count = Stream.of(array).filter(i->i>20).count(); long sum = Stream.of(12,77,59,3,654).filter(i->i>20).mapToInt(Integer::intValue).sum();

public static Stream iterate(final T seed, final UnaryOperator f); //迭代 public static Stream generate(Supplier s); //生成 //举例 iterate Stream bigIntStream = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.TEN)).limit(10); BigInteger[] bigIntArr = bigIntStream.toArray(BigInteger[]::new); //输出：[0, 10, 20, 30, 40, 50, 60, 70, 80, 90] System.out.println(Arrays.toString(bigIntArr)); //举例 generate Stream stream = Stream.generate(() -> "test").limit(10); String[] strArr = stream.toArray(String[]::new); //输出 [test, test, test, test, test, test, test, test, test, test] System.out.println(Arrays.toString(strArr));

Stream 的中间操作：多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); for(Integer i:numbers){ if(i>20){ count++; } } //当使用 Stream 操作时如下： list.stream().filter(num -> num > 4).count(); //limit 使用：输出 [1, 2, 3, 4] 方法会返回一个包含n个元素的新的流（若总长小于n则返回原始流） List afterLimit = list .stream().limit(4).collect(Collectors.toList()); //skip(n) 使用：输出 [5, 6, 7, 8, 9] 与limit 正好相反，它会丢弃掉前面的n个元素。 List afterSkip = list .stream().skip(4).collect(Collectors.toList()); //用limit和skip方法一起使用就可以实现日常的分页功能 List pageList = myList.stream().skip(pageNumber*pageSize) .limit(pageSize).collect(Collectors.toList());

List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); //将Integer类型转换成String类型 List afterString = integerList.stream().map(i->String.valueOf(i)).collect(Collectors.toList());

//distinct List list = Arrays.asList(70, 25, 38, 64, 25, 46, 7, 18, 9); List distinctList = list.stream().distinct().collect(Collectors.toList()); //sorted List sortList = myTestList.stream() .sorted(Integer::compareTo).collect(Collectors.toList());

List list = Arrays.asList(70, 125, 38, 64, 25, 46, 7, 18, 9); //max 与 min 案例 Integer maxItem = list.stream().max(Integer::compareTo).get(); Integer minItem = list.stream().min(Integer::compareTo).get(); //findFirst:方法返回非空集合中的第一个值，它通常与filter方法结合起来使用。 Integer first = list.stream().filter(i->i>100).findFirst().get(); //findAny:可以在集合中只要找到任何一个所匹配的元素，就返回，此方法在对流并行执行时十分有效（任何片段中发现第一个匹配元素都会结束计算，串行流中和findFirst返回一样)。 Integer anyItem = list.parallelStream().filter(i->i>100).findAny().get(); //anyMatch:可以判定集合中是否还有匹配的元素。返回结果是一个boolean类型值。noneMatch 相反。 boolean isHas = list.parallelStream().anyMatch(i->i>100); boolean noHas = hearList.parallelStream().noneMatch(i->i>100);

List list = Arrays.asList(70, 125, 38, 64, 25, 46, 7, 18, 9); //简化一下，对元素长度进行求和。 sum = list.stream().map(Objects::toString).mapToInt(String::length).sum();

//例如前面的例子用的要将一个流收集到一个List中，只需要这样写就可以。 List thereList = hereList.stream().collect(Collectors.toList()); //收集到Set中可以这样用 Set thereSet = hereList.stream().collect(Collectors.toSet()); //将字流中的字符串连接并收集起来。 String resultString = stringList.stream().collect(Collectors.joining()); //在将流中的字符串连接并收集起来时，想在元素中介添加分隔符，传递个joining方法即可。 String resultString = stringList.stream().collect(Collectors.joining(",")); //总和、平均值，最大值，最小值 int sum = hereList.stream().collect(Collectors.summingInt(Integer::intValue)); Double ave = hereList.stream().collect(Collectors.averagingInt(Integer::intValue)); Integer max = hereList.stream().collect(Collectors.maxBy(Integer::compare)).get(); Integer min = hereList.stream().collect(Collectors.minBy(Integer::compare)).get();

//准备工作 List

formList = Lists.newArrayList( new Form (3,4,5), new Form (6,5,3), new Form (77,43,55); ) //Form对象的 high作为键 width作为值 Map hwMap = formList.stream().collect(Collectors.toMap(Form::getHigh, Form::getWidth)); //但是通常还是以具体元素作为值的情况多，可以使用Function.identity()来获取实际元素。 Map FormMap = formList.stream().collect(Collectors.toMap(Form::getHigh, Function.identity())); //如果多个元素拥有相同的键，在收集结果时会抛出java.lang.IllegalStateException异常。 //可以使用第三个参数来解决，第三个参数用来确定当出现键冲突时，该如何处理结果，如果当出现键冲突时只保留一个并且是保留已经存在的值时，就是如下方式。 Map rMap = formList.stream().collect(Collectors.toMap(Form::getHigh, Function.identity(),(nowValue,newValue)->nowValue)); //如果想指定生成的 Map类型，则还需要第三个参数。 TreeMap FormTreeMap = FormList.stream().collect(Collectors.toMap(Form::getHigh, Function.identity(),(nowValue,newValue)->newValue,TreeMap::new)); //******在一个集合中，对具有相同特性的值进行分组是一个很常见的功能，在Stream的API中也提供了相应的方法。 //根据 high 将 Form 进行分组 Map> groupMap = list .stream().collect(Collectors.groupingBy(Form::getHigh)); //当分类函数是一个返回布尔值的函数时，流元素会被分为两组列表：一组是返回true的元素集合，另一组是返回false的元素集合。这种情况适用 partitoningBy方法会比groupingBy更有效率。 Map> partitionMap = list.stream().collect(Collectors.partitioningBy(form->form.getHigh()==22)); //例如我们将房间集合分为两组，一组是高度为22的房间，另一组是其他房间。 //mapping方法会将结果应用到另一个收集器上。如下取出分组中宽度最大的宽度。 Map> collect = list.stream().collect(Collectors.groupingBy(Form::getHigh, Collectors.mapping(Form::getWidth,Collectors.maxBy(Comparator.comparing(Integer::valueOf))))); //*****groupingBy是支持多级分组的。例如第一级我们将按照高度分组，第二级按照宽度分组。 Map>> multistageMap = list.stream(). collect(Collectors.groupingBy(Form::getHigh,Collectors.groupingBy(Form::getWidth)));

Stream.of(roomList).parallel();

//下面这个例子中的代码就是错误的，传递给并行流的操作并不是线程安全的。可以改为AtomicInteger的对象数组来作为计数器。 int[] words = new int[23]; Stream.of(roomList).parallel().forEach(s->{ if(s.size()<10){ words[s.size()]++; } });

IntStream.range(0,roomList.size()).forEach(i->{System.out.println(roomList.get(i)); });

interface MyFunc{ T func(int a); default String getName(){ return "Hello Java8!"; } }

interface MyFunc{ default String getName(){ return "Hello Java8!"; } } interface Named(){ default String getName(){ return "Hello atguigu!"; } } class MyClass implements MyFunc,Named{ public String getName(){ return Named.super.getName(); } }

interface Named{ public Integer myFunc(); default String getName(){ return "Hello atguigu!"; } static void show(){ System.out.println("Hello Lambda!"); } }

Instant instant_1 = Instant.now(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } Instant instant_2 = Instant.now(); Duration duration = Duration.between(instant_1, instant_2); System.out.println(duration.toMillis()); // 运行结果：1000 LocalTime localTime_1 = LocalTime.now(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } LocalTime localTime_2 = LocalTime.now(); System.out.println(Duration.between(localTime_1, localTime_2).toMillis()); // 运行结果：1000 LocalDate localDate_1 = LocalDate.of(2018,9, 9); LocalDate localDate_2 = LocalDate.now(); Period period = Period.between(localDate_1, localDate_2); System.out.println(period.getYears()); // 运行结果：1 System.out.println(period.getMonths()); // 运行结果：1 System.out.println(period.getDays()); // 运行结果：18

LocalDate nextSunday = LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.SUNDAY)); //获取下个周日 LocalDateTime localDateTime1 = LocalDateTime.now(); System.out.println(localDateTime1); // 2019-10-27T14:19:56.884 // 获取这个第一天的日期 System.out.println(localDateTime1.with(TemporalAdjusters.firstDayOfMonth())); // 2019-10-01T14:22:58.574 // 获取下个周末的日期 System.out.println(localDateTime1.with(TemporalAdjusters.next(DayOfWeek.SUNDAY)));

DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ISO_DATE; LocalDateTime localDateTime = LocalDateTime.now(); String strDate1 = localDateTime.format(dateTimeFormatter1); System.out.println(strDate1); // 运行结果：2019-10-27 // Date -> String DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy-MM-ddHH:mm:ss"); String strDate2 = dateTimeFormatter2.format(localDateTime); System.out.println(strDate2); // 运行结果：2019-10-2714:36:11 // String -> Date LocalDateTime localDateTime1 = localDateTime.parse(strDate2, dateTimeFormatter2); System.out.println(localDateTime1); // 运行结果：2019-10-27T14:37:39

// 获取所有的时区 Set set = ZoneId.getAvailableZoneIds(); // 通过时区构建LocalDateTime LocalDateTime localDateTime1 = LocalDateTime.now(ZoneId.of("America/El_Salvador")); System.out.println(localDateTime1); // 2019-10-27T00:46:21.268 // 以时区格式显示时间 LocalDateTime localDateTime2 = LocalDateTime.now(); ZonedDateTime zonedDateTime1 = localDateTime2.atZone(ZoneId.of("Africa/Nairobi")); System.out.println(zonedDateTime1); // 2019-10-27T14:46:21.273+03:00[Africa/Nairobi]

类（java.util.Optional） 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。常用方法：
● Optional.of(T t)：创建一个 Optional 实例；
● Optional.empty()：创建一个空的 Optional 实例；
● Optional.ofNullable(T t)：若 t 不为 null,创建 Optional 实例,否则创建空实例；
● isPresent()：判断是否包含值；
● orElse(T t)：如果调用对象包含值，返回该值，否则返回t；
● orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回 s 获取的值；
● map(Function f)：如果有值对其处理，并返回处理后的 Optional，否则返回 Optional.empty()；
● flatMap(Function mapper)：与 map 类似，要求返回值必须是Optional；

public class Java8Tester { public static void main(String args[]){ Java8Tester java8Tester = new Java8Tester(); Integer value1 = null; Integer value2 = new Integer(10); // Optional.ofNullable - 允许传递为 null 参数 Optional a = Optional.ofNullable(value1); // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException Optional b = Optional.of(value2); System.out.println(java8Tester.sum(a,b)); } public Integer sum(Optional a, Optional b){ // Optional.isPresent - 判断值是否存在 System.out.println("第一个参数值存在: " + a.isPresent()); System.out.println("第二个参数值存在: " + b.isPresent()); // Optional.orElse - 如果值存在，返回它，否则返回默认值 Integer value1 = a.orElse(new Integer(0)); //Optional.get - 获取值，值需要存在 Integer value2 = b.get(); return value1 + value2; } } //输出结果: 第一个参数值存在: false 第二个参数值存在: true 10

【2】重复注解与类型注解：Java8 对注解处理提供了两点改进，可重复的注解及可用于类型的注解。如下自定义可重复注解：使用 @Repeatable 元注解，参数为可重复注解的容器。

@Repeatable(MyAnnotations.class) @Target({ ElementType.TYPE, ElementType.FIELD, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) public @interface MyAnnotation { String value() default "java8"; } /** * 容器类 */ @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) @Retention(RetentionPolicy.RUNTIME) public @interface RepetitionAnnotations { RepetitionAnnotation[] value(); }

【测试方法】

public class AnnotationTest { @Test public void t1() throws Exception { Class clazz = AnnotationTest.class; Method method = clazz.getMethod("show"); // 获取方法上的注解 RepetitionAnnotation[] ras = method.getAnnotationsByType(RepetitionAnnotation.class); for (RepetitionAnnotation repetitionAnnotation : ras) { System.out.println(repetitionAnnotation.value()); } } @RepetitionAnnotation("Hello") @RepetitionAnnotation("World") public void show() { } }

【类型注解】

//就是向 @Target 添加一种类型 TYPE_PARAMETER @Repeatable(RepetitionAnnotations.class) @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER}) @Retention(RetentionPolicy.RUNTIME) public @interface RepetitionAnnotation { String value() default "ling"; } //使用 @RepetitionAnnotation("Hello") @RepetitionAnnotation("World") public void show(@RepetitionAnnotation String str) {}

文章来源：https://javajgs.com/archives/...
看到这里今天的分享就结束了，如果觉得这篇文章还不错，来个分享、点赞、在看三连吧，让更多的人也看到～
欢迎关注个人公众号 「JavaClub」，定期为你分享一些技术干货。
【JAVA 1.8 新特性 Lamdba】
文章图片

推荐阅读

• 

  咸阳装修公司口碑最好 咸阳装修
• 

  风流果树种植方法，风流果种植栽培技术
• 

  恋爱中常吃醋的人有哪些表现 恋爱中的人为什么都容易吃醋
• 

  病人|如果你是卒中病人，如果你有这些不良习惯和错误观念……
• 

  尿蛋白1十需要治疗吗 尿蛋白高是怎么回事
• 

  牛油果能去火吗 吃牛油果去火吗
• 

  按摩八髎有什么作用
• 

  mysql几种连接方式 mysql怎么建立链接
• 

  英雄联盟9.16版本,潘森重做上线,技能逆天,网友：妥妥的上单霸主,如何评价？
• 

  vlan划分的目的是什么 为什么要划分vlan
• 

  涂防冻液只能冬天给车用吗,蚂蚁庄园防冻液12月25日答案
• 

  卫生统计数据分析报告,机构能源消耗统计数据分析报告
• 

  怀孕5个月了，能不能吃鸭血啊
• 

  2023年宁波九龙湖半程马拉松报名指南 2021宁波九龙湖马拉松报名
• 

  watchout,look out
• 

  佳能墨盒芯片怎么清零的-佳能打印机ip3680墨水计数怎么清零，要详细
• 

  自制葡萄酒的正确做法 自制葡萄酒怎么做
• 

  mysql数据库字段类型有哪些 mysql常用字段名
• 

  哪里有比较好用的pdf编辑器？
• 

  实验小学,附属小学,普通小学,有什么区别,都是什么意思？

• Java|Java基础——数组
• 人工智能|干货！人体姿态估计与运动预测
• java简介|Java是什么（Java能用来干什么？）
• Java|规范的打印日志
• Linux|109 个实用 shell 脚本
• 程序员|【高级Java架构师系统学习】毕业一年萌新的Java大厂面经，最新整理
• Spring注解驱动第十讲--@Autowired使用
• SqlServer|sql server的UPDLOCK、HOLDLOCK试验
• jvm|【JVM】JVM08(java内存模型解析[JMM])
• 技术|为参加2021年蓝桥杯Java软件开发大学B组细心整理常见基础知识、搜索和常用算法解析例题（持续更新...)