JAVA8-待续

1. 函数式编程，因为在并发和时间驱动编程中的优势，函数式编程又逐渐流行起来

以前是实现一个比较器需要实现Comparator接口，并重写compare方法，以下为两种实现方法（类似还有线程，事件等）：

    class compOldClass implements Comparator<String> {

        @Override

        public int compare(String first, String second) {

            return Integer.compare(first.length(), second.length());

        }

    }

        Comparator<String> compOld = new Comparator<String>() {

            @Override

            public int compare(String first, String second) {

                return Integer.compare(first.length(), second.length());

            }

        };

在JDK8中，很多接口添加@FunctionalInterface被声明为函数式接口,JDK8的接口中可以有default和static方法，函数式接口中除了覆盖Object的方法之外，只允许有一个抽象方法

@FunctionalInterface

public interface Comparator<T> {

......

    int compare(T o1, T o2);

    boolean equals(Object obj);
    ......

    default Comparator<T> reversed() {

        return Collections.reverseOrder(this);

    }

    ......

    ......

    public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {

        return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;

    }

    ......

}

JDK8函数方式的Comparator实现

Comparator<String> comp = (first, second) -> Integer.compare(first.length(), second.length());

自定义测试：就是迭代元素，提供处理方法，进行处理

    @FunctionalInterface

    interface WorkerSep {

        public void doSthSep(String conent);

    }

        com.timer.WorkerSep workerSep = (x) -> System.out.println(x);

        List<String> lists = new ArrayList<String>();

        lists.add("a");

        lists.add("b");

        lists.stream().forEach(workerSep::doSthSep);

方法引用（对象::实例方法 / 类::静态方法 / 类::实例方法 / 类::new （支持多个构造器根据参数选择最合适的））：例为调用父类方法，传入线程中执行

/**

 * Created by itworker365 on 5/19/2017.

 */

public class Java8ThreadTest {

    public static void main (String[] args) {

        ConcurrentWorker concurrentWorker = new ConcurrentWorker();

        concurrentWorker.doSth();

    }

}

class Worker {

    public void doSth() {

        System.out.print("working......");

    }

}

class ConcurrentWorker extends Worker {

    public void doSth () {

        Thread thread = new Thread(super::doSth);

        thread.start();

    }

}

2. Stream

例，读文件拆分字符打印，流处理的时候原字符不变,将输入流处理后传到下一个流处理器直到结束，输出的新字符为处理过后的，换成parallelStream就是并行的了，代码流程为创建一个stream，执行一些列操作，使用一个终止符来终止操作，但执行顺序为print被调用的时候，采取找数据，开始计算。

Collection接口中添加stream方法，可以将任何一个集合转换为stream，即使数组也可以Stream.of(数组),Stream.generate(),Stream.iterator(),Pattern.compile(正则).splistAsStream("****"),Files.lines(path)等

        String content = new String(Files.readAllBytes(Paths.get("d:\\a.txt")));

        List<String> words = Arrays.asList(content.split(","));

        //过滤掉fileter中运算为false的

        words.stream().filter(w -> w.startsWith("b")).forEach(System.out::println);

        //每行都执行以下map里的函数

        words.stream().map(String::toUpperCase).map(s -> s.charAt(0)).forEach(System.out::println);

        //不停输入，直到Limit，skip表示忽略掉前n个元素

        Stream.iterate(1, item -> item + 1).limit(10).forEach(System.out::println);

        //将每一行拆分为一个流添加到原来computer,it-worker ==》computer it worker

        words.stream().flatMap(article -> Stream.of(article.split("-"))).forEach(System.out::println);

        //perk显示元素是否被取用，count统计个数，同时局和方法还有max,min,findFirst,findAny,anyMatch等

        words.stream().peek(System.out::println).count();

       //有状态的转换，排序和去重等操作，需要记录元素状态，进行操作

        words.stream().distinct().forEach(System.out::println);

        //判断是否存在符合条件的元素optional元素还可以ifPresent,map,orElse等添加处理

        Optional<String> optional = words.stream().filter(w -> w.startsWith("c")).findAny();

        if (optional.isPresent()) {

            System.out.println("option result: " + optional.get());

        }

        System.out.println("any match: " + words.stream().anyMatch(w -> w.startsWith("c")));

        //将stream转为数组

        String[] wordArray = words.stream().toArray(String[]::new);

        //其他收集方式,其他方式类似，需要时查看API

        Set<String> hashSet = words.stream().collect(Collectors.toSet());

        List<String> list = words.stream().collect(Collectors.toList());

        TreeSet<String> treeSet = words.stream().collect(Collectors.toCollection(TreeSet<String>::new));

        Map<String,String> map = words.stream().collect(Collectors.toMap(x -> x, String::toUpperCase));

        String result = words.stream().collect(Collectors.joining("/"));

        //分组分片 same as String::toUpperCase

        Map<String, List<String>> splitMap = words.stream().collect(Collectors.groupingBy(x -> x.toUpperCase()));

        Map<Boolean, List<String>> partitionMap = words.stream().collect(Collectors.partitioningBy(x -> x.toUpperCase().equals("CD")));

        //所有字符串concat在一起

        String s = words.stream().reduce("", (a, b) -> a.concat(b));

        System.out.println("reduce : " + s);

3.日期函数更新

import java.time.*;

import java.time.format.DateTimeFormatter;

import java.time.format.FormatStyle;

import java.time.temporal.TemporalAdjuster;

/**

 * Created by itworker365 on 5/19/2017.

 */

public class Jdk8NewTimmer {

    public static void main (String[] args) {

        Instant start = Instant.now();

        try {

            Thread.sleep(60000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        Instant end = Instant.now();

        Duration duration = Duration.between(start, end);

        System.out.println(duration.toMillis());

        System.out.println(duration.toMinutes());

        LocalDate localDate = LocalDate.now();

        System.out.println(localDate.getYear() + "  " + localDate.getMonth());

        LocalDate localDateMe = LocalDate.of(2008, 8, 8);

        System.out.println(localDateMe.getYear() + "  " + localDateMe.getMonth());

        //2017年第十天

        LocalDate someDay = localDate.of(2017,1,1).plusDays(10);

        //可以用.with方法调整不同的作息周期，还可以用withHout等调整对应的具体时间

        TemporalAdjuster NEXT_WORKDAY = w -> {

            LocalDate localDate1 = (LocalDate)w;

            do {

                localDate1 = localDate1.plusDays(1);

            } while (localDate1.getDayOfWeek().getValue() >= 6);

            return localDate1;

        };

        LocalDate backToWork = localDate.with(NEXT_WORKDAY);

        System.out.println(backToWork.toString());

        //时间根据时区调整

        ZonedDateTime zonedDateTime = ZonedDateTime.of(2017,5,1,1,1,1,1, ZoneId.of("America/New_York"));

        System.out.println(zonedDateTime.toString());

        //各种日期信息打印格式模板

        String format = DateTimeFormatter.ISO_DATE.format(localDate);

        System.out.println(format);

        //变为本土化显示，ofPattern自定义格式。

        DateTimeFormatter format1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);

        System.out.println(format1.format(zonedDateTime));

    }

}

巴特西

JAVA8-待续

最新文章

热门文章