java8新特性

java8新特性

为什么要学Java8
简介
速度更快（底层的数据结构做了一些更新和改动，垃圾回收机制内存结构做了一些改动）
代码更少（增加了新的语法Lambda表达式）
强大的StreamAPI
便于并行
最大化减少空指针异常（Optional容器类）

主要内容
1、Lambda表达式 ***
2、函数式接口 **
3、方法引用与构造器引用 *

Lambda表达式

什么是Lambda表达式？

Lambda表达式是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使得Java语
言表达能力得到了提升。 Java8中引入了一个新的操作符” -> ”该操作符称为箭头操作符或Lambda操作符，箭头操作符将

Lambda表达式拆分为两部分：
左侧：Lambda表达式的参数列表。对应接口中抽象方法的参数列表。
右侧：Lambda表达式中所需要执行的功能，即Lambda体。对应接口中抽象方法的实现。

Lambda表达式的基础语法

无参数，无返回值

要求存在一个接口，接口中存在一个方法，方法无参无返回值即可

（） -> 方法的实现

举例

@Test 
public void test1() { 
int num = 0; 

Runnable r = new Runnable() { 
@Override
public void run() { 
System.out.println("Hello World" + num); 
} 
};
r.run();
 System.out.println("----------------------------"); 
 Runnable r2 = () -> System.out.println("Hello Lambda!"); r2.run(); 
 }

有一个参数，无返回值

要求存在一个接口，接口中存在一个方法，方法带一个参数无返回值即可。
一个参数时小括号可以省略

public void test2() {
Consumer con = (t) -> System.out.println(t); con.accept(“Hello Lambda!”);
con = t->System.out.println(t);
}

有参数有返回值

要求存在一个接口，接口中存在一个方法，方法带参数带返回值即可。

public void test4() {
Comparator<Integer> com = (x, y) -> { 
System.out.println("Hello Lambda!"); 
return Integer.compare(x, y); 
}; 
}

若Lambda体中只有一条语句，return和大括号都可以省略不写

public void test5() { 
Comparator<Integer> com = (x, y) -> Integer.compare(x, y); 
}

说明

Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出数据类型，即“类型推断

public void test6() { 
Comparator<Integer> com = (Integer x, Integer y) -> Integer.compare(x, y); 
show(new HashMap<>());// jdk1.8以后 
}

public void show(Map<String, Integer> map) { 

}

函数式接口

什么是函数式接口？
接口中只有一个抽象方法的接口，称为函数式接口。default修饰方法只能在接口中使用(只能被实现了这个接口的对象调用)，在接口种被default标记的方法为普通方法，可以直接写方法体。
可以使用注解@FunctionalInterface修饰，可以检查是否是函数式接口。
Lambda表达式需要函数式接口的支持

使用函数式接口

@FunctionalInterface
 public interface MyFunction<T> { public T getValue(T o); 
 }

// 需求：对一个数进行运算 
@Test 
public void test7() { 
Integer result = operation(100, (x) -> x * x); System.out.println(result); 
result = operation(200, (y) -> y - 100); System.out.println(result); 

}
public Integer operation(Integer num, MyFunction<Integer> mf) { return mf.getValue(num);

 }

四大内置核心函数式接口

消费型、供给型、函数型、断定型

消费型接口 Comsumer
void accept(T t)
供给型接口 Supplier
T get()
函数型接口 Function<T,R>
R apply(T t)
断定型接口 Predicate
boolean test(T t)
~~ —————————————————————————-~~
消费性：只进不出
供给型：白手起家，空手套白狼
函数型：礼尚往来
断定行：鉴定评审

Consumer 消费型接口

public void test1() {
 happy(10000, (m) -> System.out.println("澳门赌场一日游下去" + m + "元")); 
 }
 public void happy(double money, Consumer<Double> con) { con.accept(money);
  }

Supplier 供给型接口

/* 
* Supplier<T> 供给型接口 
* * T get(); 
*/ 
// 需求：产生指定个数的整数，并放入集合中 
@Test 
public void test2() { 
List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
 for (Integer integer : numList) { 
  System.out.println(integer); 
} 
}
public 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; 
}

Function<T, R> 函数型接口

/* 
 Function<T, R> 函数型接口 
  R apply(T t); 
 */  
 // 需求：用于处理字符串 
@Test 
 public void test3() { 
 String newStr = strHandler(" shsxt ", (str) -> str.trim()); System.out.println(newStr); 
newStr = strHandler("shsxt", (str) -> str.substring(2, 5)); System.out.println(newStr); 
}
public String strHandler(String str, Function<String, String> fun) { 
return fun.apply(str);

}

Predicate 断言型接口

/*
 * Predicate<T> 断言型接口
 *  * boolean test(T t); 
 * */ 
 // 需求：将满足条件的字符串，放入集合中 
 public void test(){ 
 Predicate<Integer> pre = (i) -> i>1; System.out.println(pre.test(5)); 
 }
 public void test4() { 
 List<String> list = Arrays.asList("hello", "bjsxt", "Lambda", "www", "ok"); 
 List<String> strList = filterStr(list, (s) -> s.length() > 3); for (String string : strList) { 
  System.out.println(string); 
 } 
 }
 public List<String> filterStr(List<String> list, Predicate<String> pre) {
  List<String> strList = new ArrayList<>(); 
  for (String string : list) { 
   if(pre.test(string)) { 
  strList.add(string); 
  } 
  }
   return strList;
   }

方法引用

对象::实例方法名

// 对象::实例方法名
 @Test 
 public void test1() {
  Consumer<String> con = (x) -> System.out.println(x); PrintStream ps = System.out;
Consumer<String> con1 = ps::println;
Consumer<String> con2 = System.out::println; con2.accept("shsxt"); 
}
@Test 
public void test2() { 
Employee emp = new Employee(); emp.setName("张三"); emp.setAge(18); Supplier<String> sup = () -> emp.getName(); StriSystem.out.println(str); 
Supplier<Integer> sup2 = emp::getAge; int age = sup2.get(); System.out.println(age); 
}

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

注意：
1、Lambda体中调用方法的参数列表和返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致。
2、若Lambda参数列表中的第一个参数是实例方法的调用者，第二个参数是实例方法的参数时，可以使用ClassName::method。

构造器引用

// 构造器引用
@Test 
public void test5() { 
Supplier<Employee> sup = () -> new Employee(); 
Employee emp = sup.get(); 
// 构造器引用方式
 Supplier<Employee> sup1 = Employee::new; 
 Employee emp1 = sup.get(); 
 System.out.println(emp1); 
 }
 @Test
 public void test6() { 
  Function<Integer, Employee> func = (x) -> new Employee(x); func.apply(20);
  // 需要调用的构造器的参数列表要与函数式接口中抽象方法参数列表保持一致  Function<Integer, Employee> func2 = Employee::new; 
 Employee emp1 = func2.apply(18); 
 System.out.println(emp1); 
 BiFunction<Integer, String, Employee> bf = Employee::new; Employee emp2 = bf.apply(20, "张三");
  System.out.println(emp2); 
  }

注意：需要调用的构造器的参数列表要与函数式接口中抽象方法参数列表保持一致。

常用类

字符串相关类
1.String
不可变的字符序列
2.StringBuffer
可变字符序列，并且线程安全，但是效率低
3.StringBuilder
可变字符序列，线程 不安全，但是效率高 （一般用他！）
String
由于使用特别多，所以有特殊快捷的创建方式通过双引号 “” 直接创建对象
构造方法

常用方法

StringBuffer和StringBuilder
这两个类使用方式类似。一般用于做字符串拼接，删除，替换，反转，截取，插入等。
通过查看源码，认识StringBuffer和StringBuilder的构造方式，以及与String的转换方式

包装类

对于包装类说，这些类的用途主要包含两种：
a、作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。
b、包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法（这些操作方法的作
用是在基本类型数据、包装类对象、字符串之间提供转化！）。
包装类和基本类型之间存在自动装箱和自动拆箱操作，所以可以互相方便地切换。