public interface TsInface01 {
static void staticMethod(){
System.out.println("我是 TsInface01 接口中的static方法: staticMethod");
}
default void default1(){
System.out.println("我是 TsInface01 接口中的default方法: default1");
}
}
public interface TsInface02 extends TsInface01{
static void staticMethod(){
System.out.println("我是 TsInface02 接口中的static方法: staticMethod");
}
}
public interface TsInface03 {
static void staticMethod(){
System.out.println("我是 TsInface03 接口中的static方法: staticMethod");
}
default void default1(){
System.out.println("我是 TsInface03 接口中的default方法: default1");
}
}
public class Test01 implements TsInface01, TsInface02 {
public static void main(String[] args) {
Test01 t01 = new Test01();
t01.default1();
}
@Override
public void default1(){
TsInface02.super.default1();
}
}
函数式接口,该接口中只能由一个抽象方法,可以使用@FunctionalInterface注解修饰某个接口有且仅有一个抽象方法。
@FunctionalInterface
public interface TsInface04 {
void getName(String firstName);
default void getMoney() {
System.out.println("默认方法就是这么任性");
}
static void main(String[] args) {
System.out.println("自从接口可以由静态方法,可以写main函数,作为程序的入口");
}
}
使用:参数 + 规则 + 方法体 如果使用局部变量,局部变量必须是final类型
public class Test02 implements TsInface01, TsInface02 {
public static void main(String[] args) {
Test02 t02 = new Test02();
// 参数 + 规则 + 方法体
TsInface04 ts04 = (fisrtName) -> {
return fisrtName + "bbbbbb";
};
// 只有一个参数的时候,参数中的那个括号可以省略
TsInface04 ts05 = fisrtName -> {
return fisrtName + "bbbbbb";
};
// 只有一句话的方法体,大括号 和 return 也可以省略
TsInface04 ts06 = fisrtName -> fisrtName + "bbbbbb";
System.out.println(ts04.getName("全写"));
System.out.println(ts05.getName("简写"));
System.out.println(ts06.getName("简简写"));
}
}
import java.util.HashMap;
import java.util.Map;
@FunctionalInterface
interface TsInface05 {
String getName(String firstName);
default void getMoney() {}
}
@FunctionalInterface
interface TsInface06 {
Map<String, String> getName(Map<String,String> map, String firstName);
}
@FunctionalInterface
interface TsInface07 {
void getName(Map<String,String> map, String firstName);
}
public class Test03 {
public Test03(){
}
public Test03(Map<String,String> map, String firstName){
map.put("NAME", firstName);
System.out.println(map.get("NAME"));
}
public static void main(String[] args) {
Test03 test03 = new Test03();
// 引用实例的方法
TsInface05 t501 = test03::getName1;
t501.getName("引用实例的方法");
// 引用类的方法
TsInface05 t502 = Test03::getName2;
t501.getName("引用类的方法");
// 引用类实例方法
Map<String, String> map = new HashMap<>(16);
TsInface06 t601 = Test03::getName3;
t601.getName(map, "引用类实例方法");
// 引用构造方法
TsInface07 t701 = Test03::new;
t701.getName(map, "引用构造方法");
}
// 实例方法
public String getName1(String str) {
System.out.println(str);
return str;
}
// 类方法
public static String getName2(String str) {
System.out.println(str);
return str;
}
// 类实例方法
public static Map<String, String> getName3(Map<String, String> map, String str) {
map.put("NAME", str);
System.out.println(map.get("NAME"));
return map;
}
}
// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();
流的操作类型分为三种:
在对于一个 Stream 进行多次转换操作(Intermediate 操作),每次都对 Stream 的每个元素进行转换,而且是执行多次,这样时间复杂度就是 N(转换次数)个 for 循环里把所有操作都做掉的总和吗?其实不是这样的,转换操作都是 lazy 的,多个转换操作只会在 Terminal 操作的时候融合起来,一次循环完成。我们可以这样简单的理解,Stream 里有个操作函数的集合,每次转换操作就是把转换函数放入这个集合中,在 Terminal 操作的时候循环 Stream 对应的集合,然后对每个元素执行所有的函数。
int sum = widgets.stream()
.filter(w -> w.getColor() == RED)
.mapToInt(w -> w.getWeight())
.sum();
stream() 获取当前小物件的 source,filter 和 mapToInt 为 intermediate 操作,进行数据筛选和转换,最后一个 sum() 为 terminal 操作,对符合条件的全部小物件作重量求和。
生成 10 个随机整数
Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
Stream.generate(random).limit(10).forEach(System.out::println);
//Another way
IntStream.generate(() -> (int) (System.nanoTime() % 100)).
limit(10).forEach(System.out::println);
Stream.generate() 还接受自己实现的 Supplier
Stream.generate(new PersonSupplier()).
limit(10).
forEach(p -> System.out.println(p.getName() + ", " + p.getAge()));
private class PersonSupplier implements Supplier<Person> {
private int index = 0;
private Random random = new Random();
@Override
public Person get() {
return new Person(index++, "StormTestUser" + index, random.nextInt(100));
}
}
package com.hand.sxy.java8.intface;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
public class Test04 {
public static void main(String[] args) {
LocalDate d1 = LocalDate.now();
System.out.println(d1.toString());
LocalTime d2 = LocalTime.now();
System.out.println(d2.toString());
LocalDateTime d3 = LocalDateTime.now();
System.out.println(d3.toString());
DateTimeFormatter f = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
d3 = LocalDateTime.parse("2018-09-19 11:23:22", f);
System.out.println(d3.toString());
ZonedDateTime zd = ZonedDateTime.now();
zd.format(f);
System.out.println(zd.toString());
}
}