java8新特性

一、Lambda表达式

函数式接口需要用注解@FunctionalInterface修饰（检查接口是不是函数式接口）

public class TestLambda {
  // 1、无参数，无返回值
  //使用函数式接口Runnable
  @Test
  public void test1() {  
    // 匿名内部类使用方式：
    Runnable r = new Runnable（）{
      @Override
       public void run() {
        System.out.println("Hello World!");
      }
    }
    // 调用
    r.run();
    // Lambda方式使用：
    Runnable r1 = () -> System.out.println("Hello World!");
    // 调用
    r1.run();
  }

  // 2、多个参数(如果只有一个参数小括号可以省略，如果方法体有多条语句必须写大括号)，无返回值
  // 一个参数使用Consumer接口
  // 两个参数使用Comparator接口
  public void test2() {
    Consumer con = (x) -> System.out.println(x);
    con.accept("Hello World!");
  }
  
  // 3、两个参数，有返回值
  public void test3() {
    Comparator com = (x,y) -> {
      System.out.println("Hello World!");
      return Integer.compare(x,y);
    }
    com.compare(3,5);
  }
}

二、Lambda表达式使用场景

1、使用场景1

// 声明一个接口
@FunctionalInterface
public interface Myfun {
  public Integer getValue(Integer num);
}


// 使用
public class LambdaTest {

  public Integer operation(Integer num,Myfun m) {
    return m.getValue(num);
  }

  public void test() {
    Integer result = operation(100,x -> x + x);
    System.out.println(result);
  }
}

2、使用场景2

// 创建一个user类
@Data
public class User {
  private Integer id;
  private String name;
  private Integer age;
  public User(Integer id,String name,Integer age) {
    this.id = id;
    this.name = name;
    this.age = age;
  }
}

// 给users排序，先按年龄排序，年龄相同按姓名排序
public class TestLambda {
  List users = Arrays.asList(
    new User(101,"张三",18),
    new User(102,"李四",59),
    new User(103,"王五",28),
    new User(104,"赵六",8),
    new User(105,"田七",38)
  );
  @Test
  public void test() {
    Collections.sort(users,(item1,item2) -> {
      if(item1.getAge() == item2.getAge()) {
        return item1.getName().compareTo(item2.getName());
      }else {
        return -Integer.compare(item1.getAge(),item2.getAge()); // 加个“-”号表示倒序排序
      }
      // 测试
      for (User user:users) {
        System.out.println(user);
      }
    }
  }
}

3、使用场景3

// 声明一个函数式接口
@FunctionalInterface
public interface MyFun {
  public R getValue(T t1,T t2);
}

// 使用
public class LambdaTest {
  public void operator(Integer x,Integer y,MyFun m) {
    System.out.println(m.getValue(x,y));
  }
  @Test
  public void test() {
    operator(3,2,(x,y) -> x + y); // 计算x+y等于5
    operator(3,2,(x,y) -> x * y); // 计算x*y等于6
    operator(3,2,(x,y) -> x - y); // 计算x-y等于1
  }
}

三、可以使用的内置函数式接口

1、Consumer 消费型接口
void accept(T t)
2、Supplier 供给型接口
T get()
3、Function 函数型接口
R apply(T t))
4、Predicate 断言型接口
boolean test(T t)
5、BiFunction
R apply(T t,U u)
6、UnaryOperator
T apply(T t)
7、BinaryOperatoy
T apply(T t1,T ,t2)
8、BiConsumer
void accept(T t,U u)
9、ToIntFunction、ToLongFunction、ToDoubleFunction
分别计算int、long、double值的函数式接口
链接教程请点击

四、java8 使用方法

（1）获取指定元素的下标

List list = new ArrayList<>();
    //添加测试数据
    list.add("test1");list.add("test2");list.add("test3");
    list.add("test4");list.add("test5");list.add("test6");
    list.add("test7");list.add("test8");list.add("test9");

    AtomicInteger index = new AtomicInteger(0);

    list.stream()
        //指定匹配逻辑
        .filter(s -> {
            //每比对一个元素，数值加1
            index.getAndIncrement();

            return s.equals("test2");
        })
        .findFirst();

    System.out.println(index.get());