菜鸡学习day24

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量128 收藏
点赞数
分类专栏： 给自己看 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47330507/article/details/106124188
版权

菜鸡学习day24

package day24;

import java.util.*;
import java.util.stream.Stream;

/*
Stream流
jdk1.8之后出现的，关注的是做什么，不是怎么做
遍历

流式思想
Stream接口 不是函数式接口
获取流
1.所有的Collection集合都可以通过默认方法stream获取流
    default Stream<E> stream()
2.静态方法of 可以获取对应数组的流
    static <T> Stream<T> of(T…values)
    可变参数，可以传递数组
常用方法
延迟方法（返回值类型仍是接口自身类型的方法，因此支持链式调用）
终结方法（返回值类型不再是…………，不支持………………）count forEach 其他都是延迟
1.forEach
Consumer接口 消费型接口，lambda
void forEach(Cinsumer<? super T> action)
forEach，遍历流中的数据，遍历完后不能再调用其他方法

2.过滤方法filter
将一个流转换成另一个子集流

Stream属于管道流，只能被消费一次
第一个流调用完毕方法，数据就会流转到下一个流
此时第一个流关闭，不能再调用方法

map方法 映射
<R> Stream<R> map(Function<? super T,? extens R> mapper)
Function接口
可以将一个流中的元素映射到另一个流中

count方法 统计个数
终结方法，返回值是一个long类型的整数，所以不能继续调用流中的其他方法

limit方法 截取前几个
延迟方法，对流中的元素进行截取，返回一个新的流，原来的流可以继续使用

skip方法 跳过前几个 截取剩余部分，返回一个新流
延迟

concat静态方法 组合，将两个流合并为一个流

方法引用
对lambda表达式的优化
前提是对象和方法都已经存在
格式：print1(System.out::println);

通过对象名引用成员方法
使用前提：对象名和成员方法已经存在
print1(person::printperson);

通过类名引用静态方法
使用前提：类和静态方法已经存在
cal1(-10,Math::abs)

使用super引用父类成员方法
method（super::父类成员方法），无需创建父类对象

使用this引用本类的成员方法
method（this::本类成员方法）

类的构造器引用
printName("小周",Person::new);

数组的构造器引用
createArray(10,int[]::new);
 */

public class D2401 {
    public static void main(String[] args){
        //Stream流对遍历进行优化
        stream01();

        //集合转换为Stream流
        huoQu();

        //forEach
        forEach1();

        //filter 过滤
        filter1();

        //map方法 映射
        map1();

        //count 统计个数
        count1();

        //limit 取用前几个
        limit1();

        //skip 跳过前几个元素，截取剩余部分
        skip1();

        //concat静态方法 将两个流合并为一个流
        concat1();

//        //集合元素处理(普通)
        lianXi1();

        //集合元素处理（Stream流）
        lianXi2();

        //方法引用？？
        print1((str)->{
            System.out.println(str);
        });
        print1(System.out::println);

        //通过对象名引用成员方法
        Person person = new Person();
        person.printperson("aaa");
        print1(person::printperson);

        //通过类名引用静态方法
        int num = cal1(-10,(n)->{return Math.abs(n);});
        cal1(-10,Math::abs);

        //类的构造器引用
        printName("小周",Person::new);

        //数组的构造器引用
        createArray(10,int[]::new);
    }



    //Stream流对遍历进行优化
    public static void stream01(){
        ArrayList<String> list = new ArrayList<>();
        list.add("小明");
        list.add("大红");
        list.add("大大周");
        list.add("小王");

        list.stream().filter((str) -> str.startsWith("大"))
                .filter((str) -> str.length() == 3)
                .forEach((str) -> System.out.println(str));
    }

    //集合转换为Stream流
    public static void huoQu(){
        //list
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        //set
        Set<String> set1 = new HashSet<>();
        Stream<String> stream2 = set1.stream();

        //map
        Map<String,String> map1 =new HashMap<>();
        Set<String> set2 = map1.keySet();//键
        Stream<String> stream3 = set2.stream();
        Collection<String> coll = map1.values();//值
        Stream<String> stream4 = coll.stream();
        Set<Map.Entry<String,String>> entry = map1.entrySet();//键值对
        Stream<Map.Entry<String,String>> stream5 = entry.stream();

        //静态方法of获取流
        Integer[] array = {6,7,8,9,10};
        Stream<Integer> stream6 = Stream.of(array);
    }

    //forEach遍历
    public static void forEach1(){
        Stream<String> stream1 = Stream.of("aa","bb","cc","dd");
        stream1.forEach((str)->{
            System.out.println(str);
        });
    }

    //filter 过滤
    public static void filter1(){
        Stream<String> stream1 = Stream.of("aa","bb","cc","dd");
        Stream s = stream1.filter((str)->{
            return str.startsWith("c");
        });
        s.forEach((str)->{
            System.out.println(str);
        });
    }

    //map方法 映射
    public static void map1(){
        Stream<String> stream1 = Stream.of("1","2","3","4");
        Stream<Integer> stream2 = stream1.map((str)->{
            return Integer.parseInt(str);
        });
        stream2.forEach((i)->{
            System.out.println(i);
        });
    }

    //count 统计个数
    public static void count1(){
        Stream<String> stream1 = Stream.of("aa","bb","cc","dd");
        Long l = stream1.count();
        System.out.println(l);
    }

    //limit 取用前几个
    public static void limit1(){
        Stream<String> stream1 = Stream.of("aa","bb","cc","dd");
        Stream<String> stream2 = stream1.limit(2);
        stream2.forEach((str)->{
            System.out.println(str);
        });
    }

    //skip 跳过前几个元素，截取剩余部分
    public static void skip1(){
        Stream<String> stream1 = Stream.of("aa","bb","cc","dd");
        Stream<String> stream2 = stream1.skip(2);
        stream2.forEach((str)->{
            System.out.println(str);
        });
    }

    //concat静态方法 将两个流合并为一个流
    public static void concat1(){
        Stream<String> stream1 = Stream.of("aa","bb","cc","dd");
        Stream<String> stream2 = Stream.of("1","2","3","4");
        Stream.concat(stream1,stream2).forEach((str)->{
            System.out.println(str);
        });
    }

    //集合元素处理(普通)
    public static void lianXi1(){
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        String[] arr1 = {"AAA","BB","CCC","DD","EEE","FF","GGG","HH"};
        String[] arr2 = {"aa","1bb","cc","1dd","ee","1ff","gg","1hh"};
        //第一个队伍
        for(String str : arr1){//初始化
            list1.add(str);}
        List<String> list11 = new ArrayList<>();
        for(String str : list1){//只要名字为三个字的
            if(str.length() == 3){
                list11.add(str);
            }
        }
        List<String> list12 = new ArrayList<>();//只要前三个
        for(int i = 0;i < 3;i++){
            list12.add(list11.get(i));
        }

        //第二个队伍
        for (String str : arr2){//初始化
            list2.add(str);
        }
        List<String> list21 = new ArrayList<>();
        for(String str : list2){//只要开头有1的
            if(str.startsWith("1")){
                list21.add(str);
            }
        }
        List<String> list22 = new ArrayList<>();//不要前两个
        for(int i = 2;i < list21.size();i++){
            list22.add(list21.get(i));
        }
        System.out.println(list2);
        System.out.println(list21);
        System.out.println(list22);

        //合并
        List<String> list3 = new ArrayList<>();
        for(String str : list12){list3.add(str);}
        for(String str : list22){list3.add(str);}

        List<Person> list4 = new ArrayList<>();
        for(String str : list3){
            list4.add(new Person(str));
        }
        for(Person p : list4){
            System.out.println(p);
        }
    }

    //集合元素处理（Stream流）
    public static void lianXi2(){
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        Stream<String> stream1 = list1.stream();
        Stream<String> stream11 = Stream.of("AAA","BB","CCC","DD","EEE","FF","GGG","HH")
                .filter((str)->str.length() == 3).limit(3);

        Stream<String> stream2 = list2.stream();
        Stream<String> stream21 = Stream.of("aa","1bb","cc","1dd","ee","1ff","gg","1hh")
                .filter((str)->str.startsWith("1")).skip(2);
        
        List<String> list3 = new ArrayList<>();
        Stream<String> stream3 = list3.stream();
        stream3 = Stream.concat(stream11,stream21);

        List<Person> list4 = new ArrayList<>();
        Stream<Person> stream4 = list4.stream();
        stream4 =stream3.map((str)->new Person(str));
        stream4.forEach((str)->{
            System.out.println(str);
        });
    }

    //
    public static void print1(Print1 p){
        p.print("AAA");
    }
    public static int cal1(int i, Cal c){
        return c.cal(10);
    }

    public static void printName(String name,PersonBuilder pb){
        Person person = pb.buildPerson(name);
        System.out.println(person.getName());
    }

    public static int[] createArray(int len,ArrayBuilder ab){
        return ab.builderArray(len);
    }
}

package day24;

@FunctionalInterface
public interface Print1 {
    void print(String str);//打印字符串的抽象方法
}

package day24;

import java.util.stream.Stream;

public class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void printperson(String str){//大写输出
        System.out.println(str.toUpperCase());
    }
}

package day24;

@FunctionalInterface
public interface Cal {
    int cal(int i);
}

package day24;

@FunctionalInterface
public interface PersonBuilder {
    Person buildPerson(String name);
}

package day24;

@FunctionalInterface
public interface ArrayBuilder {
    int[] builderArray(int len);
}
weixin_47330507
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pictures:菜鸡学习总结
03-13
【标题】：“Pictures:菜鸡学习总结”表明这是一个关于图像处理或者图片学习资源的压缩包，其中可能包含了一些初级学习者的学习笔记、示例代码或教程资料。 【描述】：“Pictures:菜鸡学习总结”简单明了地指出这是...
山东大学深度学习期末复习资料，93菜鸡
03-08
山东大学深度学习期末复习资料，93菜鸡。 包含上课ppt，几套期末试卷以及自己的学习总结。 学弟学妹看了认真复习应该可以90+。加油
菜鸡学习day27
ViVi_Z的博客
05-16 114
菜鸡学习day27 DQL查询语句 1.排序查询 语法：order by 排序字段1，排序字段2 desc 降序 asc升序 （默认升序） 前面的条件一样时才会考虑后面的条件 2.聚合函数 将一列数据作为一个整体，进行纵向计算 聚合函数的计算排除null值 解决方案：（选择非空列计算/ifnull） count计算个数 SELECT COUNT(NAME)FROM
菜鸡学习day28
ViVi_Z的博客
05-17 120
/* 多表查询 查询语法： select 列名列表 from 表名列表 笛卡尔积：有两个集合AB，取他们的所有组合情况 要完成多表查询，需要消除无用数据 分类： 1.内连接查询 1.隐式内连接 (用where消除无用数据) SELECT 字段列表 FROM 表名 WHERE 条件 2.显式内连接 SELECT 字段列表 FROM 表名1 【INNER】 JOIN 表名2 ON 条件; 注：表？条件？查询字段？ 2.外连接查询（一般用左） 1.左外连接 显示左表
菜鸡学习day15_02_斗地主案例
ViVi_Z的博客
04-29 146
菜鸡学习day15_02 这个还不是特别会。。。 package day1502; import java.util.*; /* 斗地主 */ public class D1502 { public static void main(String[] args) { Map<Integer, String> map = new HashMap<&gt...
菜鸡学习day16_异常
ViVi_Z的博客
05-02 120
菜鸡学习day16 异常没太懂，过段时间有空看书，书看完第四章了，囫囵吞枣 package day16; import java.io.FileNotFoundException; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java....
菜鸡学习day17_多线程
ViVi_Z的博客
05-02 133
菜鸡学习day17 package day17; import java.util.Objects; /* void start（）开辟新的栈空间，多线程 Thread类常用方法 1.public String getName() 获取当前线程名称 2.public void start（）开始执行线程，调用run方法 3.public static Thread currentThread（...
菜鸡学习day04_方法格式&重载
ViVi_Z的博客
04-25 110
菜鸡学习day04欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 package...
菜鸡学习day22_网络通信协议
ViVi_Z的博客
05-12 133
菜鸡学习day22 package day22; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; /* 网络通信协议（连接和通信的规则） 双方同时遵守才能数据传输 TCP/IP协议 定义了计算机如何炼乳因特网，以及数据如何在他们之间传输的标准 采用四层的分层模型（了），每层都呼叫它的下一层所提供的协议来完成自己的需求 应用层（应用程序）
菜鸡学习day23_函数式接口
ViVi_Z的博客
05-14 108
菜鸡学习day23 package day23; import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; import java.util.function.Function; import java.util.function.Consumer; import java.util.function.Predicate; import java.util.function.Supplier; /*
菜鸡学习day26数据库的基本概念
ViVi_Z的博客
05-15 133
菜鸡学习day26数据库的基本概念 /* 数据库的基本概念 DataBase（DB） 用于存储和管理数据的仓库 特点：1.持久存储数据结构，其实就是一个文件系统 2.方便存储和管理数据 3.使用了统一的方式操作数据库SQL 数据库软件：MySQL 目录结构 安装目录 bin二进制可执行文件 data 日志数据文件 lib库文件 share错误信息 ini配置文件 数据目录 数据库（文件夹） 表（文件） 数据 SQL：结构化查询语言，定义了操作所有操作关系型数据库的规则 每一种数
Java学习路线.xmind
06-23
适合Java初学者，没有目标的Java开发人员
山东大学2019级智能班神经网络与深度学习复习
01-05
山东大学2019级智能班神经网络与深度学习复习 本资源是山东大学2019级智能班神经网络与深度学习的复习笔记，涵盖了深度学习的基本概念、神经网络的基本结构、损失函数、优化方法、激活函数、批量归一化、Dropout、...
PGRGame菜鸡版.zip
03-28
8. **游戏开发基础**：对于初学者，这个项目提供了一个基础的游戏开发框架，可以学习到如何在Java中创建游戏循环、事件处理、对象交互等基本概念。 9. **扩展性**：尽管当前版本的游戏功能有限，但可以作为基础进行...
（javaweb）请求响应postman
2301_79144798的博客
08-08 483
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 269
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 235
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Spring事务
c1tenj2的博客
08-07 452
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
菜鸡mac地址扫描器
12-30
菜鸡MAC地址扫描器是一种针对局域网中的网络设备进行扫描的工具。它的主要功能是识别和展示网络中各个设备的MAC地址。 菜鸡MAC地址扫描器相对于其他高级的网络工具来说，功能相对简单，易于使用。它可以通过扫描...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值