Java8特性

Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );

Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );

String separator &＃61; ",";
//separator &＃61; ";;";//该行编译时会报错&＃xff1a;从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
Arrays.asList( "a", "b", "d" ).forEach(
( String e ) -> System.out.print( e &＃43; separator ) );

final String separator &＃61; ",";
Arrays.asList( "a", "b", "d" ).forEach(( String e ) -> System.out.print( e &＃43; separator ) );

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {int result &＃61; e1.compareTo( e2 );return result;
} );

&＃64;FunctionalInterface
public interface Functional {void method();
}

&＃64;FunctionalInterface
public interface FunctionalDefaultMethods {void method();default void defaultMethod() {}
}

Runnable r &＃61; () ->{ System.out.println("Running!"); }

private interface Defaulable {// Interfaces now allow default methods, the implementer may or// may not implement (override) them.default String notRequired() {return "Default implementation";}
}private static class DefaultableImpl implements Defaulable {}private static class OverridableImpl implements Defaulable {&＃64;Overridepublic String notRequired() {return "Overridden implementation";}
}

private interface DefaulableFactory {// Interfaces now allow static methodsstatic Defaulable create( Supplier supplier ) {return supplier.get();}
}

public static void main( String[] args ) {Defaulable defaulable &＃61; DefaulableFactory.create( DefaultableImpl::new );System.out.println( defaulable.notRequired() );defaulable &＃61; DefaulableFactory.create( OverridableImpl::new );System.out.println( defaulable.notRequired() );
}

Default implementation
Overridden implementation

public static class Car {public static Car create( final Supplier supplier ) {return supplier.get();} public static void collide( final Car car ) {System.out.println( "Collided " &＃43; car.toString() );}public void follow( final Car another ) {System.out.println( "Following the " &＃43; another.toString() );}public void repair() {System.out.println( "Repaired " &＃43; this.toString() );}
}

final Car car &＃61; Car.create( Car::new );
final List cars &＃61; Arrays.asList( car );

cars.forEach( Car::collide );

cars.forEach( Car::repair );

final Car police &＃61; Car.create( Car::new );
cars.forEach( police::follow );

Collided com.javacodegeeks.java8.method.references.MethodReferences$Car&＃64;7a81197d
Repaired com.javacodegeeks.java8.method.references.MethodReferences$Car&＃64;7a81197d
Following the com.javacodegeeks.java8.method.references.MethodReferences$Car&＃64;7a81197d

Optional fullName &＃61; Optional.ofNullable( null );
System.out.println( "Full Name is set? " &＃43; fullName.isPresent() );
System.out.println( "Full Name: " &＃43; fullName.orElseGet( () -> "[none]" ) );
System.out.println( fullName.map( s -> "Hey " &＃43; s &＃43; "!" ).orElse( "Hey Stranger!" ) );

Full Name is set? false
Full Name: [none]
Hey Stranger!

Optional firstName &＃61; Optional.of( "Tom" );
System.out.println( "First Name is set? " &＃43; firstName.isPresent() );
System.out.println( "First Name: " &＃43; firstName.orElseGet( () -> "[none]" ) );
System.out.println( firstName.map( s -> "Hey " &＃43; s &＃43; "!" ).orElse( "Hey Stranger!" ) );
System.out.println();

First Name is set? true
First Name: Tom
Hey Tom!  

public Map getIdNameMap(List accounts) {return accounts.stream().collect(Collectors.toMap(Account::getId, Account::getUsername));
}

public Map getIdAccountMap(List accounts) {return accounts.stream().collect(Collectors.toMap(Account::getId, account -> account));
}

public Map getIdAccountMap(List accounts) {return accounts.stream().collect(Collectors.toMap(Account::getId, Function.identity()));
}

public Map getNameAccountMap(List accounts) {return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity()));
}

public Map getNameAccountMap(List accounts) {return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity(), (key1, key2) -> key2));
}

public Map getNameAccountMap(List accounts) {return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity(), (key1, key2) -> key2, LinkedHashMap::new));
}

public class Streams {private enum Status {OPEN, CLOSED};private static final class Task {private final Status status;private final Integer points;Task( final Status status, final Integer points ) {this.status &＃61; status;this.points &＃61; points;}public Integer getPoints() {return points;}public Status getStatus() {return status;}&＃64;Overridepublic String toString() {return String.format( "[%s, %d]", status, points );}
}
}

final Collection tasks &＃61; Arrays.asList(new Task( Status.OPEN, 5 ),new Task( Status.OPEN, 13 ),new Task( Status.CLOSED, 8 )
);

// Calculate total points of all active tasks using sum()
final long totalPointsOfOpenTasks &＃61; tasks.stream().filter( task -> task.getStatus() &＃61;&＃61; Status.OPEN ).mapToInt( Task::getPoints ).sum();
System.out.println( "Total points: " &＃43; totalPointsOfOpenTasks );

Total points: 18

// Calculate total points of all tasks
final double totalPoints &＃61; tasks.stream().parallel().map( task -> task.getPoints() ) // or map( Task::getPoints ).reduce( 0, Integer::sum );
System.out.println( "Total points (all tasks): " &＃43; totalPoints );

Total points (all tasks): 26.0

// Group tasks by their status
final Map > map &＃61; tasks.stream().collect( Collectors.groupingBy( Task::getStatus ) );
System.out.println( map );

{CLOSED&＃61;[[CLOSED, 8]], OPEN&＃61;[[OPEN, 5], [OPEN, 13]]}

// Group tasks by their status
final Map map &＃61; tasks.stream().collect( Collectors.groupingBy( Task::getStatus, Collectors.counting()) );
System.out.println( map );

// Group tasks by their status
final Map map &＃61; tasks.stream().collect( Collectors.groupingBy( Task::getStatus, Collectors.averagingInt(Task::getPoints)) );
System.out.println( map );

// Calculate the weight of each tasks (as percent of total points)
final Collection result &＃61; tasks.stream() // Stream.mapToInt( Task::getPoints ) // IntStream.asLongStream() // LongStream.mapToDouble( points -> points / totalPoints ) // DoubleStream.boxed() // Stream.mapToLong( weigth -> ( long )( weigth * 100 ) ) // LongStream.mapToObj( percentage -> percentage &＃43; "%" ) // Stream.collect( Collectors.toList() ); // List
System.out.println( result );

[19%, 50%, 30%]

final Path path &＃61; new File( filename ).toPath();
try( Stream lines &＃61; Files.lines( path, StandardCharsets.UTF_8 ) ) {lines.onClose( () -> System.out.println("Done!") ).forEach( System.out::println );
}

long t0 &＃61; System.nanoTime();
long count &＃61; values.stream().sorted().count();
System.out.println(count);
long t1 &＃61; System.nanoTime();
long millis &＃61; TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));
// 串行耗时: 899 ms

package com.javacodegeeks.java8.base64;import java.nio.charset.StandardCharsets;
import java.util.Base64; public class Base64s {
public static void main(String[] args) {
final String text &＃61; "Base64 finally in Java 8!";
final String encoded &＃61; Base64
.getEncoder()
.encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
System.out.println( encoded );
final String decoded &＃61; new String(
Base64.getDecoder().decode( encoded ),
StandardCharsets.UTF_8 );
System.out.println( decoded );
}
}

QmFzZTY0IGZpbmFsbHkgaW4gSmF2YSA4IQ&＃61;&＃61;
Base64 finally in Java 8!

import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom; public class ParallelArrays {public static void main( String[] args ) {long[] arrayOfLong &＃61; new long [ 20000 ];Arrays.parallelSetAll( arrayOfLong,index -> ThreadLocalRandom.current().nextInt( 1000000 ) );Arrays.stream( arrayOfLong ).limit( 10 ).forEach(i -> System.out.print( i &＃43; " " ) );System.out.println();Arrays.parallelSort( arrayOfLong );Arrays.stream( arrayOfLong ).limit( 10 ).forEach(i -> System.out.print( i &＃43; " " ) );System.out.println();}
}