lambda语法，java8Stream流，maven

news2025/1/11 6:05:08

lambda语法

Arraylist排序

ArrayList<Integer> a = new ArrayList();
        a.add(1);
        a.add(2);
        a.add(3);

        a.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;//对集合a中数据进行升序排序
            }
        });

但是这样的书写还是有一些复杂，于是就有了一种更简单的写法。

ArrayList<Integer> a = new ArrayList();
        a.add(4);
        a.add(2);
        a.add(3);

        a.sort((o1,o2)->{
            return o1-o2;//使用了lambda表达式，与上段代码一样
        });
        System.out.println(a);

什么是lambda表达式

Lambda表达式是一种匿名函数，通常用于简化代码、实现小型函数而不需要定义完整的函数。

lambda也是一种语法糖，语法糖（Syntactic Sugar）指的是一种语言设计特性，允许程序员以更简洁、易读的方式编写代码。其实质上，它不增加语言的功能，只是提供了一种更方便的语法，使得程序员的编写和理解更加轻松。

使用lamdba表达式要求
一个抽象类或者接口里面只能有一个方法
@FunctionalInterface添加了这个注解的抽象类只能有一个抽象方法
匿名函数，把函数当作参数一样传递
lambda函数怎么使用，使用arraylist排序来举例

在这个Comparator接口里面只有一个compare方法，里面传入了两个参数，要使用lambda的要求就是一个抽象类或者接口里面只能有一个方法，因为arraylist排序方法里面要传入一个Comparator接口，new 一个对象可以直接重写，但是使用lambda表达式就十分简单，只需（o1,o2）->{},其中o1，o2是传进的参数，{}里面可以直接重写方法，和上面的案例一样。

java8Stream流

我们之前所学的IO流是在文件上面进行输入输出，我们现在所说的这个流是在数组和集合的基础上进行操作的。

处理数据集合（数组，集合）
对数组，集合进行各种操作（过滤，排序.....）

Stream 处理数据大体过程

数组/集合 --> 流 --各种操作（排序，过滤）--> 结果（数组，集合类）

如何获取数组和集合的流

ArrayList<Integer> a1 = new ArrayList<>();
        a1.add(1);
        a1.add(5);
        a1.add(3);
        a1.add(4);
        Stream<Integer> stream = a1.stream();//集合获取流的方式

 Integer[] a2 = new Integer[]{1,2,3,4,5};
        Stream<Integer> stream1 = Arrays.stream(a2);//数组获得流的方式

Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);//获得流

流的操作

分为中间操作（流的各种处理）和终端操作（把流转化为最终结果）

中间操作：filter：过滤流中的某些元素,
sorted(): 自然排序，流中元素需实现 Comparable 接口
distinct: 去除重复元素
limit(n): 获取 n 个元素
skip(n): 跳过 n 元素，配合 limit(n)可实现分页
map(): 将其映射成一个新的元素

ArrayList<Integer> a1 = new ArrayList<>();
        a1.add(1);
        a1.add(5);
        a1.add(3);
        a1.add(4);
        a1.add(3);
        a1.add(4);
        a1.add(2);
        Stream<Integer> stream = a1.stream();//集合获取流的方式
        a1.stream().filter((e)->{
            return e>1;//过滤集合中大于1的
        }).sorted()//升序排序
                .distinct()//去除重复元素
                .skip(2)//跳过两个元素
                .limit(2)//限制输出元素
                .forEach((e)->{//我们这里就使用了lambda表达式
            System.out.println(e); //集合遍历
        });

终端操作
forEach: 遍历流中的元素
toArray:将流中的元素倒入一个数组
Min:返回流中元素最小值
Max:返回流中元素最大值
count:返回流中元素的总个数
Reduce:所有元素求和
anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返
回 true，否则返回 false
allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返
回 true，否则返回 false
findFirst：返回流中第一个元素
collect:将流中的元素倒入一个集合,Collection 或 Map

Integer i = a1.stream().distinct()
//                .findFirst().get();//返回第一个元素
//        System.out.println(i);


//        boolean b = a1.stream().distinct()
//                .anyMatch((e) -> {
//                    return e > 2;//有一个元素满足条件返回true,allMatch所有条件满足返回true否则返回false
//                });
//        System.out.println(b);


//        Integer i = a1.stream().distinct()
//                .reduce((o1, o2) -> {
//                    return o1 + o2;//流中所有元素相加
//                }).get();
//        System.out.println(i);


//        long count = a1.stream().distinct()
//                .count();//计算流中数据个数,为long类型
//        System.out.println(count);

//        Integer i = a1.stream().distinct()
//                .min((o1, o2) -> {
//                    return o1 - o2;//最小值min方法将数据包装在一个类中需要调用get方法返回数据,max也一样
//                }).get();
//        System.out.println(i);


//        a1.stream().distinct()
//                .forEach((e)->{
//                    System.out.println(e);//元素遍历
//                });

将整数换成student对象
 student s1 =new student(1,"张三1",18);
        student s2 =new student(2,"张三2",19);
        student s4 =new student(3,"张三4",20);
        student s3 =new student(4,"张三3",21);
        student s6 =new student(5,"张三6",22);
        ArrayList<student> a = new ArrayList<>();
        a.add(s1);
        a.add(s2);
        a.add(s3);
        a.add(s4);
        a.add(s6);
//        Map<Integer, String> collect = a.stream()
//                .collect(Collectors.toMap(student::getId, student::getName));//将对象中的属性的值映射到一个新的集合中去也是lambda表达式
//        System.out.println(collect);


//        List<student> collect = a.stream().sorted((o1, o2) -> {
//            return o1.getAge() - o2.getAge();//用年龄排序
//        }).collect(Collectors.toList());//将流转换为list集合
//        System.out.println(collect);


//        List<Integer> collect = a.stream().map(student::getId)//将对象中某个属性的值映射到一个新的集合中去
//                .collect(Collectors.toList());
//        System.out.println(collect);

maven

概述

Maven 是 Apache 软件基金会的一个开源项目,是一个优秀的项目构建工具,它
用来帮助开发者管理项目中的 jar,以及 jar 之间的依赖关系、完成项目的编译、
测试、打包和发布等工作。

Maven 管理的项目的根目录下都有一个 pom.xml 文件。
pom.xml 文件指示 Maven 如何工作。
在 pom.xml 文件中配置项目基本信息以及项目构建信息等。比如：项目坐标、
项目依赖的 jar、插件、编译选项等。
一旦在 pom.xml 文件中配置了所依赖的 jar，Maven 会自动从构件仓库中下
载相应的构件。

坐标

Maven 给每个 jar 定义了唯一的标志，这个在 Maven 中叫做项目的坐标，通
过这个坐标可以找到你需要用到的任何版本的 jar 包。
groupId、artifactId、packaging、version 的组合被称为项目的坐标，它们形
成了项目的唯一标识，Maven 通过坐标来精确定位构件。其中 groupId、
artifactId、version 是必须的，且这三项的值必须唯一，packaging 是可选的(默
认为 jar)。

仓库

中央仓库全球共享,先将 jar 从中央仓库下载到本地仓库,然后在项目中引用本地
仓库的 jar.在使用的时候会先在本地仓库查找，如果没有会在中央仓库查找并且下载，我们一般都会使用中央仓库镜像来下载，这样会快一点。