java8新特性练习

国际惯例
public static void main(String arg[]){
  System.out.println("hello Java8");
}

1.LocalDate , LocalTime

/**
 * LocalDate,LocalTime
 * 获取当前时间用now()方法
 * 构造时间用of()或者parse()
 * 对日期进行一些操作取值是在上述方法调用完成后调用with()或相关的方法
 *
 * 与JDBC对应关系
 * SQL -> Java
 * date -> LocalDate
 * time -> LocalTime
 * timestamp -> LocalDateTime
 *
 */
//取当前日期
LocalDate today = LocalDate.now();
System.out.println("today:" + today);
//取本月第一天(取本月最后一天，取下个月第一天等等)
LocalDate firstDayOfTheMouth = today.with(TemporalAdjusters.firstDayOfMonth());
System.out.println("firstDayOfTheMouth:" + firstDayOfTheMouth);
//取19年第一个周一
LocalDate firstMondayOf2019 = LocalDate.parse("2019-01-01").with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));
System.out.println("firstMondayOf2019:" + firstMondayOf2019);
//取当前时间（包含毫秒）
LocalTime now = LocalTime.now();
System.out.println("now:" + now);
//取当前时间（不包含毫秒）
now = LocalTime.now().withNano(0);
System.out.println("now:" + now);
//构造一个时间
LocalTime made = LocalTime.parse("10:10:00");
System.out.println("made:" + made);
//取当前日期时间
LocalDateTime dateTime = LocalDateTime.now();
System.out.println("dateTime:" + dateTime);

2.Lambda表达式

java8内置的四大核心函数式接口

Consumer<T> : 消费型接口  void accept(T t);

Supplier<T> : 供给型接口 T get();

Function<T,R>: 函数型接口 R apply(T t);

Predicate<T> : 断言型接口 boolean test(T t);

/**
 * 消费型接口
 */
@Test
public void test1() {
  happy(500, m -> System.out.println("消费：" + m));
}

private void happy(double money, Consumer<Double> con) {
  con.accept(money);
}

/**
 * 供给型接口
 */
@Test
public void test2() {
  List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));
  for (Integer num : numList) {
    System.out.println(num);
  }
}

//产生指定个数的整数并放入集合中
private List<Integer> getNumList(int num, Supplier<Integer> sup) {
  List<Integer> list = new ArrayList<>();

  for (int i = 0; i < num; i++) {
    Integer n = sup.get();
    list.add(n);
  }

  return list;
}


/**
 * 函数型接口
 */
@Test
public void test3() {
  String newStr = strHandler("  dh  sja k ", str -> str.trim());
  System.out.println(newStr);
}

private String strHandler(String str, Function<String, String> fun) {
  return fun.apply(str);
}

/**
 * 断言型接口
 */
@Test
public void test4() {
  List<String> list = Arrays.asList("1222", "22", "333");
  List<String> strList = filterStr(list, s -> s.length() > 3);
  System.out.println(strList.size());
}

private List<String> filterStr(List<String> strs, Predicate<String> pre) {
  List<String> strList = new ArrayList<>();

  for (String str : strs) {
    if (pre.test(str)) {
      strList.add(str);
    }
  }
  return strList;
}

 

/**
 * 一、Lambda 表达式的基础语法：  参数列表 -> 执行的功能 
 * 二、Lambda 表达式需要函数式接口（接口中只有一个抽象方法，可以用@FunctionalInterface注解修饰，里面只能有一个抽象方法）
 * 
 * 语法格式一：无参数，无返回值
 *      () -> System.out.println("hello lambda!");
 */
Runnable r = new Runnable() {
  @Override
  public void run() {
    System.out.println("hello world!");
  }
};
r.run();
Runnable r1 = () -> System.out.println("hello lambda!");
r1.run();

/**
 *
 * 语法格式二：有一个参数，无返回值；有一个参数小括号可以不写
 */
Consumer<String> consumer = (x) -> System.out.println(x);
consumer.accept("666");

/**
 *
 * 语法格式三：有多个参数，Lambda体中有多条语句
 */

Comparator<Integer> com = (x,y) -> {
  System.out.println("---");
  return Integer.compare(x,y);
};

/**
 *
 * 语法格式四：有多个参数，Lambda体中有一条语句，return和大括号都可以省略不写
 */

Comparator<Integer> com2 = (x,y) -> Integer.compare(x,y);
/**
 *
 * 语法格式五：Lambda表达式的参数列表的数据类型可以省略不写，JVM可以通过上下文判断数据类型
 */

Comparator<Integer> com3 = (x,y) -> Integer.compare(x,y);

 lambda引用

/**
 * 一：方法引用：若Lambda体中的内容有方法已经实现了，我们可以使用“方法引用”
 * （可以理解为方法引用是Lambda表达式的另外一种表现形式）
 * <p>
 * 主要有三种语法格式：
 * <p>
 * <p>
 * 对象：：实例方法名
 * <p>
 * 类：：静态方法名
 * <p>
 * 类：：实例方法名
 * <p>
 * 注意
 * 1.Lambda体中调用方法的参数列表与返回值类型要与函数式接口中抽象方法的函数列表和返回值类型保持一致
 * 2.Lambda参数列表中的第一个参数是实例方法的调用者，而第二个是实例方法的参数，可以使用ClassName::method
 * <p>
 * <p>
 * ---------------------------
 * <p>
 * 二：构造器引用
 * <p>
 * 格式
 * ClassName::new
 * <p>
 * 三：数组引用
 * <p>
 * Type::new;
 */
public class TestMethodRef {

  /**
   * 对象：：实例方法名
   * <p>
   * public void println(String x) {
   * synchronized (this) {
   * print(x);
   * newLine();
   * }
   * }
   * <p>
   * void accept(T t);
   */

  @Test
  public void test1() {
    Consumer<String> con = System.out::println;
    con.accept("111");
  }

  @Test
  public void test2() {
    User user = new User();
    user.setName("张三");
    Supplier<String> sup = () -> user.getName();
    String str = sup.get();
    System.out.println(str);

    Supplier<String> sup2 = user::getName;
    String str2 = sup2.get();
    System.out.println(str2);
  }

  /**
   * 类：：静态方法名
   */
  @Test
  public void test3() {
    Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

    Comparator<Integer> com1 = Integer::compare;
    com1.compare(22, 1);
  }

  /**
   * 类：：实例方法名
   */
  @Test
  public void test4() {
    BiPredicate<String, String> bp = (x, y) -> x.equals(y);

    BiPredicate<String, String> bp2 = String::equals;
    System.out.println(bp2.test("12", "1"));
  }

  /**
   * * ClassName::new
   */
  @Test
  public void test5() {
    Supplier<User> sup = () -> new User();

    Supplier<User> sup2 = User::new;

  }

  @Test
  public void test6() {
    Function<String, User> fun = x -> new User(x);

    Function<String, User> fun2 = User::new;
    User user = fun2.apply("李四");
    System.out.println(user.getName());


  }

  @Test
  public void test7() {
    Function<Integer, String[]> fun = (x) -> new String[x];
    String[] strs = fun.apply(10);
    System.out.println(strs.length);

    Function<Integer, String[]> fun2 = String[]::new;
    String[] strs2 = fun2.apply(20);
    System.out.println(strs2.length);
  }
}

 

流（作用：计算）

未完待续。。。