new Thread(new Runnable() { @Override public void run() { System.out.println("inside runnable using an anonymous inner class"); } }).start(); 

new Thread(() -> System.out.println("inside Thread constructor using lambda")).start(); 

Runnable r = () -> System.out.println("lambda expression implementing the run method"); 

String[] names = directory.list((dir, name) -> name.endsWith(".java")); System.out.println(Arrays.asList(names)); 

String[] names = directory.list((File dir, String name) -> { return name.endsWith(".java"); }); 

// Consumer<Integer> functional interface Consumer<Integer> printer = System.out::println; Stream.of(3, 1, 4, 1, 5, 9).forEach(printer); 

public interface Collection<E> extends Iterable<E> { boolean isEmpty(); default boolean removeIf(Predicate<? super E> filter) { Objects.requireNonNull(filter); boolean removed = false; final Iterator<E> each = iterator(); while (each.hasNext()) { if (filter.test(each.next())) { each.remove(); removed = true; } } return removed; } } // usage  boolean removed = Arrays.asList(3, 1, 4, 1, 5, 9).removeIf(n -> n <= 0); 

// implement public interface Iterable<T> { Iterator<T> iterator(); default void forEach(Consumer<? super T> action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); } } } // usage Arrays.asList("this", "is", "a", "list", "of", "strings").forEach(System.out::println); 

Supplier<T> sippiler = () -> T; DoubleSupplier randomSupplier = Math::random; // 此時才呼叫 Math.random() System.out.println(randomSupplier.getDouble()); 

// implement public static boolean predicateTest(int value, Predicate<Integer> predicate) { return predicate.test(value); } // usage predicateTest(3, (x) -> x == 3); // Stream implement Stream<T> filter(Predicate<? super T> predicate); abstract class IntPipeline<E_IN> extends AbstractPipeline<E_IN, Integer, IntStream> implements IntStream { @Override public final IntStream filter(IntPredicate predicate) { Objects.requireNonNull(predicate); return new StatelessOp<Integer>(this, StreamShape.INT_VALUE, StreamOpFlag.NOT_SIZED) { @Override Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) { return new Sink.ChainedInt<Integer>(sink) { @Override public void begin(long size) { downstream.begin(-1); } @Override public void accept(int t) { // 檢查是否通過測試 if (predicate.test(t)) downstream.accept(t); } }; } }; } } // usage Arrays.asList("this", "is", "a", "list", "of", "strings") .stream() .filter(s -> s.length() == 2) .collect(Collectors.joining(", ")); 

// implement static int modifyTheValue(int valueToBeOperated, Function<Integer, Integer> function) { return function.apply(valueToBeOperated); } // usage modifyTheValue(10, (x)-> x + 20); // Stream implement abstract class ReferencePipeline<P_IN, P_OUT> extends AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>> implements Stream<P_OUT> { @Override @SuppressWarnings("unchecked") public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) { Objects.requireNonNull(mapper); return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE, StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) { @Override Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) { return new Sink.ChainedReference<P_OUT, R>(sink) { @Override public void accept(P_OUT u) { downstream.accept(mapper.apply(u)); } }; } }; } } // usage Arrays.asList("this", "is", "a", "list", "of", "strings") .stream() .map(String::length) .collect(Collectors.toList()); 

// 呼叫流程 Arrays.stream -> StreamSupport.stream -> return ReferencePipeline.Head -> filter (or the method you need) 

public List<String> defaultSort() { Collections.sort(list); return sampleStrings; } 

public List<String> defaultSortUsingStreams() { return list.stream() .sorted() .collect(Collectors.toList()); } 

<R, A> R collect(Collector<? super T, A, R> collector); <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner); 

// 去除空值資料 List<String> nonNullStrings = Arrays.asList( "this", null, "is", "a", null, "list", "of", "strings", null) .stream().filter(Objects::nonNull).collect(Collectors.toList()); 

int total = 0; // 錯誤 lambdas 無法存取 local var Arrays.asList(3, 1, 4, 1, 5, 9).forEach(n -> total += n); // 使用 function 傳入屬性進行存取 Arrays.asList(3, 1, 4, 1, 5, 9) .stream().mapToInt(Integer::valueOf).sum() 

List<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9); // 匿名方法 integers.forEach(new Consumer<Integer>() { @Override public void accept(Integer integer) { System.out.println(integer); } }); // 完整敘述式 lambda integers.forEach((Integer n) -> {System.out.println(n);}); // 表達式 lambda integers.forEach(n -> System.out.println(n)); // 方法參照 integers.forEach(System.out::println); 

// 使用 encode 必須處理 UnsupportedEncodingException Arrays.stream(values).map(s -> URLEncoder.encode(s, "UTF-8"))).collect(Collectors.toList()); // solution Arrays.stream(values) .map(s -> { try { return URLEncoder.encode(s, "UTF-8"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); return ""; } }) .collect(Collectors.toList()); 

@FunctionalInterface public interface FunctionWithException<T, R, E extends Exception> { R apply(T t) throws E; } private static <T, R, E extends Exception> Function<T, R> wrapper(FunctionWithException<T, R, E> fe) { return arg -> { try { return fe.apply(arg); } catch (Exception e) { throw new RuntimeException(e); } }; } Arrays.stream(values).map(wrapper(s -> URLEncoder.encode(s, "UTF-8"))).collect(Collectors.toList()); 

AtomicInteger counter = new AtomicInteger(); Optional<AtomicInteger> opt = Optional.ofNullable(counter); System.out.println(optional); // Optional[0] counter.incrementAndGet(); System.out.println(optional); // Optional[1] optional.get().incrementAndGet(); // 重新指定內容 optional = Optional.ofNullable(new AtomicInteger()); 

Optional<String> firstOdd = Stream.of("five", "even", "length", "string", "values") .filter(s -> s.length() % 2 != 0) .findFirst(); // throws NoSuchElementException System.out.println(firstOdd.get()); // 使用 isPresent 檢查空值 System.out.println( firstOdd.isPresent() ? firstOdd.get() : "No even length strings"); // 如值為空回傳預設值 firstOdd.orElse("No even length strings"); // 如值為空執行Methods並回傳值 firstOdd.orElseGet(() -> new String()); 

try (Stream<String> lines = Files.lines(Paths.get("/usr/share/dict/web2")) { lines.filter(s -> s.length() > 20) .sorted(Comparator.comparingInt(String::length).reversed()).limit(10) .forEach(w -> System.out.printf("%s (%d)%n", w, w.length())); } catch (IOException e) { e.printStackTrace(); } 

try (Stream<Path> paths = Files.walk(Paths.get("src/main/java"))) { paths.forEach(System.out::println); } catch (IOException e) { e.printStackTrace(); } 

try (Stream<Path> paths = Files.find(Paths.get("src/main/java"), Integer.MAX_VALUE, (path, attributes) -> !attributes.isDirectory() && path.toString().contains("fileio"))) { paths.forEach(System.out::println); } catch (IOException e) { e.printStackTrace(); } 

// Instant.now(): 2017-06-20T17:27:08.184Z System.out.println("Instant.now(): " + Instant.now()); // LocalDate.now(): 2017-06-20 System.out.println("LocalDate.now(): " + LocalDate.now()); // LocalTime.now(): 13:27:08.318 System.out.println("LocalTime.now(): " + LocalTime.now()); // LocalDateTime.now(): 2017-06-20T13:27:08.319 System.out.println("LocalDateTime.now(): " + LocalDateTime.now()); // ZonedDateTime.now(): 2017-06-20T13:27:08.319-04:00[America/New_York] System.out.println("ZonedDateTime.now(): " + ZonedDateTime.now()); 

package datetime; import java.sql.Timestamp; import java.time.LocalDate; import java.time.LocalDateTime; import java.util.Date; public class ConvertDate { public LocalDate convertFromSqlDatetoLD(java.sql.Date sqlDate) { return sqlDate.toLocalDate(); } public java.sql.Date convertToSqlDateFromLD(LocalDate localDate) { return java.sql.Date.valueOf(localDate); } public LocalDateTime convertFromTimestampToLDT(Timestamp timestamp) { return timestamp.toLocalDateTime(); } public Timestamp convertToTimestampFromLDT(LocalDateTime localDateTime) { return Timestamp.valueOf(localDateTime); } } 

// 下列陣列將不會按順訊印出 Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9) .parallelStream().forEach(out::println); // 使用 forEachOrdered 強制以順序印出 Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9) .parallelStream().forEachOrdered(out::println); 

class Person { int id; String name; String sex; float height; } // 傳統迴圈 public List<Person> constructPersons() { List<Person> persons = new ArrayList<Person>(); for (int i = 0; i < 5; i++) { Person p = new Person(i, "name" + i, "sex" + i, i); persons.add(p); } return persons; } // 迴圈 public void doFor(List<Person> persons) { long start = System.currentTimeMillis(); for (Person p : persons) { System.out.println(p.name); } long end = System.currentTimeMillis(); System.out.println("doFor cost:" + (end - start)); } // 串流 public void doStream(List<Person> persons) { long start = System.currentTimeMillis(); persons.stream().forEach(x -> System.out.println(x.name)); long end = System.currentTimeMillis(); System.out.println("doStream cost:" + (end - start)); } // 並行 public void doParallelStream(List<Person> persons) { long start = System.currentTimeMillis(); persons.parallelStream().forEach(x -> System.out.println(x.name)); long end = System.currentTimeMillis(); System.out.println("doParallelStream cost:" + (end - start)); } 

import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; import java.util.stream.IntStream; @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) @State(Scope.Thread) @Fork(value = 2, jvmArgs = {"-Xms4G", "-Xmx4G"}) public class DoublingDemo { public int doubleIt(int n) { try { Thread.sleep(100); } catch (InterruptedException ignored) { } return n * 2; } @Benchmark public int doubleAndSumSequential() { return IntStream.of(3, 1, 4, 1, 5, 9).map(this::doubleIt).sum(); } @Benchmark public int doubleAndSumParallel() { return IntStream.of(3, 1, 4, 1, 5, 9) .parallel().map(this::doubleIt).sum(); } } 

// 改變 pool 大小 System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "20"); // 使用自定的 ForkJoinPool 執行 parallel ForkJoinPool pool = new ForkJoinPool(15); ForkJoinTask<Long> task = pool.submit(() -> LongStream.rangeClosed(1, 3_000_000).parallel().sum()); 

public void getIfNotCancelled(Future<String> future) { if (!future.isCancelled()) { System.out.println(future.get()); } else { System.out.println("Cancelled"); } } ExecutorService service = Executors.newCachedThreadPool(); Future<String> future = service.submit(new Callable<String>() { @Override public String call() throws Exception { Thread.sleep(100); return "Hello, World!"; } }); // 取消 service submit future.cancel(true); System.out.println("Processing..."); getIfNotCancelled(future); 

package com.oreilly.suppliers; public class NamesSupplier implements Supplier<Stream<String>> { private Path namesPath = Paths.get("server/src/main/resources/names.txt"); @Override public Stream<String> get() { try { return Files.lines(namesPath); } catch (IOException e) { e.printStackTrace(); return null; } } } // module-info.java module com.oreilly.suppliers { exports com.oreilly.suppliers; } 

package com.kousenit.clients; import com.oreilly.suppliers.NamesSupplier; public class Main { public static void main(String[] args) throws IOException { NamesSupplier supplier = new NamesSupplier(); try (Stream<String> lines = supplier.get()) { lines.forEach(line -> System.out.printf("Hello, %s!%n", line)); } } } // module-info.java module com.kousenit.clients { requires com.oreilly.suppliers; } 

public interface SumNumbers { default int addEvens(int... nums) { return add(n -> n % 2 == 0, nums); } default int addOdds(int... nums) { return add(n -> n % 2 != 0, nums); } private int add(IntPredicate predicate, int... nums) { return IntStream.of(nums) .filter(predicate) .sum(); } } class PrivateDemo implements SumNumbers {} public class SumNumbersTest { private SumNumbers demo = new PrivateDemo(); @Test public void addEvens() throws Exception { assertEquals(2 + 4 + 6, demo.addEvens(1, 2, 3, 4, 5, 6)); } @Test public void addOdds() throws Exception { assertEquals(1 + 3 + 5, demo.addOdds(1, 2, 3, 4, 5, 6)); } } 

@Test(expected = UnsupportedOperationException.class) public void showImmutabilityAdd() throws Exception { List<Integer> intList = List.of(1, 2, 3); intList.add(99); } @Test(expected = UnsupportedOperationException.class) public void showImmutabilityClear() throws Exception { List<Integer> intList = List.of(1, 2, 3); intList.clear(); } @Test(expected = UnsupportedOperationException.class) public void showImmutabilityRemove() throws Exception { List<Integer> intList = List.of(1, 2, 3); intList.remove(0); } @Test(expected = UnsupportedOperationException.class) public void showImmutabilityReplace() throws Exception { List<Integer> intList = List.of(1, 2, 3); intList.replaceAll(n -> -n); } @Test(expected = UnsupportedOperationException.class) public void showImmutabilitySet() throws Exception { List<Integer> intList = List.of(1, 2, 3); intList.set(0, 99); } // 如果將不可變動集合塞入物件，將可改變物件內容 @Test public void areWeImmutableOrArentWe() throws Exception { List<Holder> holders = List.of(new Holder(1), new Holder(2)); assertEquals(1, holders.get(0).getX()); holders.get(0).setX(4); assertEquals(4, holders.get(0).getX()); } 

// Java8 方法 List<BigDecimal> bigDecimals = Stream.iterate(BigDecimal.ZERO, bd -> bd.add(BigDecimal.ONE)).limit(10).collect(Collectors.toList()); // Java9 方法 bigDecimals = Stream.iterate(BigDecimal.ZERO, bd -> bd.longValue() < 10L, bd -> bd.add(BigDecimal.ONE)) .collect(Collectors.toList()); 

// Java8 用法 public List<LocalDate> getDays_java8(LocalDate start, LocalDate end) { Period period = start.until(end); return LongStream.range(0, ChronoUnit.DAYS.between(start, end)) .mapToObj(start:plusDays) .collect(Collectors.toList()); } LocalDate start = LocalDate.of(2017, Month.JUNE, 10); LocalDate end = LocalDate.of(2017, Month.JUNE, 17); System.out.println(dateRange.getDays_java8(start, end)); // Java9 用法 public List<LocalDate> getDays_java9(LocalDate start, LocalDate end) { return start.datesUntil(end).collect(Collectors.toList()); } public List<LocalDate> getMonths_java9(LocalDate start, LocalDate end) { return start.datesUntil(end, Period.ofMonths(1)).collect(Collectors.toList()); } 

// Java8 用法 // inputstream try(InputStream stream1 = new InputStream(....); InputStream stream2 = new InputStream(....)) { ... } // connection try (Connection con = DriverManager.getConnection(myConnectionURL); PreparedStatement ps = createPreparedStatement(con, userId); ResultSet rs = ps.executeQuery()) { // process the resultset here, all resources will be cleaned up } catch (Exception e) { e.printStackTrace(); } // Java9 用法 InputStream stream1 = new InputStream(....); InputStream stream2 = new InputStream(....); .... try(stream1;stream2){ .... } 

// java.util.Map.Entry static <K extends Comparable<? super K>,V> Comparator<Map.Entry<K,V>> comparingByKey() // or this one from java.util.Comparator: static <T,U extends Comparable<? super U>> Comparator<T> comparing( Function<? super T,? extends U> keyExtractor) // or even this monster from java.util.stream.Collectors: static <T,K,D,A,M extends Map<K, D>> Collector<T,?,M> groupingBy( Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream) 

List<String> strings = new ArrayList<>(); strings.add("Hello"); strings.add("World"); // strings.add(new Date()); // Integer i = strings.get(0); 編譯不過 for (String s : strings) { System.out.printf("%s has length %d%n", s, s.length()); } 

boolean add(E e) boolean addAll(Collection<? extends E> c) void clear() boolean contains(Object o) boolean containsAll(Collection<?> c) E get(int index) 

List<String> strings = new ArrayList<>(); String s = "abc"; String s = "abc"; Object o = s; // 這樣的代碼是不被允許的 strings.add(o); 

List<?> stuff = new ArrayList<>(); // 未指定泛型的 list 不能被寫入 stuff.add("abc"); stuff.add(new Object()); stuff.add(3); // 但是能被讀取 int numElements = stuff.size(); 

List<? extends Number> numbers = new ArrayList<>(); // numbers.add(3); // numbers.add(3.14159); // numbers.add(new BigDecimal("3")); 

private static double sumList(List<? extends Number> list) { return list.stream().mapToDouble(Number::doubleValue).sum(); } List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5); List<Double> doubles = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0); List<BigDecimal> bigDecimals = Arrays.asList( new BigDecimal("1.0"),new BigDecimal("2.0"),new BigDecimal("3.0"),new BigDecimal("4.0"),new BigDecimal("5.0")); System.out.printf("ints sum is %s%n", sumList(ints)); System.out.printf("doubles sum is %s%n", sumList(doubles)); System.out.printf("big decimals sum is %s%n", sumList(bigDecimals)); 

public void numsUpTo(Integer num, List<? super Integer> output) { IntStream.rangeClosed(1, num).forEach(output::add); } ArrayList<Integer> integerList = new ArrayList<>(); ArrayList<Number> numberList = new ArrayList<>(); ArrayList<Object> objectList = new ArrayList<>(); numsUpTo(5, integerList); numsUpTo(5, numberList); numsUpTo(5, objectList); 

T extends Runnable & AutoCloseable