Android基础-Java基础三

参考Java常用功能的实例代码：

http://www.runoob.com/java/java-examples.html

Java8新特性：https://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html  
    Lambda 是java8 最大的变化

1.     Lambda 表达式：允许把函数作为一个方法的参数
   
   可以使代码变的更加简洁紧凑
    

   // 1. 不需要参数,返回值为 5  
   () -> 5  
     
   // 2. 接收一个参数(数字类型),返回其2倍的值  
   x -> 2 * x  
     
   // 3. 接受2个参数(数字),并返回他们的差值  
   (x, y) -> x – y  
     
   // 4. 接收2个int型整数,返回他们的和  
   (int x, int y) -> x + y  
     
   // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
   (String s) -> System.out.print(s)

    

2.  方法引用： 方法引用通过方法的名字来指向一个方法，方法引用使用一对冒号 ::

3. 默认方法：默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法

4.  Optional: 是个容器,它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测 

   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 - 允许传递为 null 参数
         Optional<Integer> a = Optional.ofNullable(value1);
           
         // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
         Optional<Integer> b = Optional.of(value2);
         System.out.println(java8Tester.sum(a,b));
      }
       
      public Integer sum(Optional<Integer> a, Optional<Integer> b){
       
         // Optional.isPresent - 判断值是否存在
           
         System.out.println("第一个参数值存在: " + a.isPresent());
         System.out.println("第二个参数值存在: " + b.isPresent());
           
         // Optional.orElse - 如果值存在，返回它，否则返回默认值
         Integer value1 = a.orElse(new Integer(0));
           
         //Optional.get - 获取值，值需要存在
         Integer value2 = b.get();
         return value1 + value2;
      }
   }

    

5. 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("使用 Java 7: ");
           
         // 计算空字符串
         List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
         System.out.println("列表: " +strings);
         long count = getCountEmptyStringUsingJava7(strings);
           
         System.out.println("空字符数量为: " + count);
         count = getCountLength3UsingJava7(strings);
           
         System.out.println("字符串长度为 3 的数量为: " + count);
           
         // 删除空字符串
         List<String> filtered = deleteEmptyStringsUsingJava7(strings);
         System.out.println("筛选后的列表: " + filtered);
           
         // 删除空字符串，并使用逗号把它们合并起来
         String mergedString = getMergedStringUsingJava7(strings,", ");
         System.out.println("合并字符串: " + mergedString);
         List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
           
         // 获取列表元素平方数
         List<Integer> squaresList = getSquares(numbers);
         System.out.println("平方数列表: " + squaresList);
         List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
           
         System.out.println("列表: " +integers);
         System.out.println("列表中最大的数 : " + getMax(integers));
         System.out.println("列表中最小的数 : " + getMin(integers));
         System.out.println("所有数之和 : " + getSum(integers));
         System.out.println("平均数 : " + getAverage(integers));
         System.out.println("随机数: ");
           
         // 输出10个随机数
         Random random = new Random();
           
         for(int i=0; i < 10; i++){
            System.out.println(random.nextInt());
         }
           
         System.out.println("使用 Java 8: ");
         System.out.println("列表: " +strings);
           
         count = strings.stream().filter(string->string.isEmpty()).count();
         System.out.println("空字符串数量为: " + count);
           
         count = strings.stream().filter(string -> string.length() == 3).count();
         System.out.println("字符串长度为 3 的数量为: " + count);
           
         filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
         System.out.println("筛选后的列表: " + filtered);
           
         mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
         System.out.println("合并字符串: " + mergedString);
           
         squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
         System.out.println("Squares List: " + squaresList);
         System.out.println("列表: " +integers);
           
         IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
           
         System.out.println("列表中最大的数 : " + stats.getMax());
         System.out.println("列表中最小的数 : " + stats.getMin());
         System.out.println("所有数之和 : " + stats.getSum());
         System.out.println("平均数 : " + stats.getAverage());
         System.out.println("随机数: ");
           
         random.ints().limit(10).sorted().forEach(System.out::println);
           
         // 并行处理
         count = strings.parallelStream().filter(string -> string.isEmpty()).count();
         System.out.println("空字符串的数量为: " + 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 separator){
         StringBuilder stringBuilder = new StringBuilder();
           
         for(String string: strings){
           
            if(!string.isEmpty()){
               stringBuilder.append(string);
               stringBuilder.append(separator);
            }
         }
         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 numbers){
         int sum = (int)(numbers.get(0));
           
         for(int i=1;i < numbers.size();i++){
            sum += (int)numbers.get(i);
         }
         return sum;
      }
       
      private static int getAverage(List<Integer> numbers){
         return getSum(numbers) / numbers.size();
      }
   }

      

6. java.time 进行时间的统一处理。以前在java.util和java.sql的包中都有日期类，而且各有不同很不合理。

7. Base64编码已经成为Java类库的标准。

 

Java9 新特性：https://docs.oracle.com/javase/9/whatsnew/toc.htm#JSNEW-GUID-C23AFD78-C777-460B-8ACE-58BE5EA681F6
  模块化是java9最大变化

 

Java10 新特征
   最大的变化是 局部变量类型推断，使用var val。 类似于kotlin