JDK8特性二之Streams

滴一盘技术
2020-06-11 10:00:49
技术资源分享

 
前天本来已经写完这篇文章了，可是到最后一不小心网页让我退后，回来时所有内容都没有了，悲催啊！！！！！！！！！！！！！！

[========]
好，开始我们今天的主题，stream的认识之路，首先在认识之前，如果你还没有了解什么是lLambda表达式,请你移步到JDK8特性一之Lambda表达式。

什么是Stream

Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream，也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。我们先来个例子。

 
//Java 7 的排序、取值实现
  List<Transaction> groceryTransactions = new Arraylist<>();
  for(Transaction t: transactions){
   if(t.getType() == Transaction.GROCERY){
   groceryTransactions.add(t);
   }
  }
  Collections.sort(groceryTransactions, new Comparator(){
   public int compare(Transaction t1, Transaction t2){
   return t2.getValue().compareTo(t1.getValue());
   }
  });
  List<Integer> transactionIds = new ArrayList<>();
  for(Transaction t: groceryTransactions){
   transactionsIds.add(t.getId());
  }
  //Java 8 使用 Stream，代码更加简洁易读；而且使用并发模式，程序执行速度更快。
  List<Integer> transactionsIds = transactions.parallelStream(). //数值流的构造
   filter(t -> t.getType() == Transaction.GROCERY). //
   sorted(comparing(Transaction::getValue).reversed()).//排序
   map(Transaction::getId). //1 1对应
   collect(toList()); //转换数据结构

看，是不是简单多了，好，我们开始说明Stream的各个部分

构造与转换构造流的几种常见方法

 
// 1. Individual values
  Stream stream = Stream.of("a", "b", "c");
  // 2. Arrays
  String [] strArray = new String[] {"a", "b", "c"};
  stream = Stream.of(strArray);
  stream = Arrays.stream(strArray);
  // 3. Collections
  List<String> list = Arrays.asList(strArray);
  stream = list.stream();

但是对于基本类型还有不同的方法对于基本数值型，目前有三种对应的包装类型 Stream：

IntStream、LongStream、DoubleStream。当然我们也可以用 Stream、Stream >、Stream

 
//数值流的构造
  IntStream.of(new int[]{1, 2, 3}).forEach(System.out::println);
  IntStream.range(1, 3).forEach(System.out::println);
  IntStream.rangeClosed(1, 3).forEach(System.out::println);

转换为其它数据结构

 
// 1. 转换成数组(Array)
  String[] strArray1 = stream.toArray(String[]::new);
  // 2. Collection(集合)
  List<String> list1 = stream.collect(Collectors.toList());
  List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
  Set set1 = stream.collect(Collectors.toSet());
  Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
  // 3. String(字符串)
  String str = stream.collect(Collectors.joining()).toString();

其他方法

在说之前，我们create一个类用来当例子:

 
public class Person {  
  
  private String firstName, lastName, job, gender;  
  private int salary, age;  
  
  public Person(String firstName, String lastName, String job,  
                  String gender, int age, int salary)       {  
            this.firstName = firstName;  
            this.lastName = lastName;  
            this.gender = gender;  
            this.age = age;  
            this.job = job;  
            this.salary = salary;  
  }  
  // Getter and Setter   
  // . . . . .  
  }

再new几个person的对象.

 
List<Person> javaProgrammers = new ArrayList<Person>() {  
    {  
      add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));  
      add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));  
      add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));  
      add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));  
      add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));  
      add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900));  
      add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300));  
      add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700));  
      add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000));  
      add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300));  
    }  
  };  
  
  List<Person> phpProgrammers = new ArrayList<Person>() {  
    {  
      add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550));  
      add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200));  
      add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600));  
      add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000));  
      add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100));  
      add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300));  
      add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100));  
      add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000));  
      add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600));  
      add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800));  
    }  
  };

现在我们使用forEach方法来迭代输出上述列表(Lambda表达式):

 
System.out.println("所有程序员的姓名:");  
  javaProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));  
  phpProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

我们同样使用forEach方法,增加程序员的工资5%:

 
System.out.println("给程序员加薪 5% :");  
  Consumer<Person> giveRaise = e -> e.setSalary(e.getSalary() / 100 * 5 + e.getSalary());  
  
  javaProgrammers.forEach(giveRaise);  
  phpProgrammers.forEach(giveRaise);

复习完了，我们开始说stream的方法

过滤器filter

 
//显示月薪超过1400美元的PHP程序员
  System.out.println("下面是月薪超过 $1,400 的PHP程序员:")  
  phpProgrammers.stream()  
            .filter((p) -> (p.getSalary() > 1400))  
            .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

我们也可以定义过滤器,然后重用它们来执行其他操作:

 
// 定义 filters  
  Predicate<Person> ageFilter = (p) -> (p.getAge() > 25);  
  Predicate<Person> salaryFilter = (p) -> (p.getSalary() > 1400);  
  Predicate<Person> genderFilter = (p) -> ("female".equals(p.getGender()));  
  
  System.out.println("下面是年龄大于 24岁且月薪在$1,400以上的女PHP程序员:");  
  phpProgrammers.stream()  
            .filter(ageFilter)  
            .filter(salaryFilter)  
            .filter(genderFilter)  
            .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));  
  
  // 重用filters  
  System.out.println("年龄大于 24岁的女性 Java programmers:");  
  javaProgrammers.stream()  
            .filter(ageFilter)  
            .filter(genderFilter)  
            .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

limit方法,限制结果数量

 
System.out.println("最前面的3个 Java programmers:");  
  javaProgrammers.stream()  
            .limit(3)  
            .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));  
  
  
  System.out.println("最前面的3个女性 Java programmers:");  
  javaProgrammers.stream()  
            .filter(genderFilter)  
            .limit(3)  
            .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

排序sorted

 
System.out.println("根据 name 排序,并显示前5个 Java programmers:");  
  List<Person> sortedJavaProgrammers = javaProgrammers  
            .stream()  
            .sorted((p, p2) -> (p.getFirstName().compareTo(p2.getFirstName())))  
            .limit(5)  
            .collect(toList());  
  
  sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));  
  
  System.out.println("根据 salary 排序 Java programmers:");  
  sortedJavaProgrammers = javaProgrammers  
            .stream()  
            .sorted( (p, p2) -> (p.getSalary() - p2.getSalary()) )  
            .collect( toList() );  
  
  sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));

min和max方法

 
System.out.println("工资最低的 Java programmer:");  
  Person pers = javaProgrammers  
            .stream()  
            .min((p1, p2) -> (p1.getSalary() - p2.getSalary()))  
            .get()  
  
  System.out.printf("Name: %s %s; Salary: $%,d.", pers.getFirstName(), pers.getLastName(), pers.getSalary())  
  
  System.out.println("工资最高的 Java programmer:");  
  Person person = javaProgrammers  
            .stream()  
            .max((p, p2) -> (p.getSalary() - p2.getSalary()))  
            .get()  
  
  System.out.printf("Name: %s %s; Salary: $%,d.", person.getFirstName(), person.getLastName(), person.getSalary())

map/flatMap

我们先来看 map。如果你熟悉 scala 这类函数式语言，对这个方法应该很了解，它的作用就是把 input Stream 的每一个元素，映射成 output Stream 的另外一个元素。

 
//转换大写
  List<String> output = wordList.stream().
  map(String::toUpperCase).
  collect(Collectors.toList());
  这段代码把所有的单词转换为大写。

 
//平方数
  
  List<Integer> nums = Arrays.asList(1, 2, 3, 4);
  List<Integer> squareNums = nums.stream().
  map(n -> n * n).
  collect(Collectors.toList());

这段代码生成一个整数 list 的平方数 {1, 4, 9, 16}。

从上面例子可以看出，map 生成的是个 1:1 映射，每个输入元素，都按照规则转换成为另外一个元素。还有一些场景，是一对多映射关系的，这时需要 flatMap。

 
//一对多
  Stream<List<Integer>> inputStream = Stream.of(
   Arrays.asList(1),
   Arrays.asList(2, 3),
   Arrays.asList(4, 5, 6)
   );
  Stream<Integer> outputStream = inputStream.
  flatMap((childList) -> childList.stream());

flatMap 把 input Stream 中的层级结构扁平化，就是将最底层元素抽出来放到一起，最终 output 的新 Stream 里面已经没有 List 了，都是直接的数字

collect 转换数据结构

 
System.out.println("将 PHP programmers 的 first name 拼接成字符串:");  
  String phpDevelopers = phpProgrammers  
            .stream()  
            .map(Person::getFirstName)  
            .collect(joining(" ; ")); // 在进一步的操作中可以作为标记(token)     
  
  System.out.println("将 Java programmers 的 first name 存放到 Set:");  
  Set<String> javaDevFirstName = javaProgrammers  
            .stream()  
            .map(Person::getFirstName)  
            .collect(toSet());  
  
  System.out.println("将 Java programmers 的 first name 存放到 TreeSet:");  
  TreeSet<String> javaDevLastName = javaProgrammers  
            .stream()  
            .map(Person::getLastName)  
            .collect(toCollection(TreeSet::new));

并行的(parallel)

 
System.out.println("计算付给 Java programmers 的所有money:");  
  int totalSalary = javaProgrammers  
            .parallelStream()  
            .mapToInt(p -> p.getSalary())  
            .sum();

summaryStatistics方法

我们可以使用summaryStatistics方法获得stream 中元素的各种汇总数据

 
//计算 count, min, max, sum, and average for numbers  
  List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);  
  IntSummaryStatistics stats = numbers  
            .stream()  
            .mapToInt((x) -> x)  
            .summaryStatistics();  
  
  System.out.println("List中最大的数字 : " + stats.getMax());  
  System.out.println("List中最小的数字 : " + stats.getMin());  
  System.out.println("所有数字的总和   : " + stats.getSum());  
  System.out.println("所有数字的平均值 : " + stats.getAverage());

 
本文参考与网上的资料，还有不懂得地方，你可以再网站得留言处给我留言。

原创来源：滴一盘技术

上一篇：《Java开发实战1200例（第1卷）》PDF 下载，免费下载，免积分下载
下一篇： nginx均衡配置:upstream支持的负载均衡算法和几种策略

网站简介

第一盘搜索_让网盘资源搜索更简单
第一盘搜索，争做网盘搜索第一盘。专注于百度云网盘、微盘、阿里云盘、文库、在线视频网站的资源嗅探和搜索，让资源搜索查找变得更简单

友情链接

爱推站网站地图

JDK8特性二之Streams

网站简介

热门标签

最新评论

友情链接

JDK8特性二之Streams

网站简介

热门标签

置顶推荐

最新评论

友情链接