java8有哪些经典java课程里未曾提及的东西？

1. default关键字, 看源码无意看到Collection.removeIf方法

笔者阅读Collection接口时看到如下的东西(然后花了一天时间就有了这篇文章)：

     * @since 1.8
     */
    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;
    }

看的我一脸懵逼，Collection接口里面怎么会有方法实现？！！再看看还有一些static静态方法根据所学知识：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。java8原则性的东西都改么？！！！

后来楼主发现Java8新增了default关键字，可以使接口有自己的默认的实现类，而且还不影响接口的实现类。

2. stream技术，这是java8最为被人推崇的技术，甚至说上述接口能写实现方法，就是为了stream技术而进行的让步，stream能自动进行并行运算，计算结束后再合并，对于服务器多核环境能显著提高速度，并行运算能力以及云计算的普及，这项技术将会普及。

有的地方称之为数据流技术，这项技术并不是单独的一个知识点，会和下面的lambda表达式函数式编程一块出现，所以看到这部分代码可能会一脸懵逼。

什么是数据流？
流代表从支持聚合操作源的序列的对象。以下是数据流的特点。

• 元素序列 - 流提供了一组特定类型的以顺序方式元素。流获取/计算需求的元素。它不存储元素。

• 源- 流使用集合，数组或I/O资源为输入源。

• 聚合操作 - 数据流支持如filter, map, limit, reduced, find, match等聚合操作。

• 管道传输 - 大多数流操作的返回流本身使他们的结果可以被管道传输。这些操作被称为中间操作以及它们的功能是利用输入，处理输入和输出返回到目标。collect()方法是终端操作，这是通常出现在管道传输操作结束标记流的结束。

• 自动迭代 - 流操作内部做了反复对比，其中明确迭代需要集合提供源元素。

---

生成数据流

使用Java8，Collection 接口有两个方法来生成流。

• stream() -返回顺序流考虑集合作为其源。

• parallelStream() - 返回并行数据流考虑集合作为其源。

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
// 这里 -> 是java8里的Lambda表达式，后文详述

ForEach

数据流提供了新的forEach方法遍历该流中的每个元素。考虑下面的例子打印10个随机数字。

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);
// 这里 :: 是java8新特性函数引用，后文详述

map

map方法用于映射每个元素对应的结果。考虑下面的例子打印唯一的方形数字。

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
//get list of unique squares
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

filter

filter方法用于消除基于标准元素。考虑下面的例子打印空字符串计数(总数)。

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//get count of empty string
int count = strings.stream().filter(string -> string.isEmpty()).count();

limit

limit 方法用于减少流的大小。考虑下面的例子打印10个随机数字。

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

sorted

sorted方法用来流排序。考虑下面的例子打印10个随机数字的排序顺序。

Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);

并行处理

parallelStream是流进行并行处理的替代方案。考虑下面的例子打印空字符串计数。

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//get count of empty string
int count = strings.parallelStream().filter(string -> string.isEmpty()).count();

这是很容易在顺序和并行的流之间进行切换。
收集器

收集器是用来处理组合在一个数据流的元素的结果。收集器可用于返回一个列表或一个字符串。

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println("Filtered List: " + filtered);       
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("Merged String: " + mergedString);

统计

使用Java8，统计收集器引入计算所有统计数据时，流处理可以做这些。

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

IntSummaryStatistics stats = integers.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println("Highest number in List : " + stats.getMax());
System.out.println("Lowest  number in List : " + stats.getMin());
System.out.println("Sum of all numbers : " + stats.getSum());
System.out.println("Average of all  numbers : " + stats.getAverage());

Stream 例子

import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.Map;

public class Java8Tester {
   public static void main(String args[]){

      System.out.println("Using Java 7: ");
      // Count empty strings
      List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
      System.out.println("List: " +strings);
      long count = getCountEmptyStringUsingJava7(strings);      
      System.out.println("Empty Strings: " + count);

      count = getCountLength3UsingJava7(strings);       
      System.out.println("Strings of length 3: " + count);

      //Eliminate empty string
      List<String> filtered =  deleteEmptyStringsUsingJava7(strings);
      System.out.println("Filtered List: " + filtered);

      //Eliminate empty string and join using comma.
      String mergedString = getMergedStringUsingJava7(strings,", ");
      System.out.println("Merged String: " + mergedString);

      List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

      //get list of square of distinct numbers
      List<Integer> squaresList =  getSquares(numbers);
      System.out.println("Squares List: " + squaresList);

      List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
      System.out.println("List: " +integers);
      System.out.println("Highest number in List : " + getMax(integers));
      System.out.println("Lowest number in List : " + getMin(integers));
      System.out.println("Sum of all numbers : " + getSum(integers));
      System.out.println("Average of all numbers : " + getAverage(integers));
      System.out.println("Random Numbers: ");
      //print ten random numbers
      Random random = new Random();
      for(int i=0; i < 10; i++){
         System.out.println(random.nextInt());
      }
      System.out.println("Using Java 8: ");
      System.out.println("List: " +strings);
      count = strings.stream().filter(string->string.isEmpty()).count();
      System.out.println("Empty Strings: " + count);

      count = strings.stream().filter(string -> string.length() == 3).count();
      System.out.println("Strings of length 3: " + count);

      filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
      System.out.println("Filtered List: " + filtered);

      mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
      System.out.println("Merged String: " + mergedString);

      squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
      System.out.println("Squares List: " + squaresList);      

      System.out.println("List: " +integers);
      IntSummaryStatistics stats = integers.stream().mapToInt((x) -> x).summaryStatistics();

      System.out.println("Highest number in List : " + stats.getMax());
      System.out.println("Lowest  number in List : " + stats.getMin());
      System.out.println("Sum of all numbers : " + stats.getSum());
      System.out.println("Average of all  numbers : " + stats.getAverage());
      System.out.println("Random Numbers: ");
      random.ints().limit(10).sorted().forEach(System.out::println);

      //parallel processing
      count = strings.parallelStream().filter(string -> string.isEmpty()).count();
      System.out.println("Empty Strings: " + count);
   }

   private static int getCountEmptyStringUsingJava7(List<String> strings){
      int count = 0;
      for(String string: strings){
         if(string.isEmpty()){
            count++;
         }
      }
      return count;
   }
   private static int getCountLength3UsingJava7(List<String> strings){
      int count = 0;
      for(String string: strings){
         if(string.length() == 3){
            count++;
         }
      }
      return count;
   }   
   private static List<String> deleteEmptyStringsUsingJava7(List<String> strings){
      List<String> filteredList = new ArrayList<String>();
      for(String string: strings){
         if(!string.isEmpty()){
            filteredList.add(string);
         }
      }     
      return filteredList;
   }

   private static String getMergedStringUsingJava7(List<String> strings, String seperator){
      StringBuilder stringBuilder = new StringBuilder();
      for(String string: strings){
         if(!string.isEmpty()){
            stringBuilder.append(string);
            stringBuilder.append(seperator);
         }
      } 
      String mergedString = stringBuilder.toString();
      return  mergedString.substring(0, mergedString.length()-2);
   }

   private static List<Integer> getSquares(List<Integer> numbers){
      List<Integer> squaresList = new ArrayList<Integer>();
      for(Integer number: numbers){
         Integer square = new Integer(number.intValue() * number.intValue());
         if(!squaresList.contains(square)){
            squaresList.add(square);
         }
      }     
      return squaresList;
   }

   private static int getMax(List<Integer> numbers){
      int max = numbers.get(0);
      for(int i=1;i< numbers.size();i++){
         Integer number = numbers.get(i);
         if(number.intValue() > max){
            max = number.intValue();
         }
      }     
      return max;
   }

   private static int getMin(List<Integer> numbers){
      int min = numbers.get(0);
      for(int i=1;i< numbers.size();i++){
         Integer number = numbers.get(i);
         if(number.intValue() < min){
            min = number.intValue();
         }
      }     
      return min;
   }

   private static int getSum(List<Integer> numbers){
      int sum = numbers.get(0);
      for(int i=1;i< numbers.size();i++){
         sum += numbers.get(i).intValue();          
      }     
      return sum;
   }
   private static int getAverage(List<Integer> numbers){
      return getSum(numbers) / numbers.size();
   }
}

3. Lambda表达式

语法：
parameter -> expression body
参数 -> 运算
注意：
- 可选类型声明 - 无需声明参数的类型。编译器可以从该参数的值推断。
- 可选圆括号参数 - 无需在括号中声明参数。对于多个参数，括号是必需的。
- 可选大括号 - 表达式主体没有必要使用大括号，如果主体中含有一个单独的语句。
- 可选return关键字 - 编译器会自动返回值，如果主体有一个表达式返回的值。花括号是必需的，以表明表达式返回一个值。
例如：

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();

      //with type declaration
      MathOperation addition = (int a, int b) -> a + b;

      //with out type declaration
      MathOperation subtraction = (a, b) -> a - b;

      //with return statement along with curly braces
      MathOperation multiplication = (int a, int b) -> { return a * b; };
      //without return statement and without curly braces
      MathOperation division = (int a, int b) -> a / b;

      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));       
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));

      //with parenthesis
      GreetingService greetService1 = message -> System.out.println("Hello " + message);

      //without parenthesis
      GreetingService greetService2 = (message) -> System.out.println("Hello " + message);

      greetService1.sayMessage("Mahesh");
      greetService2.sayMessage("Suresh");      
   }   

   interface MathOperation {
      int operation(int a, int b);
   }  

   interface GreetingService {
      void sayMessage(String message);
   }

   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   } 
}

4. java.util.Function包下的函数式接口

例如：

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Java8Tester {
   public static void main(String args[]){

      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

      // Predicate<Integer> predicate = n -> true
      // n is passed as parameter to test method of Predicate interface
      // test method will always return true no matter what value n has.
      System.out.println("Print all numbers:");     
      //pass n as parameter 
      eval(list, n->true);

      // Predicate<Integer> predicate1 = n -> n%2 == 0
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n%2 comes to be zero
      System.out.println("Print even numbers:");
      eval(list, n-> n%2 == 0 ); 

      // Predicate<Integer> predicate2 = n -> n > 3
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n is greater than 3.
      System.out.println("Print numbers greater than 3:");
      eval(list, n-> n > 3 );
   }   

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

5. 方法引用 “：：”运算符

可以指向这些方法：
- 静态方法。
- 实例方法。
- 使用new运算符构造函数(TreeSet::new)

我想到了js里的回调函数

import java.util.List;
import java.util.ArrayList;
public class Java8Tester {

   public static void main(String args[]){

      List names = new ArrayList();
      names.add("Mahesh");
      names.add("Suresh");
      names.add("Ramesh");
      names.add("Naresh");
      names.add("Kalpesh");
    // 打印输出可以这样写
      names.forEach(System.out::println);
   }   
}

6.Optional对象

这个类有各种实用的方法，以方便代码来处理为可用或不可用，而不是检查null值。
public final class Optional <T> extends Object
例子：

import java.util.Optional;

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester java8Tester = new Java8Tester();

      Integer value1 =  null;
      Integer value2 =  new Integer(10);
      //Optional.ofNullable - allows passed parameter to be null.
      Optional<Integer> a = Optional.ofNullable(value1);
      //Optional.of - throws NullPointerException if passed parameter is null
      Optional<Integer> b = Optional.of(value2);        

      System.out.println(java8Tester.sum(a,b));
   }

   public Integer sum(Optional<Integer> a, Optional<Integer> b){
      //Optional.isPresent - checks the value is present or not
      System.out.println("First parameter is present: " + a.isPresent());

      System.out.println("Second parameter is present: " + b.isPresent());

      //Optional.orElse - returns the value if present otherwise returns
      //the default value passed.
      Integer value1 = a.orElse(new Integer(0));    

      //Optional.get - gets the value, value should be present
      Integer value2 = b.get();

      return value1 + value2;
   }    
}

### 7 Nashorn脚本引擎
jjs
java8 提供了控制台交互工具jjs，可以直接运行javaScript命令，或者执行js文件，感觉就像使用Node.js的控制台交互，大概是java在和Node.js以及谷歌V8引擎竞争

---

解读js文件

创建并保存sample.js在 C：> JAVA 文件夹。
sample.js

print('Hello World!');

打开控制台并使用下面的命令。

C:\JAVA>jjs sample.js

看到结果

Hello World!

JJS在交互模式

打开控制台并使用下面的命令

C:\JAVA>jjs 
jjs> print("Hello, World!")
Hello, World!
jjs> quit()
>>

传递参数

打开控制台并使用下面的命令。

C:\JAVA> jjs -- a b c
jjs> print('letters: ' +arguments.join(", "))
letters: a, b, c
jjs>

*在JAVA调用JavaScript

使用ScriptEngineManager，JavaScript代码用Java编写可以被调用。
示例

选择使用任何编辑器创建以下java程序在 C:/> JAVA
Java8Tester.java

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class Java8Tester {
   public static void main(String args[]){
      ScriptEngineManager scriptEngineManager = new ScriptEngineManager(); 
      ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn"); 
      String name = "Mahesh"; 

      Integer result = null;
      try {
         nashorn.eval("print('" + name + "')");
         result = (Integer) nashorn.eval("10 + 2");   
      }catch(ScriptException e){
         System.out.println("Error executing script: "+ e.getMessage());
      }
      System.out.println(result.toString());
   } 
}

从JavaScript调用Java

下面的例子将展示如何导入和使用Java类的Java脚本。

创建并保存 sample.js 在 c: > JAVA 文件夹.
sample.js

var BigDecimal = Java.type('java.math.BigDecimal'); 

function calculate(amount, percentage) { 
   var result = new BigDecimal(amount).multiply( 
      new BigDecimal(percentage)).divide( 
         new BigDecimal("100"), 2, BigDecimal.ROUND_HALF_EVEN); 
   return result.toPlainString(); 
}
var result = calculate(568000000000000000023,13.9); 
print(result);

打开控制台并使用下面的命令。

C:\JAVA>jjs sample.js

其余还有时间日期接口的变化，base64编码的支持等

对java8关注的重点应是 函数式的支持以及数据流stream

参考文献 ：java8教程