java8学习笔记(1)

java8学习笔记(1) 1.Lambda表达式

一个 Lambda 表达式可以有零个或多个参数。
参数的类型既可以明确声明，也可以根据上下文来推断。
所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (String a, int b, float c)
空圆括号代表参数集为空。例如：() -> 42
当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> a*a
如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致
Lambda的变量捕获，与匿名内部类一样也是不能捕获发生改变的，如果发生改变就会报错。

2.Stream流

流的操作类型分为两种：

Intermediate：一个流可以后面跟随零个或多个intermediate操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历
map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
Terminal：一个流只能有一个terminal操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以,这必定是流的最后一个操作。Terminal操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个side effect。
forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
转换操作都是lazy的，多个转换操作只会在Terminal操作的时候融合起来，一次循环完成。我们可以这样简单的理解，Stream里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在Terminal 操作的时候循环Stream对应的集合，然后对每个元素执行所有的函数。
short-circuiting操作。用以指：对于一个intermediate操作，如果它接受的是一个无限大（infinite/unbounded）的Stream，但返回一个有限的新Stream；对于一个terminal操作，如果它接受的是一个无限大的Stream，但能在有限的时间计算出结果。
anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

1.创建流

单列集合
通过 java.util.Collection.stream() 方法

List list = Arrays.asList("hello","world","stream");
//创建顺序流
Stream stream = list.stream();

数组

Arrays.stream(T[] array)方法

String[] array = {"h", "e", "l", "l", "o"};
Stream arrayStream = Arrays.stream(array);

Stream的静态方法：of()、iterate()、generate()

 // public static Stream of(T... values) {return Arrays.stream(values); }
Stream stream1 = Stream.of(1, 2, 3, 4, 5, 6);

// public static Stream iterate(final T seed, final UnaryOperator f)
Stream stream2 = Stream.iterate(0, (x) -> x + 2).limit(3);
stream2.forEach(System.out::println); //0,2,4

// public static Stream generate(Supplier s) {
//         Objects.requireNonNull(s);
//         return StreamSupport.stream(
//                 new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
//     }
Stream stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println)

双列集合

Map map = new HashMap<>(){
	{
		put("aaa",18);put("bbb",20);put("ccc",66);
	}
}
Stream> stream =map.entrySet().stream()

2.中间操作

filter()

	// 返回由与给定谓词匹配的此流的元素组成的流。
	Stream filter(Predicate predicate);

map()

     Stream map(Function mapper);

mapToInt()

   IntStream mapToInt(ToIntFunction mapper);

flatMap()

	// 返回一个流，其中包含将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容的结果.
	// flatMap()操作具有对流的元素应用一对多转换的效果，然后将生成的元素展平为新的流。
 	//  Stream flatMap(Function> mapper);
	Stream> inputStream = Stream.of(
		 Arrays.asList(1),
		 Arrays.asList(2, 3),
		 Arrays.asList(4, 5, 6)
	 );
	Stream outputStream = inputStream.flatMap((childList) -> childList.stream());

distinct()

	// 返回由该流的不同元素（根据Object.equals(Object) ）组成的流。

sorted()

	// Stream sorted();
	// Stream sorted(Comparator comparator);
	List persons = new ArrayList();
	 for (int i = 1; i <= 5; i++) {
		 Person person = new Person(i, "name" + i);
		 persons.add(person);
	 }

	List personList2 = persons.stream()
										.limit(2)
										.sorted((p1, p2) -> p1.getName().compareTo(p2.getName()))
										.collect(Collectors.toList());
	System.out.println(personList2);

limit()

	// 返回由该流的元素组成的流，截断长度不超过maxSize 。
    Stream limit(long maxSize);

peek()

	// 返回由该流的元素组成的流，并在从结果流中消耗元素时对每个元素执行提供的操作
	// 此方法的存在主要是为了支持调试，您希望在元素流过管道中的某个点时查看它们：
    Stream peek(Consumer action);

skip()

	// 在丢弃流的前n元素后，返回由该流的剩余元素组成的流。如果此流包含少于n元素，则将返回一个空流。
    Stream skip(long n);

3.终结操作

count()

 long count();

min()&max()

    Optional max(Comparator comparator);

anyMatch()

	// 返回此流的任何元素是否与提供的谓词匹配。如果不需要确定结果，则可能不会评估所有元素的谓词。是一个短路终端操作。
	boolean anyMatch(Predicate predicate);

allMatch()

	// 返回此流的所有元素是否与提供的谓词匹配。如果不需要确定结果，
    boolean allMatch(Predicate predicate);

noneMatch()
findFirst()

	// 返回一个描述此流的第一个元素的Optional 
   Optional findFirst();

findAny()

    Optional findAny();

toArray()

// Object [] toArray();
//  A[] toArray(IntFunction generator);
List strList = Arrays.asList( "Jhonny", "David", "Jack", "Duke", "Jill","Dany","Julia","Jenish","Divya");
 
Object [] strAryNoArg = strList.stream().toArray();
String [] strAry = strList.stream().toArray(String[]::new);

collect()

//收集器，它接收的参数是将流中的元素累积到汇总结果的各种方式
 R collect(Collector collector);
//常见参数
List menus=Menu.getMenus.stream().collect(Collectors.toList());
Set menus=Menu.getMenus.stream().collect(Collectors.toSet());
//把流中所有元素收集到给定的供应源创建的集合中
ArrayList menus=Menu.getMenus.stream().collect(Collectors.toCollection(ArrayList::new));

Map> map =authors.stream().distinct().collect(Collectors.toMap(a->a.getName,a->a.getBooks()));

reduce()
该接口含有3种调用方式：

Optional reduce(BinaryOperator accumulator);
T reduce(T identity, BinaryOperator accumulator);
 U reduce(U identity, BiFunction accumulator,BinaryOperator combiner);

//1个参数的接口内部效果
	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();

//2个参数的接口
	T result = identity;
	for (T element : this stream){
	    result = accumulator.apply(result, element)
	}
	return result;
	
	//egg
	List num = Arrays.asList(1, 2, 4, 5, 6, 7);
	Integer integer = num.stream().reduce(new BinaryOperator() {
	    @Override
	    public Integer apply(Integer a, Integer b) {
	    	System.out.println("x:"+a);
	        return a + b;
	    }
	//integer=25
	//Integer integer3 = num.stream().reduce((integer1, integer2) -> integer1 + integer2).get();

4.转化为其它数据结构

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List list1 = stream.collect(Collectors.toList());
List list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

部分内容来源于网上，侵删。

java8学习笔记(1)

Java相关栏目本月热门文章