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));