java map collect_Java8 Lambda和Stream常用的样例代码(filter map reduce collect join)

package java8.basic.stream;

import java.util.Arrays;

import java.util.Comparator;

import java.util.LinkedList;

import java.util.List;

import java.util.Set;

import java.util.function.BinaryOperator;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import java8.model.Album;

import java8.model.Artist;

import java8.model.Song;

/**

* Stream类中的方法对应常见的集合操作，总结一些常用的stream操作样例代码

* @author : lh

* @date 创建时间：2018年8月5日 上午8:49:02

* @version 1.0

*/

public class Stream1 {

/**

* 过滤List中字符串并计数 filter只描述stream，不产生新的集合，此种叫惰性求值(str不打印)count则终止流打印

* 和建造者模式相似(调用build才创建对象)

* @param params

* @return

* @throws

*/

public static Long streamFilterCount() {

List list = new LinkedList<>();

list.add(“test1”);

list.add(“right”);

long result = list.stream()

.filter(str -> str.equals(“right”))

.count();

//        list.stream().filter(str -> {

//            System.out.println(str);

//            return str.equals(“right”);

//        }).count();

System.out.println(“filter: “+result);

return result;

}

/**

* 请输入功能描述：Stream::collect

* @param params

* @return

* @throws

*/

public static List streamCollectList(){

List result = Stream.of(“a”,”b”,”c”)

.collect(Collectors.toList());

System.out.println(“collect: “+result.size());

return result;

}

/**

* 请输入功能描述：Stream::map

* @param params

* @return

* @throws

*/

public static void streamMap() {

List result = Stream.of(“a”,”b”,”C”)

.map(str -> str.toUpperCase())

.collect(Collectors.toList());

System.out.println(“map: “+result.get(0)+result.get(1)+result.get(2));

}

/**

* 请输入功能描述：Stream:filter

* @param params

* @return

* @throws

*/

public static void streamFilter() {

List result = Stream.of(“1abc”,”abcd”,”2bcd”)

.filter(str -> Character.isDigit(str.charAt(0)))

.collect(Collectors.toList());

System.out.println(“filter: “+result.size());

}

/**

* 请输入功能描述：Stream::flatMap

* @param params

* @return

* @throws

*/

public static void streamFlatMap() {

List result = Stream.of(Arrays.asList(“r1″,”r2″,”r3”)

,Arrays.asList(“t1″,”t2″,”t3”))

.flatMap(list -> list.stream())

.collect(Collectors.toList());

System.out.println(“flatMap: “+result.size());

}

/**

* 请输入功能描述：Stream::min/max

* @param params

* @return

* @throws

*/

public static void streamMin() {

List list = Arrays.asList(new Song(“t1”,222),new Song(“t2”,333));

Song result = list.stream()

.max(Comparator.comparing(track -> track.getLength()))

.get();

System.out.println(“min/max: “+result.getName());

}

/**

* 请输入功能描述：Stream::reduce

* @param params

* @return

* @throws

*/

public static void streamReduce() {

int count = Stream.of(1,2,3)

.reduce(0, (x,y) -> x + y);

System.out.println(“reduce: ” + count);

BinaryOperator accumulator = (acc, element) -> acc + element;

int count2 = accumulator.apply(

accumulator.apply(accumulator.apply(0, 1), 2), 3);

System.out.println(“reduce2: ” + count2);

int count3 = Stream.of(1,2,3)

.reduce(Integer::sum).get();

System.out.println(“reduce3:” + count3);

}

/**

* 请输入功能描述：stream方法综合运用

* @param params

* @return

* @throws

*/

public static void streamZH() {

Album album = new Album(“The”,Arrays.asList(new Song(“test”,1)),

Arrays.asList(new Artist(“at”,”at2″)));

Set origins = album.getMusicians()

.filter(artist -> artist.getName().startsWith(“The”))

.map(artist -> artist.getNationality())

.collect(Collectors.toSet());

System.out.println(“streamZH: “+origins.size());

}

public static void streamZH2(List albums) {

albums.stream()

.flatMap(album -> album.getTracks())

.filter(track -> track.getLength() > 60)

.map(track -> track.getName())

.collect(Collectors.toSet());

}

/**

* 请输入功能描述：按一定规则拼接集合字符串

* @param params

* @return

* @throws

*/

public static void streamJoin() {

String result = Arrays.asList(“str1″,”str2″,”str3”)

.stream()

.filter(str -> str.contains(“3”))

.map(str -> str.toUpperCase())

.collect(Collectors.joining(“,”,”[“,”]”));

System.out.println(“join: “+result);

}

public static void main(String[] args) {

streamFilterCount();

streamCollectList();

streamMap();

streamFilter();

streamFlatMap();

streamMin();

streamReduce();

streamZH();

streamJoin();

}

}