jdk8 lambda 练习

public class Artist {    public Artist(){}    public Artist(String name, String from) {        this.name = name;        this.from = from;    }    public Artist(String name, String from, String numbers) {        this.name = name;        this.from = from;        this.numbers = numbers;    }    public String name ;    public String from;    public String numbers;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getFrom() {        return from;    }    public void setFrom(String from) {        this.from = from;    }    public String getNumbers() {        return numbers;    }    public void setNumbers(String numbers) {        this.numbers = numbers;    }    public Boolean isFrom(String from) {        if(this.from.equals(from)) {            return true;        }        return false;    }    public static List<Artist> getList() {        List<Artist> artists = new ArrayList<Artist>();        artists.add(new Artist("spring","London"));        artists.add(new Artist("summer","Usa"));        artists.add(new Artist("autumn","China"));        artists.add(new Artist("winter","London"));        return artists;    }}

package Test;/** * Created by Administrator on 2017/5/26. */public interface InterfaceA {    public default String rock() {        return "A";    }}

package Test;/** * Created by Administrator on 2017/5/26. */public interface InterfaceB {    public default String rock() {        return "B";    }}

package Test;import com.google.common.base.Strings;import com.google.common.collect.Lists;import java.awt.event.ActionListener;import java.util.*;import java.util.function.BinaryOperator;import java.util.function.Predicate;import java.util.function.Supplier;import java.util.stream.Collectors;import java.util.stream.IntStream;import java.util.stream.Stream;/** * Created by Administrator on 2017/5/11. */public class TestController {    public static void main(String[] params) {//        Runnable r = new Runnable() {//            @Override//            public void run() {//                System.out.println("123");//            }//        };//        r.run();        //函数式接口:（1）是一个接口 （2）只有一个待实现的方法        Runnable r = ()->System.out.println("lambda");        r.run();        Comparator com = (o1, o2) -> 0;        Comparator<String> cn = (String str1,String str2)->str1.compareTo(str2);        new Thread(                ()->System.out.println("lambda2")        ).start();        List<String> arrays = Arrays.asList("abc","def","ghi");        arrays.forEach(System.out::println);        arrays.forEach((String n)->System.out.println(n));        System.out.println(arrays.stream()                .collect(Collectors.joining(",")));        //////////////////////////////////////////////二///////////////////////////////////////////        List<String> languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");        languages.sort((str1, str2)->str1.compareTo(str2));        BinaryOperator<Long> add = (x,y) -> x + y;//创建一个函数，用来计算两个数字相加的结果        BinaryOperator<Long> addExplicit = (Long x, Long y) -> x + y;        /**         * 目标类型指Lambda表达式所在上下文环境的类型。比如，将Lambda表达式赋值给一个局部变量，         * 或传递给一个方法作为参数，局部变量或方法参数的类型就是Lambda表达式的目标类型。         *         */        Predicate<Integer> s = x -> x > 5;        BinaryOperator<Long> add1 = (x,y) -> x + y;        ActionListener oneArgument = (event) -> System.out.println();        //stream的作用和调用iterator()一样        //filter：只保留通过某项测试的对象，测试由一个函数完成。filter只刻画了Stream,但没有产生新的集合（惰性求值方法）。        //count()计算给定stream里包含多少个对象，最终会从Stream产生值的方法叫及早求值方法。        languages.stream().filter(a -> a.isEmpty()).count();        List<Artist> allArtists = Artist.getList();        System.out.println(allArtists.stream().filter(artist -> artist.isFrom("London")));//不用count，没有输出        System.out.println(allArtists.stream().filter(artist -> {System.out.println();artist.getName();            return artist.isFrom("London");}));        System.out.println(allArtists.stream().filter(artist -> {System.out.println();artist.getName();            return artist.isFrom("London");}).count());        //collect        List<String> collected = Stream.of("a","b","c").collect(Collectors.toList());        System.out.println(collected);        //map:如果有一个函数可以将一种类型的值转换为另外一种类型，map操作就可以使用该函数，将一个流中的值转换成一个新的流。        List<String> collected2 = Stream.of("a","b","hello")                .map((string -> string.toUpperCase()))                .collect(Collectors.toList());        System.out.println(collected2);        //filter        List<String> map = Stream.of("a","b","hello").filter(value-> value.equals("a")).collect(Collectors.toList());        System.out.println(map);        //flatMap:方法可用Stream替换值，然后将多个Stream连接成一个Stream        List<Integer> together = Stream.of(Arrays.asList(1,2),Arrays.asList(4,5)).flatMap(numbers -> numbers.stream()).collect(Collectors.toList());        System.out.println(together);        //min和max求最大值和最小值        List<Track> tracks = Arrays.asList(new Track("Bakai",524),                new Track("Violets for Your Furs",378),                new Track("Time Was",451));        Track shotestTrack = tracks.stream().min(Comparator.comparing(track -> track.getName())).get();        System.out.println(shotestTrack.getName());        Collections.sort(tracks, new Comparator<Track>() {            @Override            public int compare(Track o1, Track o2) {                return o1.getName().compareTo(o2.getName());            }        });//传统排序        //reduce实现从一组值中生成一个值        //实现求和操作，有两个参数：传入Stream中的当前元素和acc,将两个参数相加，acc是累加器，保存着当前的累加结果。        int count = Stream.of(1,2,3).reduce(0, (acc, element) -> acc + element);        //T reduce(T identity, BinaryOperator<T> accumulator);        System.out.println(count);        List<Integer> list=new ArrayList<Integer>();        for(int i=0;i<100;i++){            list.add(Integer.valueOf(i));        }        System.out.println(list.stream().reduce(                (result,element)->                        result=result+element));        /**         * 高阶函数         * 接受另外一个函数作为参数，或返回一个函数的函数。         * 如果函数的参数列表里包含函数接口，或该函数返回一个函数接口，那么该函数就是高阶函数。         * summaryStatistics()统计         * */        IntSummaryStatistics statistics = Stream.of("a","bc","f").mapToInt(e -> e.getBytes().length).summaryStatistics();        System.out.printf("Max:%d,Min:%d,Ave:%f,Sum:%d -----",                statistics.getMax(),statistics.getMin(),statistics.getAverage(),statistics.getSum());        int size = Stream.of("de","er","oer").mapToInt(e -> e.getBytes().length).sum();        System.out.println("size = " + size);        /**         * BinaryOperator是一种特殊的BiFunction类型，参数的类型和返回值的类型相同。比如，两个整数相加就是一个BinaryOperator.         * Lambda表达式的类型就是对应的函数接口类型。         * 操作时可以重载一个方法，分别接受BinaryOperator和该接口的一个子类作为参数。         * *///        Parent parent = new ParentImpl();        /**         * Optional对象相当于值的容器，而该值可以通过get方法提取。Optional对象也可能为空。因此还有一个对应的工厂方法empty，         * 另外一个工厂方法ofNullable则可将一个空值转成成Optional对象。         * isPresent():如果存在值，则返回 true ，否则为 false 。         * public T orElse(T other)返回值如果存在，否则返回 other 。other - 如果没有值存在则返回的值可以为null         * public T orElseGet(Supplier<? extends T> other)返回值（如果存在），否则调用 other并返回该调用的结果。other - 一个 Supplier ，如果没有值，则返回其结果         */        Optional<String> a = Optional.of("a");        System.out.println(a.get());        Optional emptyOptional = Optional.empty();        Optional alsoEmpty = Optional.ofNullable(null);        System.out.println(emptyOptional.isPresent());        System.out.println(alsoEmpty.isPresent());        System.out.println(emptyOptional.orElse("b"));//备选值        System.out.println(emptyOptional.orElseGet(()->"c"));//如果计算备选值太繁琐，用该方法，该方法接收一个Supplier对象，只有在Oprional对象真正为空时才会调用。        /**         * 方法引用         * 标准语法：Classname::methodName         * */        allArtists.stream().map(artist -> artist.getFrom()).collect(Collectors.toList());//        Artist art = Artist::new;        Supplier<Artist> art = Artist::new;        art.get();        List<String> names = new ArrayList<>();        names.add("TaoBao");        names.add("ZhiFuBao");//        List<String> lowercaseNames = names.stream().map(name->name.toUpperCase()).collect(Collectors.toList());        List<String> lowercaseNames = names.stream().map((String name)->{return name.toUpperCase();}).collect(Collectors.toList());        System.out.println(lowercaseNames);        String[] array = {"a", "b", "c"};        for(Integer i : Lists.newArrayList(1,2,3)){            Stream.of(array).map(item -> Strings.padEnd(item, i, '@')).forEach(System.out::println);        }        List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);        System.out.println("sum is:"+nums.stream().filter(num -> num != null).        distinct().mapToInt(num -> num * 2).        peek(System.out::println).skip(2).limit(4).sum());        /**         * 元素顺序         * */        Set<Integer> numbers = new HashSet<>(Arrays.asList(4,3,2,1));        List<Integer> sameOrder = numbers.stream().sorted().collect(Collectors.toList());//排序        System.out.println(sameOrder);        List<Integer> numbers2 = Arrays.asList(1,2,3,4);        List<Integer> stillOrdered = numbers2.stream().map(x -> x+1).collect(Collectors.toList());        System.out.println(stillOrdered);        Set<Integer> unordered = new HashSet<>(numbers2);        List<Integer> stillUnordered = unordered.stream().map(x->x+1).collect(Collectors.toList());        System.out.println(stillOrdered);        /**         * 收集器-转换成值         * 利用收集器让流生成一个值。         * maxBy,minBy允许用户按某种特定的顺序生成一个值。         * maxBy求最大值         * */        Optional<Track> artistMax = tracks.stream().collect(Collectors.maxBy((s1,s2)->s1.getNum()-s2.getNum()));        artistMax = tracks.stream().collect(Collectors.maxBy(Comparator.comparing(Track::getNum)));//求最大值        int sum = tracks.stream().collect(Collectors.summingInt(Track::getNum));//求综合        double avg = tracks.stream().collect(Collectors.averagingInt(Track::getNum));//求平均值        /**         * 收集器-数据分块         * partitioningBy它接受一个流，并将其分成两部分，它使用Predicate对象判断一个元素应该属于哪个部分，         * 并根据布尔值返回一个Map到列表。         * 分区可以看做是分组的一种特殊情况，在分区中key只有两种情况：true或false，目的是将待分区集合按照条件一分为二         * */        Map<Boolean,List<Artist>> partition = allArtists.stream().collect(Collectors.partitioningBy(artist->artist.isFrom("London")));        System.out.println(partition);        /**         * 收集器-数据分组         * 更自然的分割数据操作         * groupingBy接收一个分类器Function<? super T, ? extends K> classifier，我们可以自定义分类器来实现需要的分类效果。         * */        Map<String,List<Artist>> artistGroup = allArtists.stream().collect(Collectors.groupingBy(Artist::getFrom));        //多级分组,先按from分组，再按name分组        Map<String,Map<String,List<Artist>>> artistGroup2 = allArtists.stream()                .collect(Collectors.groupingBy(Artist::getFrom,Collectors.groupingBy(Artist::getName)));        /**         * 收集器-字符串         * */        String result = allArtists.stream().map(Artist::getName).collect(Collectors.joining(",", "<",">"));        System.out.println(result);        result = allArtists.stream().map(Artist::getName).collect(Collectors.joining(","));        System.out.println(result);        /**         * 重构和定制收集器         * */        StringBuffer sb = new StringBuffer("[");        allArtists.stream().map(Artist::getName).forEach(name->{            if(sb.length() > 1)                sb.append(",");            sb.append(name);        });        sb.append("]");        System.out.println(sb.toString());        System.out.println("----------------------------------------");        /**         * 并行化操作流只需改变一个方法调用。如果已经有一个Stream对象，调用他的parallel方法就能让其拥有并行操作的能力。         * 如果想从一个集合类创建一个流，调用parallelStream就能理解获得一个拥有并行能力的流。         * */        allArtists.parallelStream().collect(Collectors.toSet());        List<Integer> values = Arrays.asList(1,2,3,4,5,6);        int summ = addIntegers(values);        System.out.println(summ);        double[] arrayAlls = {0.1,0.2,0.3};        Arrays.parallelSetAll(arrayAlls, i->i%10);     //arrayAlls变为0.0 1.0 2.0        Arrays.parallelPrefix(arrayAlls,Double::sum); //0.0,1.0,3.0        int n = 3;        int start = 2;        double[] results = IntStream.range(start,arrayAlls.length).mapToDouble(i->  //i=2        {            double prefix = i == start ? 0 : arrayAlls[i-n];  //prefix = 0.0;            return (arrayAlls[i] - prefix) / n;              //(3.0 - 0.0)/n = 1.0        }).toArray();        System.out.println(Arrays.toString(results));        //        //按某个字段逆序排列        allArtists.sort(Comparator.comparing(Artist::getName).reversed());        //按不同字段排序，如果name一样，则比较from，以此类推        Comparator<Artist> c = Comparator.comparing(Artist::getName).thenComparing(Artist::getFrom).thenComparing(Artist::getNumbers);        allArtists.sort(c);    }    private static int addIntegers(List<Integer> values) {        return values.parallelStream().mapToInt(i->i).sum();//求和操作    }}
-------------------------------------------------------------------------------------------------
分组：
Map<String,List<ShoppingCartItem>> map = items.stream().collect(Collectors.groupingBy(ShoppingCartItem::getNo));