jdk 1.8新特性

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * 注意：源发行版1.8需要目标发行版1.8所以需要到setting中去设置java compiler
 * 1.Lambda表达式取代了匿名类，取消了模板,它将允许我们将行为传到函数里，lambda在java中又叫做匿名函数或则闭包
 * Lambda方法在编译器内部被翻译成私有方法，并派发 invokedynamic 字节码指令来进行调用
 * 2.stream函数式操作流元素集合
 */
public class practicejdk8<T> {
    public static void main(String[] args) {

        /**********************************lambda表达式************************************/

        System.out.println("java泛型" + new practicejdk8<String>().getList());
        /**
         * 1.lamda表达式替换传统的开启线程的方式
         */
        //传统
        new Thread(new Runnable() {
            public void run() {
                System.out.println("传统的通过runable实现开启线程的方式");
            }
        }).start();
        //jdk8
        new Thread(() -> System.out.println("jdk8采用的通过runable开启线程的方式")).start();

        /**
         * 2.lamda表达式进行事件处理，例如swing中的事件监听代码
         */
        //传统
        JButton show = new JButton("showButton");
        show.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("传统方式完成事件监听");
            }
        });
        //jdk8
        show.addActionListener((e) -> {
            System.out.println("jdk8采用的方式完成事件监听");
        });

        /**
         *3.使用lambda表达式对列表进行迭代
         */
        //传统
        List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
        for (Object feature : features) {
            System.out.print("传统方式遍历集合：" + feature + "\n");
        }

        //jdk8
        features.forEach(n -> {
            System.out.print("jdk8遍历集合：" + n + "\n");
        });

        /**
         * 场景4.支持函数式接口Predicate
         */
        List<String> languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
        filter(languages, (str) -> str.toString().length() > 4);

        /**
         * 场景5.新的map reduce
         */
        List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
        //传统方式
        for (Integer cost : costBeforeTax) {
            double price = cost + 0.12 * cost;
            System.out.println(price);
        }
        //jdk8方式
        System.out.println("======================");
        costBeforeTax.stream().map((cost) -> cost + 0.12 * cost).forEach((cos) -> {
            System.out.println(cos);
        });

        double bill = costBeforeTax.stream().map((cost) -> cost + 0.12 * cost).reduce((sum, cost) -> sum + cost).get();
        System.out.printf("total:" + bill);

        /**
         * 场景6.通过过滤创建一个String列表
         */
        List<String> stringList = Arrays.asList("try", "to", "do", "what you want");
        List<String> filtered = stringList.stream().filter((x) -> x.length() > 2).collect(Collectors.toList());
        System.out.printf("Original List : %s, filtered list : %s %n", stringList, filtered);

        /**
         * 场景7.对列表的每个元素利用函数
         */
        List<String> beautyWords = Arrays.asList("memories", "beautiful", "very", "hurt", "memories", "memories of the past", "but", "can",
                "not", "go", "back");
        String words = beautyWords.stream().map((x) -> x.toUpperCase()).collect(Collectors.joining(" "));
        System.out.println("回忆很美，很伤，回忆只是回不到过去的记忆" + words);

        /**
         * 场景8.利用distinct对集合列表去重，创建一个子列表
         */
        List<String> distinctWords = beautyWords.stream().map((x) -> x.toLowerCase()).distinct().collect(Collectors.toList());
        System.out.println(distinctWords);

        /**
         * 场景9.利用IntSummaryStatistics计算集合中的最大值，最小值，总和以及平均值
         */
        List<Integer> prime = Arrays.asList(1, 3, 5, 7, 9, 11, 13, 17, 19);
        IntSummaryStatistics statistics = prime.stream().mapToInt((x) -> x).summaryStatistics();
        System.out.println("当前集合中最大值是：" + statistics.getMax() + ",最小值：" + statistics.getMin() + ",总共的数字：" + statistics.getCount() + ",平均数："
                + statistics.getAverage() + ",总和：" + statistics.getSum());

        /**********************************Stream函数式操作流元素集合************************************/
        List<Integer> nums = Arrays.asList(1, 1, null, 2, 3, 4, null, 5, 6, 7, 8, 9, 10);
        System.out.println("求和：" + nums.stream()
                .filter((x) -> x != null)   //过滤
                .distinct()             //去重
                .mapToInt((num) -> num * 1) //map操作
                .skip(2)                //跳过前二条数据
                .limit(4)               //取前四条数据
                .sum())                 //求和
        ;

        /**********************************方法引用************************************/
        //方法引用使用一对冒号 ::
        person p = new person("zhang", "男");
        person p2 = new person("chao", "男");
        List<person> personList = Arrays.asList(p, p2);
        personList.forEach(person -> System.out.println(person.getName()));
        personList.forEach(person::getName);

        /**********************************接口的默认方法************************************/
        formula f = new formula() {
            @Override
            public double calculate(int a) {
                return a;
            }
        };
        System.out.println(f.sqrt(4));

        /**********************************函数式接口配合lambda表达式使用***********************************
         *每一个lambda表达式都对应一个类型，通常是接口类型,并且方法类型和参数通吃是模板类型
         * 而“函数式接口”是指仅仅只包含一个抽象方法的接口
         * 每一个该类型的lambda表达式都会被匹配到这个抽象方法
         * 因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法
         */
        Converter<String, Integer> stringIntegerConverter = (from) -> Integer.valueOf(from);
        Integer converted = stringIntegerConverter.convert("123");
        System.out.println(converted);

        /****************************************各种函数式接口总结******************************************/
        //predicate接口
        Predicate<String> predicate = (s) -> s.length() > 0;
        predicate.test("foo");              // true
        predicate.negate().test("foo");     // false

        //function
        Function<String, Integer> toInteger = Integer::valueOf;
        Function<String, String> backToString = toInteger.andThen(String::valueOf);
        backToString.apply("123");

        //supplier接口
        Supplier<person> personSupplier = person::new;
        System.out.println(personSupplier.get().toString());

        //Consumer 接口
        Consumer<person> greeter = (a) -> System.out.println("Hello, " + a.getName());
        greeter.accept(new person("Luke", "男"));

        //Comparator 接口
        Comparator<person> personComparator = (po1, po2) -> po1.getName().compareTo(po2.getName());
        person p1 = new person("a", "女");
        int isP1MoreP2 = personComparator.compare(p1, p2);
        int isP2MoreP1 = personComparator.reversed().compare(p1, p2);
        System.out.println(isP1MoreP2 + "," + isP2MoreP1);

        //Optional 接口
        //此接口不是函数式接口而是一个用来防止空指针异常的辅助类
        Optional<String> optional = Optional.of("ask");
        System.out.println(optional.isPresent());

        //filter接口
//        过滤通过一个predicate接口来过滤并只保留符合条件的元素，该操作属于中间操作，
//        所以我们可以在过滤后的结果来应用其他Stream操作（比如forEach）。forEach需要
//        一个函数来对过滤后的元素依次执行。forEach是一个最终操作，所以我们不能在forEach之后来执行其他Stream操作。
        languages.stream().map((m)->m.toLowerCase()).filter((s)->s.startsWith("ja")).forEach(System.out::println);

        //sort接口
        //需要注意的是排序只创建了一个排列好的stream,而不会影响原有的数据
        languages.stream().sorted().forEach((x)-> System.out.println(x));
        System.out.println(languages);

        //map映射
        //中间操作map将元素根据指定的Function接口来依次将元素转成另外的对象
        System.out.println("map映射");
        languages.stream().map(String::toUpperCase).sorted((a,b)->b.compareTo(a)).forEach(System.out::println);

        //match匹配
        boolean anyStartsWithA=languages.stream().anyMatch((s)->s.startsWith("J"));
        System.out.println(anyStartsWithA);
        System.out.println(languages.stream().allMatch((s)->s.length()>5));
        System.out.println(languages.stream().noneMatch((s)->s.equals("Javas")));

        //count 计数
        System.out.println(languages.stream().filter(s->s.length()>4).count());

        //reduce规约
        //这是一个最终操作，允许通过指定的函数来讲stream中的多个元素规约为一个元素，规越后的结果是通过Optional接口表示的
        Optional<String> reduced=languages.stream().reduce((s1,s2)->s1+","+s2);
        reduced.ifPresent(System.out::print);
        System.out.println(languages.stream().reduce((s1,s2)->s1+","+s2).get());

        //并行streams,可以发现parallelStream比stream快了50%多
        //parallelStream 只是做到别浪费cpu，假如本身电脑cpu的负载很大，那还到处用parallel，那并不能起到作用
        //不要在多线程中使用parallelStream，原因同上类似，大家都抢着cpu是没有提升效果，反而还会加大线程切换开销
        //会带来不确定性，请确保每条处理无状态且没有关联
        //考虑nq模型：n可用的数据量，q针对每个数据元素执行的计算量乘积 N*Q 越大，就越有可能获得并行提速。N x Q > 10000 就会获得有效提升
        int max = 1000000;
        List<String> values = new ArrayList<>(max);
        for (int i = 0; i < max; i++) {
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }

        long t0=System.currentTimeMillis();//串行
        values.stream().sorted().count();
        long t1=System.currentTimeMillis();
        System.out.println("串行排序所花的时间:"+(t1-t0));

        long t2=System.currentTimeMillis();//并行
        values.parallelStream().sorted().count();
        long t3=System.currentTimeMillis();
        System.out.println("串行排序所花的时间:"+(t3-t2));


        //Map,map类型不支持stream
        Map<Integer,String> map=new HashMap<>();
        for(int i=0;i<10;i++){
            map.putIfAbsent(i,"val"+i);//putIfAbsent 不需要我们做额外的存在性检查
        }
        map.forEach((id,val)-> System.out.println(val));
        map.merge(11,"张超",(value,newValue)->value.concat(newValue)); //map合并,Merge做的事情是如果键名不存在则插入，否则则对原键对应的值做合并操作并重新插入到map中
        System.out.println(map.get(11));



        /**********************************Annotation 注解************************************/


    }

    public static void filter(List<String> list, Predicate predicate) {
        for (String name : list) {
            if (predicate.test(name)) {
                System.out.println(name + " ");
            }
        }
    }

    /**
     * 集合泛型的示例
     *
     * @return
     */
    public List<T> getList() {
        List<String> list = new CopyOnWriteArrayList<String>();
        list.add("1");
        return (List<T>) list;
    }

    interface formula {
        double calculate(int a);
        default double sqrt(int a) {
            return Math.sqrt(a);
        }
    }

    //函数式接口
    @FunctionalInterface
    interface Converter<F, T> {
        T convert(F from);
    }
}