Java自學-Lambda 聚合操做

時間 2020-02-24

標籤 java 自學 lambda 聚合欄目 Java 简体版

原文原文鏈接

java 集合的聚合操做

步驟 1 : 傳統方式與聚合操做方式遍歷數據html

遍歷數據的傳統方式就是使用for循環，而後條件判斷，最後打印出知足條件的數據java

for (Hero h : heros) {
   if (h.hp > 100 && h.damage < 50)
      System.out.println(h.name);
}

使用聚合操做方式，畫風就發生了變化：數組

heros
    .stream()
    .filter(h -> h.hp > 100 && h.damage < 50)
    .forEach(h -> System.out.println(h.name));

package lambda;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
import charactor.Hero;
 
public class TestAggregate {
 
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
 
        System.out.println("初始化後的集合：");
        System.out.println(heros);
        System.out.println("查詢條件：hp>100 && damage<50");
        System.out.println("經過傳統操做方式找出知足條件的數據：");
 
        for (Hero h : heros) {
            if (h.hp > 100 && h.damage < 50)
                System.out.println(h.name);
        }
 
        System.out.println("經過聚合操做方式找出知足條件的數據：");
        heros
            .stream()
            .filter(h -> h.hp > 100 && h.damage < 50)
            .forEach(h -> System.out.println(h.name));
 
    }
}

步驟 2 : Stream和管道的概念dom

heros
    .stream()
    .filter(h -> h.hp > 100 && h.damage < 50)
    .forEach(h -> System.out.println(h.name));

要了解聚合操做，首先要創建Stream和管道的概念
Stream 和Collection結構化的數據不同，Stream是一系列的元素，就像是生產線上的罐頭同樣，一串串的出來。
管道指的是一系列的聚合操做。ide

管道又分3個部分
管道源：在這個例子裏，源是一個List
中間操做：每一箇中間操做，又會返回一個Stream，好比.filter()又返回一個Stream, 中間操做是「懶」操做，並不會真正進行遍歷。
結束操做：當這個操做執行後，流就被使用「光」了，沒法再被操做。因此這一定是流的最後一個操做。結束操做不會返回Stream，可是會返回int、float、String、 Collection或者像forEach，什麼都不返回, 結束操做才進行真正的遍歷行爲，在遍歷的時候，纔會去進行中間操做的相關判斷this

注：這個Stream和I/O章節的InputStream,OutputStream是不同的概念。code

步驟 3 : 管道源htm

把Collection切換成管道源很簡單，調用stream()就好了。對象

heros.stream()

可是數組卻沒有stream()方法，須要使用blog

Arrays.stream(hs)

或者

Stream.of(hs)

package lambda;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
 
import charactor.Hero;
 
public class TestAggregate {
 
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        //管道源是集合
        heros
        .stream()
        .forEach(h->System.out.println(h.name));
         
        //管道源是數組
        Hero hs[] = heros.toArray(new Hero[heros.size()]);
        Arrays.stream(hs)
        .forEach(h->System.out.println(h.name));
         
    }
}

步驟 4 : 中間操做

每一箇中間操做，又會返回一個Stream，好比.filter()又返回一個Stream, 中間操做是「懶」操做，並不會真正進行遍歷。
中間操做比較多，主要分兩類：
對元素進行篩選和轉換爲其餘形式的流

對元素進行篩選：
filter 匹配
distinct 去除重複(根據equals判斷)
sorted 天然排序
sorted(Comparator ) 指定排序
limit 保留
skip 忽略

轉換爲其餘形式的流：
mapToDouble 轉換爲double的流
map 轉換爲任意類型的流

package charactor;
      
public class Hero implements Comparable<Hero>{
    public String name;
    public float hp;
         
    public int damage;
         
    public Hero(){
            
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getHp() {
        return hp;
    }
    public void setHp(float hp) {
        this.hp = hp;
    }
    public int getDamage() {
        return damage;
    }
    public void setDamage(int damage) {
        this.damage = damage;
    }
    public Hero(String name) {
        this.name =name;
    }
    //初始化name,hp,damage的構造方法
    public Hero(String name,float hp, int damage) {
        this.name =name;
        this.hp = hp;
        this.damage = damage;
    }
    
    @Override
    public int compareTo(Hero anotherHero) {
        if(damage<anotherHero.damage)
            return 1; 
        else
            return -1;
    }
    
    @Override
    public String toString() {
        return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]\r\n";
    }
        
}
package lambda;
  
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
import charactor.Hero;
  
public class TestAggregate {
  
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        //製造一個重複數據
        heros.add(heros.get(0));
        System.out.println("初始化集合後的數據 (最後一個數據重複)：");
        System.out.println(heros);
        System.out.println("知足條件hp>100&&damage<50的數據");
          
        heros
            .stream()
            .filter(h->h.hp>100&&h.damage<50)
            .forEach(h->System.out.print(h));
          
        System.out.println("去除重複的數據，去除標準是看equals");
        heros
            .stream()
            .distinct()
            .forEach(h->System.out.print(h));
        System.out.println("按照血量排序");
        heros
            .stream()
            .sorted((h1,h2)->h1.hp>=h2.hp?1:-1)
            .forEach(h->System.out.print(h));
          
        System.out.println("保留3個");
        heros
            .stream()
            .limit(3)
            .forEach(h->System.out.print(h));
          
        System.out.println("忽略前3個");
        heros
            .stream()
            .skip(3)
            .forEach(h->System.out.print(h));
          
        System.out.println("轉換爲double的Stream");
        heros
            .stream()
            .mapToDouble(Hero::getHp)
            .forEach(h->System.out.println(h));
          
        System.out.println("轉換任意類型的Stream");
        heros
            .stream()
            .map((h)-> h.name + " - " + h.hp + " - " + h.damage)
            .forEach(h->System.out.println(h));
          
    }
}

步驟 5 : 結束操做

當進行結束操做後，流就被使用「光」了，沒法再被操做。因此這一定是流的最後一個操做。結束操做不會返回Stream，可是會返回int、float、String、 Collection或者像forEach，什麼都不返回,。
結束操做才真正進行遍歷行爲，前面的中間操做也在這個時候，才真正的執行。

常見結束操做以下：

forEach() 遍歷每一個元素
toArray() 轉換爲數組
min(Comparator ) 取最小的元素
max(Comparator ) 取最大的元素
count() 總數
findFirst() 第一個元素

package lambda;
  
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
 
import org.omg.Messaging.SYNC_WITH_TRANSPORT;
 
import charactor.Hero;
  
public class TestAggregate {
  
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        System.out.println("遍歷集合中的每一個數據");
        heros
            .stream()
            .forEach(h->System.out.print(h));
        System.out.println("返回一個數組");
        Object[] hs= heros
            .stream()
            .toArray();
        System.out.println(Arrays.toString(hs));
        System.out.println("返回傷害最低的那個英雄");
        Hero minDamageHero =
        heros
            .stream()
            .min((h1,h2)->h1.damage-h2.damage)
            .get();
        System.out.print(minDamageHero);
        System.out.println("返回傷害最高的那個英雄");
 
        Hero mxnDamageHero =
                heros
                .stream()
                .max((h1,h2)->h1.damage-h2.damage)
                .get();
        System.out.print(mxnDamageHero);     
         
        System.out.println("流中數據的總數");
        long count = heros
                .stream()
                .count();
        System.out.println(count);
 
        System.out.println("第一個英雄");
        Hero firstHero =
                heros
                .stream()
                .findFirst()
                .get();
         
        System.out.println(firstHero);
         
    }
}

練習：聚合操做

首選準備10個Hero對象，hp和damage都是隨機數。
分別用傳統方式和聚合操做的方式，把hp第三高的英雄名稱打印出來

答案 :

package lambda;
  
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
 
import charactor.Hero;
  
public class TestAggregate {
  
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for (int i = 0; i < 10; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
 
        System.out.println("初始化集合後的數據 (最後一個數據重複)：");
        System.out.println(heros);
         
        //傳統方式
        Collections.sort(heros,new Comparator<Hero>() {
            @Override
            public int compare(Hero o1, Hero o2) {
                return (int) (o2.hp-o1.hp);
            }
        });
         
        Hero hero = heros.get(2);
        System.out.println("經過傳統方式找出來的hp第三高的英雄名稱是:" + hero.name);
         
        //聚合方式
        String name =heros
            .stream()
            .sorted((h1,h2)->h1.hp>h2.hp?-1:1)
            .skip(2)
            .map(h->h.getName())
            .findFirst()
            .get();
 
        System.out.println("經過聚合操做找出來的hp第三高的英雄名稱是:" + name);
         
    }
}