JAVA的新特性

JDK1.8的新特性
匿名类
接口新特性
Lambda(λ)表达式;
数据流:深入到JDK源码中写代码;Spark增强版的数据流
时间的新特性
1.匿名类
多线程:Runnable接口
1 先写一个类,实现runnable接口,重写run方法
2 在main方法中new Thread(runnable).start();
标准:
1 得有接口,接口里面的方法比较少;
2 大括号就是类体,木有类的名字,所以叫做匿名类
** 用在哪里面:**
1 确定类体只能使用一次代码;run方法不能重复使用
2 好处:省去了一个MyRunnable的类

2.接口
属性:public static final ;写不写都一样;接口.属性就可以使用;
方法:全部是抽象的:public abstract void
需求:标准
所有实现类的方法都是一样的(得new对象;在方法上面加上default
接口里面的方法也可是静态的;(得类名.方法名);
3.lambda表达式
语法超级简单:—python,scala;
相当于匿名函数(方法);方法的参数居然可是一个方法;js的类型就有Function;特殊像匿名类
写法
(参数,参数2,参数3…) ->
{
方法体;
}

所有的参数类型可以省略,会推算出变量的类型
如果参数只有一个,小括号可以省略
如果方法体只有一行,大括号可以省略;
E(变量名) -> 方法体只有一行

哪些地方可以写Lambda表达式
必须接口中有只有一个抽象的方法
某个方法的参数是此接口;
参数列表和方法体,返回值如何对应(参照的是接口中抽象方法)
接口的注解:@override,@Test;如果接口的注解是@FunctionalInterface,优先级最高,肯定可以写lambda表达式;

4 方法引用

OverrideImp::new = new OverrideImp()

: 表示调用方法;左边是类名或者对象;右边是方法名;木有参数
只能调用无参的

5.数据流
Stream:
1 返回值是最终的结果;所有的操作马上执行;action
2 返回值还是流(他自己),链式编程;所有的操作都不会执行;(懒执行);transformation
主要方法:
1 Parallel:平行;单线程,调用此方法会变成多线程;利用CPU硬件的核数全部计算
2 Filter:不是最终的;(transformation);算子(方法);过滤数据使用的
3 Map:transformation算子,从一个值变成另外一个值;
4 flatMap:transformation算子,
5 Distinct:transformation去掉;
6 Sorted:排序;transformation
7 Limit:transformation取前几条记录;每页多少条
8 Skip:transformation跳过;从第几条开始,跳过前面的第N条;
9 forEach:action;循环
10 toArray:action;数组
11 Reduce:减少;(合并);action
12 Collect:action;把每一个线程算完的结果汇总一下
13 min和max(action)
14 Count:action;总条数
15 findFirst,findAny;
16 Of:把一个参数放到数据流里面
方法的测试代码

package com.carlinfo.news.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.junit.Test;

/**

• 流式的操作

• 流式操作和Spark的关系特别像:

• javase中的容器;http://commons.apache.org/proper/commons-collections/

• @author WangshMac
  */
  public class StreamMain
  {
  private List alList = Arrays.asList(“test”, “text”, “b”,“b”, “c”, “d”);

  /**

  • filter

  • 检查一个,公布一个结果;并不是将所有的全部检查完以后,再公布结果

  • action类算子,一旦执行,stream自己关闭

  • 如果你觉得效率特别低

  • paralel:一定要写到最前面;
    /
    @Test
    public void filter()
    {
    / 流:Stream /
    Stream stream = alList.stream() ;
    /----Java原生的编程----/
    / transformation算子:

    • 懒执行:
    • transformation要想执行,后面紧跟一个action算子;链式编程
    • /
      stream = stream.parallel().filter(new Predicate()
      {
      @Override
      public boolean test(String t)
      {
      System.out.println(t + “Predicate”);
      return true;
      }
      });
      / 循环:匿名类
    • Action类算子
    • 方法是一个接口
    • /
      stream.forEach(new Consumer()
      {
      @Override
      public void accept(String t)
      {
      System.out.println(t + “java接口”);
      }
      });
      / 关闭 */
      stream.close();

    /*----Lambda的编程----

    • ~先看方法的参数是哪个接口
    • ~再看接口中的抽象方法(只有一个)
    • ~对着接口中抽象的方法:只关心,形参和返回值
    • 链式编程
    • */
      stream = alList.stream() ;
      stream.filter( e ->
      {
      System.out.println("=lambda=检查==" + e);
      /*return true ; */
      boolean flag = e.indexOf(“te”) != -1 ;
      return flag ;
      }).forEach((String c) ->
      {
      System.out.println(“lambda=循环” + c);
      });
      }

  /**

  • map的相关方法
    /
    @Test
    public void map()
    {
    / 获取一个流 /
    Stream stream = this.alList.stream() ;
    /----java版本----/
    /

    • T:输入参数
    • $:输出结果
    • /
      Stream streamInt = stream.map(new Function<String, Integer>()
      {
      @Override
      public Integer apply(String t)
      {
      System.out.println(t + “map=”);
      / 写死了 /
      return 1;
      }
      }).distinct();
      / 去重 */

    /* 循环 */
    streamInt.forEach(new Consumer()
    {
    @Override
    public void accept(Integer t)
    {
    System.out.println(t + “foreach=”);
    }
    });

    //System.out.println(streamInt.count() + “=count”);
    /----lambda表达式–入-----/
    /**

    • lambda大部分情况下会自动判断类型,有些判断不了;
      /
      stream = alList.stream() ;
      / map操作 /
      streamInt = stream.map( e ->
      {
      System.out.println(e + “maplambda=”);
      return 1 ;
      }).distinct();
      /streamInt.forEach(e ->
      {
      System.out.println(e + “foreach=lambda”);
      });/
      / 计算总条数 */
      System.out.println(streamInt.count() + “=count”);
      }

  /**

  • 压平;平板

  • 和map特别像
    /
    @Test
    public void flatMap()
    {
    Stream stream = this.alList.stream() ;
    / flatmap

    • 返回值再也不是Stream了,而是Stream
    • /
      List resultList = stream.flatMap(new Function<String, Stream>()
      {
      @Override
      public Stream apply(String t)
      {
      System.out.println(“flatmap java” + t);
      / map的返回值是Integer,
      * flatMap的返回值是Stream /
      return Stream.of(t);
      }
      }).distinct().collect(Collectors.toList());
      / :distinct:去重
    • collect:收集;参数的类型,看API文档 */
      System.out.println(“结果>” + resultList);

    /* lambda表达式, */
    }

  /**

  • 其它的方法
    /
    @Test
    public void others()
    {
    Stream stream = this.alList.stream() ;
    / action算子 /
    //stream
    / 排序
    • 默认升序,
    • 可以指定比较器,倒序 /
      //.sorted((e1,e2) -> -e1.compareTo(e2))
      / 跳过 /
      //.skip(3)
      / 每页多少条 */
      //.limit(2)
      //.forEach(e -> System.out.println("====" + e));
      /* 取第一个 /
      Optional optional = stream
      / 取第一个 /
      //.findFirst();
      / 取任何一个 /
      //.findAny();
      / 取最小的 */
      .min((e1,e2) -> e1.compareTo(e2));
      System.out.println("–findFirst-----" + optional.get()) ;
      }
      }