Java学习笔记整理: 关于Java8增加的特性 2024/7/6；

lambda表达式：

方法引用分类	类名::方法
类名::staticMethod	(args)->类名.staticMethod(args)	静态方法
inst::instMethod	(args)->inst.instMethod(args)	实例方法
类名::instMethod	(inst,args)->inst.instMethod(args)	对象方法
类名::new	(args)->new 类名(args)	构建方法

lambda常用接口	接口名<参数类型,可多个参数>
Consunmer:	带参无返回值;
.accept(s);	传入参数
Supplier:	无参有返回值;
.get();	获取返回值
Function:	带参带返回值
.apply(s)	传入参数并获取返回值
BiFunction:	带双参带返回值
Preadicated:	带参带boolean类型返回值
.test(s)	传入参数并获取boolean返回值
Comparator:	带双参并返回boolean类型

lambda表达式可以将方法当作参数进行传递;

只有接口的传参位置才可以使用箭头函数简化;

如果方法只有一行可省略{};

如果接口传参只有一个可省略();

如果lambda表达式调用其他方法可使用::

其可以根据当前接口的有参无参自动注入方法中;

//例如:
public static void test(Consumer<String> consumer,String s)
​
//调用静态test方法时,参数consumer的位置可以使用()->{}(箭头函数)代替
//s为传入参数,而箭头后为该函数执行的方法;
test(s -> System.out.println(s+"ooo"),"hahaha");
//如果方法不只有一行使用{};
test(s->{
s="hhh";
System.out.println(s+"ooo")
},"hahaha")
//如果参数不只有一行使用();
test((s,a)->{
s="hhh";
a="aaa"
System.out.println(s+a+"ooo")
},"hahaha")
//使用方法所在的类名调用该类下的方法; 
Consumer<String> consumer = Test0Consumer::add;
test(consumer,"hahaha");
    //也可以写成
    test(Test0Consumer::add,"hahaha");

Consunmer<T>：

消费型接口:带参无返回值;

public class Test0 {
public static void main(String[] args) {
//--------方法一----------------------------------
  //lambda表达式
  Consumer<String> consumer = (s)->{
      System.out.println(s);
  };
  //调用静态test方法
  test(consumer,"hahaha");
//--------方法二----------------------------------
  //调用静态test方法并传入lambda表达式
  test(s -> System.out.println(s+"ooo"),"hahaha");
//--------结束-----------------------------------
}
//创建静态带参test方法
public static void test(Consumer<String> consumer,String s){
  //赋值lambda参数值;
  consumer.accept(s);
}
}

Supplier:

供给型接口:无参有返回值;

public class TestSupplier {
 public static void main(String[] args) {
//--------方法一----------------------------------
     //lambda表达式
     Supplier supplier = ()->{
         return "hello";
     };
     //调用静态test方法
     test(supplier);
//--------方法二----------------------------------
     //调用静态test方法并传入lambda表达式
     test(()->"hello");
//--------结束-----------------------------------
 }
 //创建静态带参test方法
 public static void test(Supplier<String> supplier){
     //获取并输出返回值;
     System.out.println(supplier.get());
 }
}

Function:

函数型接口:有参有返回值

public class TestFunction {
public static void main(String[] args) {
//--------方法一----------------------------------
  //lambda表达式
   Function<String,String> function = s->{
      return s.toUpperCase();
  };
  //调用静态test方法
  test(function,"hello");
//--------方法二----------------------------------
  //调用静态test方法并传入lambda表达式
  test(s->s.toUpperCase(),"hello");
//--------结束-----------------------------------  
}
//创建静态带参test方法
public static void test(Function<String,String> function, String s){
  //获取并输出返回值
  System.out.println(function.apply(s));
}
}

Preadicated:

断言型接口:带参并且返回值为boolean;

public class TestPredicate {
 public static void main(String[] args) {
//--------方法一----------------------------------
  //lambda表达式
  Predicate<String> predicate = t->t.length()>3;
  //调用静态test方法
  test(predicate,"hhhh");
//--------方法二----------------------------------
  //调用静态test方法并传入lambda表达式
  test(t->t.length()>3,"hhhh");
//--------结束-----------------------------------  
 }
 //创建静态带参test方法
 public static void test(Predicate<String> predicate, String s){
     //获取并输出返回值
     System.out.println(predicate.test(s));
 }
}

Stream流:

获取stream串行流的方法;	串行筛选数据
Stream<list类型> s = list.stream();	通过list调用stream()获取流
Stream<传入类型> s = Stream.of("a","b",...)	通过Arrays数组工具类获取stream对象
IntStream s = Arrays.stream(数组名);	使用steam类中of方法获取stream流
LongStream range = LongStream.rangeClosed(0,10);	获取1~10范围内的数的stream流

获取stream并行流的方法;	并行筛选数据,适用数据量大的
Stream<list类型> s = list.parallelStream();	通过list调用stream()获取并行流流
stream流方法:	--------------------------
Stream<类型> s = Stream.concat(s1,s2)	合并s1,s2两个stream流

stream过程操作:	------------------------------------------
.map(Function接口)	(映射器)遍历流中元素进行操作并返值每个对象
.flatMap()	StreamDemo::fromStringToStream(遍历流中流的值)
.sorted(Comparator接口)	(比较器)遍历流排序通过正负,正前参置前,负后参置前最终返回每个值
.sorted()	Comparator.naturalOrder()自然顺序排序(可比较英文)
.filter(Predicte接口)	(筛选器)遍历流筛选符合条件的值保留;
.collect()	(收集器)收集方法
.distinct()	(去重器)使用hashcode和equals方法对比去重
.limit(5)	(截取器)截取指定个数
.skip(5)	(跳过器)跳过指定个数
.iterate	(迭代器)使用Stream.iterate创建流值，即所谓的无限流。
.peek(Consumer接口)	(查看器)使在流中可查看当前值,有可能改变某些值

stream终止操作:	====================================
.forEach	遍历流处理列表
.forEachOrdered	遍历特殊状态
.count()	(计数器)计数并返回个数
.max(Comparator接口)	(比较器)遍历并通过正负,正保留前参,负保留后参最终返回一个值
.min(Comparator接口)	(比较器)遍历并通过正负,负保留前参,正保留后参最终返回一个值
.reduce(BiFunction接口)	(融合器)遍历通过计算得出返回值将值赋予前参,并重复最终返回一个值 (参数类型与返回类型需要统一)(名称:规约)
.collect(Collectors.toList())	(打包器)搜集(方法),将处理后的值打包为列表返回;
.findFirst()	获取第一个值(返回Optional类型)
.findAny	获取一个值,串行流为首个,并行流不固定(返回Optional类型)
.allMatch(Predicate接口)	(判断器)遍历判断，返回boolean值.全部通过为true,否则为false
.anyMatch(Predicate接口)	(判断器)遍历判断，返回boolean值.任一通过为true,否则为false
.noneMatch(Predicate接口)	(判断器)遍历判断，返回boolean值.无通过为true,有则为false

stream流:

性能更快，支持多线程处理;比传统处理性能更优;

原理:

stream流思想类似于工厂车间流水线,不是一种数据结构,不保存数据,而是对数据进行加工处理。通过多个工序让一个原材料加工成一个商品;

stream流分为过程操作和终止操作，终止操作只能有一个;

public class TestStream {
 public static void main(String[] args) {
     //创建列表;
     ArrayList<String> list = new ArrayList<>();
     //添加数据;
     Collections.addAll(list,"张三","李四","王五","赵六","孙七");
     //将列表转换为stream流;
     list.stream()
     //过程操作---
         //使用stream流的方法查找"张"开头,结合lambda表达式;
             .filter(s -> s.startsWith("张"))
    //终止操作---
         //循环并输出;
             .forEach(System.out::println);
 }
}

                ----------其中多为自我理解进行总结,可能会有错误,仅供参考---------