欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java 8 lambda表达式引入详解及实例

程序员文章站 2024-02-17 10:01:58
java 8 lambda表达式引入详解及实例 eclipse 下载安装 help -> eclipsemarketplace -> 搜索java 8 ke...

java 8 lambda表达式引入详解及实例

eclipse 下载安装

help -> eclipsemarketplace -> 搜索java 8 kepler ->java 8 support for eclipse kepler sr2 安装完成后需要重启

android studio

在project的build.gradle文件中添加

buildscript {
  dependencies {
    classpath 'me.tatarka:gradle-retrolambda:3.2.5'
  }
}

在app的build.gradle文件中添加

apply plugin: 'me.tatarka.retrolambda'

android {
  compileoptions {
    sourcecompatibility javaversion.version_1_8
    targetcompatibility javaversion.version_1_8
  }
}

 

使用

import java.util.arraylist;
import java.util.arrays;
import java.util.comparator;
import java.util.list;
import java.util.optional;
import java.util.function.predicate;
import java.util.stream.collectors;
import java.util.stream.stream;
import java.util.stream.stream.builder;
 
public class lambdatest {
 
 public static void main(string[] args) {
 
  string[] str = new string[] { "lambdas", "lambdas", "default method", "stream api", "date and time api" };
  list<string> strlist = arrays.aslist(str);
 
  system.out.println("----------------------------> 默认遍历");
  strlist.stream().foreach(item -> {
   system.out.println(item);
  });
  system.out.println("----------------------------> 默认遍历简化写法");
  strlist.stream().foreach(system.out::println);
 
  // limit输出指定个数
  system.out.println("limit ---------------------------->");
  strlist.stream().limit(2).foreach(system.out::println);
 
  // 去掉重复数据
  system.out.println("distinct ---------------------------->");
  strlist.stream().distinct().foreach(system.out::println);
 
  // filter过滤器,筛选出符合条件的值
  system.out.println("filter ---------------------------->");
  predicate<string> contain = item -> item.contains("api");// 只是用于匹配条件的如int可以用条件运算符等
  strlist.stream().filter(contain).foreach(system.out::println);
  system.out.println("filter简化写法 ---------------------------->");
  strlist.stream().filter(item -> item.contains("api")).foreach(system.out::println);
 
  system.out.println("and ---------------------------->");
  predicate<string> contain1 = item -> item.contains("api");
  predicate<string> contain2 = item -> item.contains("time");
  strlist.stream().filter(contain1.and(contain2)).foreach(system.out::println);
  system.out.println("or ---------------------------->");
  strlist.stream().filter(contain1.or(contain2)).foreach(system.out::println);
 
  // 向每个字符后追加
  system.out.println("map ---------------------------->");
  // 对stream中包含的元素使用给定的转换函数进行转换操作,生成的stream只包含转换生成的元素。
  // maptoint,maptolong和maptodouble是对int、long、double进行操作的
  strlist.stream().map(item -> item + string.valueof(1)).foreach(system.out::println);
 
  // 向每个字符后追加
  system.out.println("flatmap ---------------------------->");
  // flatmap:和map类似,不同的是其每个元素转换得到的是stream对象,会把子stream中的元素压缩到父集合
  strlist.stream().flatmap(item -> getcharacter(item)).foreach(system.out::println);
 
  system.out.println("peek ---------------------------->");
  // peek 需调用collect
  strlist.stream().map(string::touppercase).peek(system.out::println).collect(collectors.tolist());
 
  system.out.println("skip ---------------------------->");
  // 丢弃原stream的前n个元素后剩下元素组成的新stream
  strlist.stream().skip(3).foreach(system.out::println);
 
  // 统计个数
  system.out.println("count ---------------------------->" + strlist.stream().count());
 
  // allmatch:是不是stream中的所有元素都满足给定的匹配条件
  boolean allmatch1 = strlist.stream().allmatch(item -> item.contains("a"));
  system.out.println("allmatch --------------> " + allmatch1);
  boolean allmatch2 = strlist.stream().allmatch(item -> item.contains("api"));
  system.out.println("allmatch --------------> " + allmatch2);
 
  // anymatch:stream中是否存在任何一个元素满足匹配条件
  boolean anymatch1 = strlist.stream().anymatch(item -> item.contains("stream api"));
  system.out.println("anymatch --------------> " + anymatch1);
  boolean anymatch2 = strlist.stream().anymatch(item -> item.contains("stream api1"));
  system.out.println("anymatch --------------> " + anymatch2);
 
  // findfirst: 返回stream中的第一个元素,如果stream为空,返回空optional
  optional<string> findfirst = strlist.stream().findfirst();
  // ispresent方法用来检查optional实例是否有值。
  if (findfirst.ispresent()) {
   // 调用get()返回optional值。如果optional没有值调和则抛出nosuchelementexception。
   system.out.println("findfirst --------------> " + findfirst.get());
  }
  system.out.print("findfirst简化写法 --------------> ");
  // 如果存在值,则使用该值调用,否则不执行任何操作。
  strlist.stream().findfirst().ifpresent(system.out::println);
 
  // nonematch:是不是stream中的所有元素都不满足给定的匹配条件
  boolean nonematch1 = strlist.stream().nonematch(item -> item.contains("stream api"));
  system.out.println("nonematch --------------> " + nonematch1);
  boolean nonematch2 = strlist.stream().nonematch(item -> item.contains("zzzzz"));
  system.out.println("nonematch --------------> " + nonematch2);
 
  system.out.println("newstrlist ---------------------------->");
  list<string> newstrlist = strlist.stream().filter(item -> item != null)
    .collect(() -> new arraylist<string>(), (list, item) -> list.add(item), (list1, list2) -> list1.addall(list2));
  newstrlist.stream().foreach(system.out::println);
  system.out.println("newstrlist简化写法 ---------------------------->");
  list<string> newstrlist1 = strlist.stream().filter(item -> item != null).collect(collectors.tolist());
  newstrlist1.stream().foreach(system.out::println);
 
  system.out.println("sorted 排序---------------------------->");
  // strlist.stream().sorted();
  strlist.stream().sorted(comparator.comparing(string::length)).foreach(system.out::println);
  ;
 
  // max和min:使用给定的比较器(operator),返回stream中的最大|最小值
  integer[] ints = new integer[] { 7, 2, 3, 10, 5, 1, 6, 8, 9, 4 };
  list<integer> intlist = new arraylist<integer>();
  intlist = arrays.aslist(ints);
  system.out.print("max --------------> ");
  intlist.stream().max((o1, o2) -> o1.compareto(o2)).ifpresent(system.out::println);
  system.out.print("max简化写法 --------------> ");
  // comparable<integer> integer.compare(int arg0, int arg1)
  intlist.stream().max(integer::compare).ifpresent(system.out::println);
  system.out.print("min --------------> ");
  intlist.stream().min((o1, o2) -> o1.compareto(o2)).ifpresent(system.out::println);
  system.out.print("min简化写法 --------------> ");
  // comparable<integer> integer.compare(int arg0, int arg1)
  intlist.stream().min(integer::compare).ifpresent(system.out::println);
 
  system.out.println("reduce单参数 ---------------------------->");
  system.out.println(intlist.stream().reduce((result, element) -> result = result + element));
  system.out.println("reduce双参数 ---------------------------->");
  system.out.println(intlist.stream().reduce(0, (result, element) -> result = result + element));
 
  system.out.println("generate ---------------------------->");
  // 生成一个无限长度的stream,其中值是随机的。这个无限长度stream是懒加载,一般这种无限长度的stream都会配合stream的limit()方法来用。
  stream.generate(math::random).limit(2).foreach(system.out::println);
 
  system.out.println("iterate ---------------------------->");
  // 也是生成无限长度的stream,和generator不同的是,其元素的生成是重复对给定的种子值,调用用户指定函数来生成的
  stream.iterate(12, item -> item + 1).limit(2).foreach(system.out::println);
 }
 
 public static stream<string> getcharacter(string s) {
  builder<string> builder = stream.builder();
  builder.add(s);
  builder.accept("1");
  return builder.build();
 }
}
  

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!