java lamada表达式使用总结

首先创建一个实体类，在下面的例子中会用到它

class Player{ // 例子中使用到的实体类

    public Player(int inAgeOut, 
                  String inNameOut, 
                  int inHeightOut, 
                  int inWeightOut, 
                  String inHomeOut) {
        age = inAgeOut;
        name = inNameOut;
        height = inHeightOut;
        weight = inWeightOut;
        home = inHomeOut;
    }

    private int age;
    private String name;
    private int height; 
    private int weight; 
    private String home;
    public int getAge() {
        return age;
    }
    public void setAge(int inAgeOut) {
        age = inAgeOut;
    }
    public String getName() {
        return name;
    }
    public void setName(String inNameOut) {
        name = inNameOut;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int inHeightOut) {
        height = inHeightOut;
    }
    public int getWeight() {
        return weight;
    }
    public void setWeight(int inWeightOut) {
        weight = inWeightOut;
    }
    public String getHome() {
        return home;
    }
    public void setHome(String inHomeOut) {
        home = inHomeOut;
    }
    @Override
    public String toString() {
        return "来自" + home + "的" + name +"今年"+ age+"岁了";
    } 
}

lamada 之for循环。

public static void main(String[] args) {
    String[] atp =  {"Rafael Nadal", "Novak Djokovic",  
               "Stanislas Wawrinka",  
               "David Ferrer","Roger Federer",  
               "Andy Murray","Tomas Berdych",  
               "Juan Martin Del Potro"};  
    List<String> players = Arrays.asList(atp);
    // 以前的循环方式
    for(String player : players) {
        System.out.println(player + ";");
    }
    System.out.println("------------------------");
    // lamada
    players.forEach( p -> System.out.println(p));

    // 在java 8中使用双冒号操作符
    players.forEach(System.out::println);
}

lamada实现排序
使用集合的stream().sorted()方法不会改变集合本身顺序，只能在sorted()方法之后加上对应的操作方法。
如果要实质性地改变一个集合的排序那么应该使用Collections.sort() 或者 数组的 Arrays.sort()方法。

// lamada排序  **********************************************
// 数组 -- Arrays.sort   集合 -- Collections.sort
public static String main(String[] args) {
    List<Player> myPlayers = Arrays.asList(
        new Player(52, "Novak Djokovic", 54, 80, "德克萨斯州"),
        new Player(31, "Stanislas Wawrinka", 54, 80, "加利福尼亚州"),
        new Player(21, "David Ferrer", 54, 80, "迈阿密"),
        new Player(20, "Roger Federer", 54, 80, "宾夕法尼亚州"),
        new Player(20, "Andy Murray", 54, 80, "新墨西哥州"),
        new Player(18, "Tomas Berdych", 54, 80, "犹他州"), 
        new Player(16, "Juan Martin Del Potro", 54, 80, "密西西比州"),
        new Player(19, "Richard Gasquet", 54, 80, "阿拉斯加州"));

    myPlayers.forEach(p -> System.out.println(p));

    System.out.println("stream()流排序不会改变集合本身-------------------------------");
    myPlayers.stream().sorted((p1, p2) -> p1.getAge() - p2.getAge()).forEach(p -> System.out.println(p));
    System.out.println("stream()流排序不会改变集合本身-------------------------------");
    myPlayers.forEach(p -> System.out.println(p));

    // 传统排序
    System.out.println("---------------------------------------------");
    myPlayers.sort(new Comparator<Player>() {
        @Override
        public int compare(Player p1, Player p2) {
            return p1.getAge() - p2.getAge();
        }
    });
    myPlayers.forEach(p -> System.out.println(p));

    // lamada表达式实现排序(Arrays.sort  和 Collections.sort)
    System.out.println("---------------------------------------------");
    Collections.sort(myPlayers, (p1, p2) -> p1.getAge() - p2.getAge());
    myPlayers.forEach(p -> System.out.println(p));
}       

lamada实现过滤
stream().filter()的过滤也不会改变集合本身。

/* lamada表达式实现过滤**********************************/
public static void main(String[] args) {
    System.out.println("表达式实现过滤 ， 输出年龄小于20岁的运动员---------------");
    Consumer<Player> addWeight = e -> e.setWeight(e.getWeight() + 10);
    myPlayers.forEach(addWeight);
    myPlayers.stream().filter(p -> p.getAge() < 20).forEach(p -> System.out.println(p));
    System.out.println("表达式实现过滤 ，最前面的3个-------------------");
    myPlayers.stream().limit(10).forEach(p -> System.out.println(p));
    System.out.println("表达式实现过滤 ，找出年龄最小的------------------");
    Player play = myPlayers.stream().min((p1, p2) -> p1.getAge() - p2.getAge()).get();
    System.out.println(play);
    System.out.println("表达式实现过滤 ，找出年龄最大的--------------------");
    play = myPlayers.stream().max((p1, p2) -> p1.getAge() - p2.getAge()).get();
    System.out.println(play);
}

将集合过滤并转成新的集合或其他的操作
toSet, toList, joining

Set set = myPlayers.stream().map(Player::getAge).collect(Collectors.toSet());
String string = myPlayers.stream().map(Player :: getName).collect(Collectors.joining("--"));

lamada计算

public static void main(String[] args) {
    int s = myPlayers.stream().mapToInt(p -> p.getWeight()).sum();
    System.out.println(s);
    long ss = myPlayers.stream().mapToInt(p -> p.getWeight()).count();
    System.out.println(ss);

    //计算 count, min, max, sum, and average for numbers  
    IntSummaryStatistics playerCalc = myPlayers.stream().mapToInt((x) -> x.getAge()).summaryStatistics();  
    System.out.println("List中最大的数字 : " + playerCalc.getMax());  
    System.out.println("List中最小的数字 : " + playerCalc.getMin());  
    System.out.println("所有数字的总和   : " + playerCalc.getSum());  
    System.out.println("所有数字的平均值 : " + playerCalc.getAverage());   

    //计算 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());
}