/**
* java8中的函数式接口，java中规定：函数式接口必须只有一个抽象方法，可以有多个非抽象方法，同时，如果继承实现了
* Object中的方法，那么也是合法的
* <p>
* 函数式接口可以使用lambda来创建
*/
@FunctionalInterface
interface MyService {
void sayMessage(String msg);
@Override
boolean equals(Object obj);
}
/**
* 入口
* @param args
*/
public static void main(String[] args) {
printSeperator();
testMehtodRef();
printSeperator();
testSupplierConsumer();
printSeperator();
testOptional();
printSeperator();
testStream();
printSeperator();
}
/**
* 测试Optional类
*/
private static void testOptional() {
Optional<String> optional1 = Optional.ofNullable(null);
//如果optional确实存在值，那么该函数返回值为true
if (optional1.isPresent()) {
System.out.println("optional1 present!");
}
//如果optional没有值，那么默认返回传入的other
String res = optional1.orElse("default");
System.out.println("res's value after orElse:" + res);
try {
/**
* 如果没有该值，那么抛出{@link NoSuchElementException}
*/
res = optional1.orElseThrow();
System.out.println("res's value after orElseThrow:" + res);
} catch (NoSuchElementException e) {
System.out.println("orElseThrow occured!");
}
optional1 = Optional.ofNullable("i have a value");
res = optional1.orElse("default");
System.out.println("res's value after orElse:" + res);
}
/**
* 测试{@link java.util.function.Supplier} and {@link java.util.function.Consumer}
*/
private static void testSupplierConsumer() {
Supplier<String> supplier1 = new Supplier<String>() {
@Override
public String get() {
return new String("hello world from supplier1");
}
};
//lambda式的supplier，supplier的规定是无参数，且返回一个对象，因此满足该条件
Supplier<String> supplier2 = () -> new String("hello world from supplier2");
//本质上supplier是一个容器，对一个方法的封装
var str1 = getSupplier(supplier1);
var str2 = getSupplier(supplier2);
//方法引用默认返回一个supplier，因为该new不接受任何参数，返回一个对象，因此满足条件
var str3 = getSupplier(String::new);
System.out.println("str1: " + str1 + " str2:" + str2 + " str3:" + str3);
/////////////////////////////////////////////////////////////////////////////////////////////
Consumer<String> consumer1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.print(s + "|");
}
};
//lambda式的Consumer，Consumer的约定是接受一个参数，返回值为void，因此满足条件
Consumer<String> consumer2 = (s) -> System.out.print(s + "^");
var list = getStrList();
list.forEach(consumer1);
System.out.println();
list.forEach(consumer2);
System.out.println();
/////////////////////////////////////////////////////////////////////////////////////////////
//Predicate谓词接口，用于判断是否符合某个条件，约定是：接受一个参数，返回值为boolean
Predicate<Integer> predicate1 = new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
return integer > 2;
}
};
//lambda式的谓词接口
Predicate<Integer> predicate2 = (num) -> num > 2;
var numList = getIntList();
var res = numList.stream().filter(predicate1).collect(Collectors.toList());
System.out.println(res);
res = numList.stream().filter(predicate2).collect(Collectors.toList());
System.out.println(res);
/////////////////////////////////////////////////////////////////////////////////////////////
//Function接口：这是一个功能性的接口，主要用于把一种类型的数据处理完成后，可能得到的结果是另外一种类型
//本质上是上面那些接口的超集，第一个参数为接口的类型，第二个参数为转换后的类型
Function<String, Character> func1 = new Function<String, Character>() {
@Override
public Character apply(String s) {
if (s.length() <= 2) {
return 'a';
}
return s.charAt(2);
}
};
Function<String, Character> func2 = (s) -> {
return s.length() <= 2 ? 'a' : s.charAt(2);
};
var varList = getStrList();
var res2 = varList.stream().map(func1).collect(Collectors.toList());
System.out.println(res2);
res2 = varList.stream().map(func2).collect(Collectors.toList());
System.out.println(res2);
}
/**
* 测试{@link java.util.stream.Stream}里面的函数接口，
* Stream里面的函数接口非常的多，类似于SQL，分为两种：
* 1 中间函数 immediate function
* 2 最终函数（规约） terminal function
*/
private static void testStream() {
//将一个数字list，先过滤到大于3的数，然后转换为对应的字母，最后在大写，最后重新收集为一个List
List<Integer> numList = getIntList();
List<String> res = numList.stream().filter((num) -> num > 3).map(num -> String.valueOf((char)('a' + num)))
.map(str -> String.valueOf((char)('A' + str.charAt(0) - 'a'))).collect(Collectors.toList());
System.out.println(res);
final int size = 100;
int[] arr = new int[size];
Random random = new Random();
for(int i = 0;i < size;++i){
arr[i] = random.nextInt(1000);
}
//对numArr进行排序，然后得到最前面的5个数据，最后得到最大值
var res2 = Arrays.stream(arr).sorted().limit(5).min();
System.out.println("res2:"+ res2.orElseThrow());
}
/**
* 辅助类
*
* @param supplier
* @param <T>
* @return
*/
private static <T> T getSupplier(Supplier<T> supplier) {
return supplier.get();
}
/**
* 测试方法引用的用法
*/
private static void testMehtodRef() {
List<String> strs = new ArrayList<>();
strs.add("one");
strs.add("two");
strs.add("three");
strs.add("four");
//printSomething本质上是一个Consumer
strs.forEach(HelloJava8::printSomething);
System.out.println();
}
/**
* 打印一些东西
*
* @param s
*/
private static void printSomething(String s) {
System.out.print(s + " ");
}
private static void printSeperator() {
System.out.println(SEPERATOR);
}
/**
* 辅助方法，获辅助list
*
* @return
*/
private static List<String> getStrList() {
List<String> strs = new ArrayList<>();
strs.add("one");
strs.add("two");
strs.add("three");
strs.add("four");
return strs;
}
/**
* 获取辅助list
*
* @return
*/
private static List<Integer> getIntList() {
List<Integer> intList = new ArrayList<>();
for (int i = 1; i <= 10; ++i) {
intList.add(i);
}
return intList;
}