Java--Lambda Stream

沉默的程序.

已于 2023-08-09 10:52:41 修改

阅读量55

点赞数

文章标签： java 开发语言

于 2023-08-03 20:50:58 首次发布

本文链接：https://blog.csdn.net/wowxoxnmf/article/details/132083373

版权

1. 函数式接口

java.util.function下的函数式接口
四大内置函数式接口 :

消费型接口	Consumer<T> void accept(T t)
函数式接口	Function<T,R> R apply(T t)
段言型接口	Predicate<T> boolean test(T t)
供给型接口	Supplier<T> T get()

2. 方法引用

简单理解：用来简化Lambda表达式，也是Lambda表达式的另一种表现形式

把存在的方法拿过来用，作为函数式接口中抽象方法的方法体

使用条件：
1.引用处需要是函数式接口
2.被引用的方法需要已经存在
3.被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
4.被引用方法的功能需要满足当前的要求

简化要求：

1. 当lambda体{}中的实现就是通过调用另外一个方法实现的,可以考虑是否可以通过方法引用简化

2. a)当lambda参数列表,返回值与内部引用方法的参数列表与返回值保持一致的时候 ---->

对象::成员方法 | 类名::静态方法
b)内部所引用方法的返回值与lambda表达式的返回值一致,lambda参数列表的第一个参数

作为调用内部方法的对象,lambda参数列表的第二个参数开始匹配内部引用方法参数列表

----> 类名::成员方法

方法引用语法 ::

引用成员方法：

对象::成员方法

格式
其他类：其他类对象::方法名
本类：this::方法名(引用处不能是静态方法)
父类：super::方法名(引用处不能是静态方法)

引用静态方法：

类名::静态方法

引用构造方法：

类名 : : new

数据类型[] : : new

类名引用成员方法

类名::成员方法

抽象方法形参的详解：
第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法
在Stream流当中，第一个参数一般都表示流里面的每一个数据。
假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String这个类中的方法

第二个参数到最后一个参数：跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法

局限性：
不能引用所有类中的成员方法。
是跟抽象方法的第一个参数有关，这个参数是什么类型的，那么就只能引用这个类中的方法。

3. Stream流

关注数据的运算，将由数据源产生的元素序列进行流式运算

3.1 使用步骤 :

1.获取创建Stream流
2.一些列流式中间操作
3.终止行为

3.2 特点 :

1.Stream本身不存储数据
2.Stream的运算不影响数据源
3.所有中间操作都返回持有结果的新的流
4.流是一次性的流,一旦已经使用就被破坏,无法重复使用多次
5.延迟执行|惰性加载 : 当获取终止行为的时候所有的中间操作才会执行

3.3 获取Stream的方式 :

1.Collection-->stream()
2.Arrays.stream()
3.Stream.of(...)

细节：方法形参为一个可变参数（底层是数组）可以传递零散数据，也可传递数组，但是数组必须为引用数据类型，若传递基本数据类型，会将整个数组当作一个元素放入Stream中

3.4 Stream中间操作

1.过滤 <T> filter(Predicate<? super T> predicate) 返回由与给定谓词匹配的此流的元素组成的流。
2.截取 Stream<T> limit(long maxSize) 返回由该流的元素组成的流，长度被截断为不超过maxSize 。
3.跳过 Stream<T> skip(long n) 在丢弃流的前n元素后，返回由该流的剩余元素组成的流。
4.去重 Stream<T> distinct() 返回由该流的不同元素（根据Object.equals(Object) ）组成的流。
根据equals与hashCode方法,需要根据内容重写

5.排序
Stream<T> sorted() 返回由该流的元素组成的流，按自然顺序排序。
Stream<T> sorted(Comparator<? super T> comparator) 返回由该流的元素组成的流，根据提供的Comparator排序。

4. Stream中间操作

映射：将流操作的每一个元素映射成为另外一种结果 | 提取信息

map：将参数函数应用与此流的所有元素 ,映射成为不同的结果,最后返回持有所有结果的新的流

flatMap：返回一个流，其中包含将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容的结果。

map与 flatMap :
1.映射结果类型的要求不同
map : 映射结果没有类型要求,可以为任意类型,包括私有
flatMap : 映射的结果必须为一个流,不能为其他类型
2.映射结果返回流的结构不同
map : 返回持有所有映射结果的新的流 ,如果映射结果为一个流,最终返回的Stream<Stream>
flatMap :在返回之前先对所有映射结果流进行连接,连接成为一个流返回

统计 :
long count() 返回此流中元素的计数。
Optional<T> max(Comparator<? super T> comparator) 根据提供的Comparator返回此流的最大元素。
Optional<T> min(Comparator<? super T> comparator) 根据提供的Comparator返回此流的最小元素。

规约
Optional<T> reduce(BinaryOperator<T> accumulator) 使用associative累积函数对此流的元素执行reduction ，并返回Optional描述减少的值（如果有）。
T reduce(T identity, BinaryOperator<T> accumulator) 使用提供的标识值和associative累积函数对此流的元素执行reduction ，并返回减少的值。

终止行为 :
收集
collect ，收集，可以说是内容最繁多、功能最丰富的部分了。
从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。
collect 主要依赖 java.util.stream.Collectors 类内置的静态方法。

注意 :
map-->reduce 先提取后运算

public class Class006_Stream {
    static List<Employee> emps = Arrays.asList(
            new Employee(103,"迪丽热巴",30,9888),
            new Employee(101,"古力娜扎",28,7777),
            new Employee(102,"易烊千玺",23,9999),
            new Employee(105,"哈妮克孜",25,6666),
            new Employee(105,"哈妮克孜",25,6666),
            new Employee(104,"欧娜娜娜",28,7777)
    );
    public static void main(String[] args) {
        //static <T> Collector<T,?,List<T>> toList()
        //返回一个Collector ，它将输入元素累积到一个新的List中。
        List<Double> list = emps.stream()
                .distinct()
                .map(Employee::getSal)
                .collect(Collectors.toList());
        System.out.println(list);
        //static <T> Collector<T,?,Set<T>> toSet()
        //返回一个Collector ，它将输入元素累积到一个新的Set中。
        System.out.println(
                emps.stream()
                        .distinct()
                        .map(Employee::getAge)
                        .collect(Collectors.toSet())
        );
        //static <T, K, U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
        //返回一个Collector ，它将元素累积到Map中，其键和值是将提供的映射函数应用于输入元素的结果。
        System.out.println(
                emps.stream()
                        .distinct()
                        .collect(Collectors.toMap(Employee::getId,Employee::getName))
        );

        //static <T> Collector<T,?,Long> counting()
        //返回一个Collector接受类型为T的元素，用于计算输入元素的数量。
        System.out.println(emps.stream()
                .distinct()
                .filter(e->e.getAge()>=25)
                .collect(Collectors.counting()));


        //static <T> Collector<T,?,Optional<T>> maxBy(Comparator<? super T> comparator)
        //返回一个Collector ，它根据给定的Comparator生成最大元素，描述为Optional<T> 。
        //static <T> Collector<T,?,Optional<T>> minBy(Comparator<? super T> comparator)
        //返回一个Collector ，它根据给定的Comparator生成最小元素，描述为Optional<T> 。
        //获取薪资最高的员工
        System.out.println(
                emps.stream()
                        .distinct()
                        .collect(Collectors.maxBy((x,y)->Double.compare(x.getSal(),y.getSal())))
                        .get()
        );

        //static <T> Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)
        //返回一个Collector ，它产生应用于输入元素的双值函数的算术平均值。
        //平均工资
        System.out.println(
                emps.stream()
                        .distinct()
                        .collect(Collectors.averagingDouble(Employee::getSal))
        );

        //static <T> Collector<T,?,Double> summingDouble(ToDoubleFunction<? super T> mapper)
        //返回一个Collector ，它产生应用于输入元素的双值函数的总和。
        //薪资总和
        System.out.println(
                emps.stream()
                        .distinct()
                        .collect(Collectors.summingDouble(Employee::getSal))
        );

        //static Collector<CharSequence,?,String> joining()
        //返回一个Collector ，它将输入元素按照遇到的顺序连接成一个String 。
        //员工姓名 拼接字符串
        System.out.println(
                emps.stream()
                        .distinct()
                        .map(Employee::getName)
                        .collect(Collectors.joining())
        );
    }
}

5. 多线程

线程是程序中的执行顺序流。

三高网站 : 高可用高性能高并发

多线程的优点 :
资源利用率更好,性能更高,效率更高
多线程的缺点 :
设计复杂,可能造成数据不安全

线程的创建方式 :
1.继承Thread,重写run方法 + start开启线程
2.实现Runnable接口,重写run方法 + start开启线程
3.实现juc包下Callable接口,重写call方法 + 线程池

6. 线程状态

五种：

新生状态 : new
就绪状态 : start 进入就绪状态的线程会进入到就绪队列,等待cpu的调度（start、yield礼让线程、cpu的调度切换、阻塞解除）
运行状态 : cpu调度执行
阻塞状态 : 无法正常运行（sleep、join、wait、IO）
终止状态（通过添加标识判断方式）

一旦一个线程进入到终止状态无法恢复，并且一个线程当阻塞状态解除会直接恢复到就绪状态

join : 插队线程 | 合并线程
final void join() 等待这个线程终止。先就绪后插队

yield : 礼让线程
当一个线程调用yield,会从运行恢复到就绪状态,同时让出cpu的资源

守护线程 :
当所有的用户线程全部执行完毕,守护线程无论是否执行完毕,JVM都会直接退出
守护线程是用来守护用户线程的
当创建一个线程默认为用户线程,如果想要设置成为守护线程 final void setDaemon(boolean on) 将此线程标记为daemon线程或用户线程。 true->守护 false->用户

注意 : 垃圾回收机制是典型守护线程
先设置守护后设置就绪

7. 线程通信

wait() 与 notify(),notifyAll()协调多线程多共享数据的存储使用,需要控制同步环境下使用

wait 当一个线程执行到wait()方法,会进入到与该对象相关的等待池中进行等待(等待队列),等待被唤醒--->等待阻塞
让出cpu的资源,同时也会让出对象锁资源
notify : 唤醒对象等待池中正处于等待的线程,唤醒是一个激活状态,可以继续参与线程调度,但是需要获取对象锁才能够执行

8. 网络编程

网络编程 : 底层数据的传输

IP : 定位节点 (电子设备,手机,电脑...)
IPV4 IPV6

192.168.0.0~192.168.255.255 供组织内部使用的,非注册IP
127.0.0.1 本地IP
localhost : 本地域名
IP-->域名 : DNS解析器

java.net包
InetAddress 此类表示 Internet 协议 (IP) 地址。

端口 : 区分软件
2个字节 0~65535
统一协议下端口号不能冲突
8000以内为预留端口号
常见端口号 :
80 : http
8080 : tomcat
1521 : Oracle
3306 : Mysql

InetSocketAddress : 此类实现了一个 IP 套接字地址（IP 地址 + 端口号）

URL : 统一资源定位符

传输层协议 : 规范标准合同
UDP : 写信|包裹 , 协议简单,开销小,效率高不安全有大小限制
TCP : 打电话 , 基于连接基于3次握手基于四次挥手效率较低较安全没有大小限制

URL : 统一资源定位符

类URL表示统一资源定位器，它是指向万维网上“资源”的指针。

互联网的三大基石 : url http html

组成：协议、域名、端口、资源

9. 反射

JAVA有着一个非常突出的动态相关机制：Reflection。
反射的作用 :
Java反射机制，可以实现以下功能：
①在运行时判断任意一个对象所属的类；
②在运行时构造任意一个类的对象；
③在运行时判断任意一个类所具有的成员变量和方法；
④在运行时调用任意一个对象的方法；
⑤生成动态代理

注意 : 反射发生在程序运行期间

反射的源头 :
Class 类Class的实例表示正在运行的 Java 应用程序中的类和接口。
Class类型的对象是类在加载到内存之后就会存在,独一份的,不变的

获取Class对象的方式 :
1.类名.class
2.Class.forName(权限定名) --> 推荐
3.对象.getClass()