java8 lambda

跟着 https://zhuanlan.zhihu.com/p/33477686学的

1.用lambda表达式实现Runnable

public class first {

    /**用lambda表达式实现Runnable
     *(params) -> expression
     *(params) -> statement
     *(params) -> { statements } 
     * @param args
     */
    public static void main(String[] args) {
        //重写内部类
        new Thread(() ->{
            System.out.println("内部类");
        }).start();

    //重写内部类
    new Thread(() ->System.out.println("你好")).start();
    }
}

2. 用Java 8 lambda表达式进行事件处理

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import javax.swing.JButton;
/**
 * 用Java 8 lambda表达式进行事件处理
 * @author dell
 *
 */
public class second {
    public static void main(String[] args) {
        //旧
        JButton show =  new JButton("Show");
        show.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
            System.out.println("Event handling without lambda expression is boring");
            }
        });     

        //新
        show.addActionListener((e) -> {
            System.out.println("Light, Camera, Action !! Lambda expressions Rocks");
        });




        List<Integer> intList = Arrays.asList(1,2,3,4);
        Collections.sort(intList,(o1,o2) -> {
            if(o1>o2){
                return -1;
            }else{
                return 1;
            }
        });

        intList.forEach(System.out::println);

    }

3.使用lambda表达式对列表进行迭代

import java.util.Arrays;
import java.util.List;

//例3、使用lambda表达式对列表进行迭代s
public class third {
    public static void main(String[] args) {

        List<Integer>list = Arrays.asList(1,2,3,4);
        //第一种
        list.forEach(System.out::println);
        //第二种
        list.forEach((x) -> System.out.println(x));

    }
}

4.使用lambda表达式和函数式接口Predicate

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

//例4、使用lambda表达式和函数式接口Predicate
public class fourth {
public static void main(String[] args) {
    List<String>languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
    System.out.println("Languages which starts with J :");
    filter(languages, (str) -> str.startsWith("J"));
    System.out.println("Print all languages :");
    filter(languages,(str) -> true );

    System.out.println("Languages which starts with J :");
    filter2(languages, (str) -> str.startsWith("J"));
    System.out.println("Print all languages :");
    filter2(languages,(str) -> true );

}

public static void filter (List<String >names ,Predicate<String> condition){
    names.forEach((x) -> {
        if(condition.test(x)){
            System.out.println(x);
        }
    });
}

public static void filter2(List<String >names ,Predicate<String> condition){
    names.stream().filter(
            (x) -> (condition.test(x))
    ).forEach(System.out::println);
}
}

如果按以前的写法是

    System.out.println("Languages which starts with J :");
    for(String str: languages){
        if(str.startsWith("J")){
            System.out.println(str);
        }
    }

1）所以对test方法的理解是执行对应的表达式

2）stream.filter这个也可以用来过滤list

标记几个api

Predicate

public interface Predicate<T>
表示一个参数的谓词（布尔值函数）。
这是一个functional interface的功能方法是test(Object) 。

test

boolean test(T t)
在给定的参数上评估这个谓词。
参数
t - 输入参数
结果
true如果输入参数匹配谓词，否则为 false

stream

default Stream<E> stream()
返回一个顺序Stream与此集合作为其来源。
当此方法应该重写spliterator()方法不能返回spliterator是IMMUTABLE ， CONCURRENT ，或后期绑定 。 （详见spliterator() ）
实现要求：
默认的实现创建顺序 Stream从收集的 Spliterator 。
结果
连续 Stream在这个集合中的元素

filter

Stream<T> filter(Predicate<? super T> predicate)
返回由与此给定谓词匹配的此流的元素组成的流。
这是一个intermediate operation 。
参数
predicate -一个 non-interfering ， stateless谓词应用到每个元素，以确定是否它应包含
结果
新的流

5.如何在lambda表达式中加入Predicate

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

//如何在lambda表达式中加入Predicate
public class fifth {
public static void main(String[] args) {
    List<String>languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
    Predicate<String> startsWithJ = (n) -> n.startsWith("J");
    Predicate<String> fourLetterLong = (n) -> n.length() == 4;

    languages.stream()
    .filter(startsWithJ.and(fourLetterLong))
    .forEach((n) -> System.out.print("nName, which starts with 'J' and four letter long is : " + n)); 
}
}

标记api

and

default Predicate<T> and(Predicate<? super T> other)
返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑AND。 当评估组合谓词时，如果此谓词为false ，则不other other谓词。
在评估任一谓词期间抛出的任何异常被中继到调用者; 如果此断言的评价抛出一个异常， other断言不会被评估。

参数
other - 将与此谓词进行逻辑与AND的谓词
结果
一个代表该谓词和other谓词的短路逻辑AND的 other谓词
异常
NullPointerException - 如果其他为空
##### negate
default Predicate<T> negate()
返回表示此谓词的逻辑否定的谓词。
结果
一个表示该谓词的逻辑否定的谓词

or

default Predicate<T> or(Predicate<? super T> other)
返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑或。 当评估组合谓词时，如果此谓词为true ，则不other other谓词。
在评估任一谓词期间抛出的任何异常被中继到调用者; 如果此断言的评价抛出一个异常， other断言不会被评估。

参数
other - 将与此谓词进行逻辑关系的谓词
结果
表示短路逻辑这个谓词的或组成谓词和 other谓词
异常
NullPointerException - 如果其他为空

6.Java 8中使用lambda表达式的Map和Reduce示例

import java.util.Arrays;
import java.util.List;

public class sixth {
public static void main(String[] args) {
    List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);

    costBeforeTax.stream().map((cost) -> cost + 0.12*cost).forEach(System.out::println);

}
}

标记api

map

<R> Stream<R> map(Function<? super T,? extends R> mapper)
返回由给定函数应用于此流的元素的结果组成的流。
这是一个intermediate operation 。

参数类型
R - 新流的元素类型
参数
mapper -一个 non-interfering ， stateless函数应用到每个元件
结果
新的流

import java.util.Arrays;
import java.util.List;

public class sixth {
public static void main(String[] args) {
    List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);

    costBeforeTax.stream().map((cost) -> cost + 0.12*cost).forEach(System.out::println);

    Double total = costBeforeTax.stream().map((cost) -> cost + 0.12*cost).reduce((sum,cost) -> sum+cost).get();

    System.out.println("total:"+total);

}
}

标记api

reduce

Optional<T> reduce(BinaryOperator<T> accumulator)
使用associative累积函数对此流的元素执行reduction ，并返回描述减小值（如果有的话）的Optional 。 这相当于：
   boolean foundAny = false; T result = null; for (T element : this stream) { if (!foundAny) { foundAny = true; result = element; } else result = accumulator.apply(result, element); } return foundAny ? Optional.of(result) : Optional.empty();  
但不限于顺序执行。
accumulator功能必须是associative功能。

这是一个terminal operation 。

参数
accumulator -一个 associative ， non-interfering ， stateless功能组合两个值
结果
一个Optional描述了减少的结果
异常
NullPointerException - 如果减少的结果为空

7.通过过滤创建一个String列表

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

//通过过滤创建一个String列表
public class seventh {
public static void main(String[] args) {
    //需要长度大于2的
    Predicate<String> predicate = (x) -> x.length()> 2;
    List<String> strList = Arrays.asList("abc", "", "bcd", "defg", "jk");   
    List<String> filtered = strList.stream().filter(predicate).collect(Collectors.toList());
    System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered);
}
}

8.对列表的每个元素应用函数

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class eighth {
public static void main(String[] args) {
    List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");
    String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
    System.out.println(G7Countries); 
}
}

标记api

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class eighth {
public static void main(String[] args) {
    List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");
    String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
    System.out.println(G7Countries); 
}
}

collect

<R,A> R collect(Collector<? super T,A,R> collector)
使用Collector对此流的元素执行mutable reduction Collector 。 A Collector将用作参数的函数封装到collect(Supplier, BiConsumer, BiConsumer) ，允许重用集合策略和组合收集操作（如多级分组或分区）。
如果流是并行的，并且Collector是concurrent ，并且流是无序的或收集器是unordered ，则将执行并发的减少（有关并发减少的细节，请参阅Collector ）。

这是一个terminal operation 。

当并行执行时，可以实例化，填充和合并多个中间结果，以便保持可变数据结构的隔离。 因此，即使与非线程安全的数据结构（例如ArrayList ）并行执行，并行还原也不需要额外的同步。

API Note:
以下将将字符串累加到ArrayList中：
   List<String> asList = stringStream.collect(Collectors.toList());  
以下将按城市分类Person对象：

   Map<String, List<Person>> peopleByCity = personStream.collect(Collectors.groupingBy(Person::getCity));  
以下将按国家和城市对Person对象进行分类，将两个Collector组合在一起：

   Map<String, Map<String, List<Person>>> peopleByStateAndCity = personStream.collect(Collectors.groupingBy(Person::getState, Collectors.groupingBy(Person::getCity)));  
参数类型
R - 结果的类型
A - 中间累积类型的 Collector
参数
collector - Collector减少的Collector
结果
减少的结果

Collectors

public final class Collectors
extends Object
的实施方式中Collector实现各种有用的还原操作，如累加元件到集合，根据各种标准总结元件等

9.复制不同的值，创建一个子列表

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class ninth {
public static void main(String[] args) {
    // 用所有不同的数字创建一个正方形列表
    List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
     numbers.stream().map( i -> i*i);
    List<Integer> distinct = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
    System.out.printf("Original List : %s,  Square Without duplicates : %s %n", numbers, distinct); 
}
}

10.计算集合元素的最大值、最小值、总和以及平均值

import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;

public class tenth {
public static void main(String[] args) {
    //获取数字的个数、最小值、最大值、总和以及平均值
    List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
    IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();
    System.out.println("Highest prime number in List : " + stats.getMax());
    System.out.println("Lowest prime number in List : " + stats.getMin());
    System.out.println("Sum of all prime numbers : " + stats.getSum());
    System.out.println("Average of all prime numbers : " + stats.getAverage());
}
}

标记api

IntSummaryStatistics

统计数据的收集状态，如count，min，max，sum和average。
这个课程旨在与（但不要求）工作（ streams） 。 例如，您可以使用以下方式计算int数据流的汇总统计信息：

   IntSummaryStatistics stats = intStream.collect(IntSummaryStatistics::new, IntSummaryStatistics::accept, IntSummaryStatistics::combine);  
IntSummaryStatistics可以用作reduction目标为stream 。 例如：

   IntSummaryStatistics stats = people.stream() .collect(Collectors.summarizingInt(Person::getDependents));  
这个计算单次通过计算人数，以及其受扶养人数的最小值，最大值，总和和平均值。
Implementation Note:
这个实现不是线程安全的。 但是，它是安全的使用Collectors.toIntStatistics()上并行流，因为并行执行Stream.collect()提供了必要的隔离，隔离和结果安全，高效的并行执行的合并。
此实现不检查总和的溢出。