跟着 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()提供了必要的隔离,隔离和结果安全,高效的并行执行的合并。
此实现不检查总和的溢出。