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 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) {
Listlist = 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) {
Listlanguages = 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 (Listnames ,Predicate condition) {
names.forEach((x) -> {
if(condition.test(x)){
System.out.println(x);
}
});
}
public static void filter2(Listnames ,Predicate 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
表示一个参数的谓词（布尔值函数）。
这是一个functional interface的功能方法是test(Object) 。 test
boolean test(T t)
在给定的参数上评估这个谓词。
参数
t - 输入参数
结果
true如果输入参数匹配谓词，否则为 falsestream
default Stream stream()
返回一个顺序Stream与此集合作为其来源。
当此方法应该重写spliterator()方法不能返回spliterator是IMMUTABLE ， CONCURRENT ，或后期绑定 。 （详见spliterator() ）
实现要求：
默认的实现创建顺序 Stream从收集的 Spliterator 。
结果
连续 Stream在这个集合中的元素 filter
Stream 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) {
Listlanguages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
Predicate startsWithJ = (n) -> n.startsWith("J");
Predicate 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 and(Predicate super T> other)
返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑AND。 当评估组合谓词时，如果此谓词为false ，则不other other谓词。
在评估任一谓词期间抛出的任何异常被中继到调用者; 如果此断言的评价抛出一个异常， other断言不会被评估。
参数
other - 将与此谓词进行逻辑与AND的谓词
结果
一个代表该谓词和other谓词的短路逻辑AND的 other谓词
异常
NullPointerException - 如果其他为空
##### negate
default Predicate negate()
返回表示此谓词的逻辑否定的谓词。
结果
一个表示该谓词的逻辑否定的谓词 or
default Predicate<T> or(Predicatesuper 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 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 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 reduce(BinaryOperator 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 predicate = (x) -> x.length()> 2;
List strList = Arrays.asList("abc", "", "bcd", "defg", "jk");
List 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 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 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 numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
numbers.stream().map( i -> i*i);
List 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 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()提供了必要的隔离，隔离和结果安全，高效的并行执行的合并。
此实现不检查总和的溢出。