java基础复习——day18（Stream流 ； 反射）

最新推荐文章于 2023-01-11 19:44:05 发布
最新推荐文章于 2023-01-11 19:44:05 发布
阅读量685 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kevinwen0228/article/details/123772843
版权

Stream流

1. 生成方式

Stream流 函数式编程 牛逼666 用到Lambda表达式

Stream流操作：
在这里插入图片描述
stream流的使用

  • 生成流
    通过数据源(集合,数组等)
    生成流list.stream()
  • 中间操作
    一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
  • 终结操作
    一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作forEach()

常见的生成流的方式：

  • Collection体系的集合可以使用默认方法stream()生成流
  • Map体系的集合间接的生成流
  • 数组可以通过Stream接口的静态方法of(T… values)生成流
package Lambda;

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

//测试类
public class Demo {
    public static void main(String[] args) {
        //Collection体系生成流 默认方法生成流
        List<String> list = new ArrayList<>();
        Stream<String> liststream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setstream = set.stream();

        //Map体系生成流，间接生成流
        Map<String, Integer> map = new HashMap<>();
        Stream<String> keySetStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //数组通过Stream接口的静态方法of 生成流
        String[] str = {"hello", "world", "java"};
        Stream<String> strStream = Stream.of(str);
        Stream<String> strStream1 = Stream.of("hello", "world", "java");
        Stream<Integer> integerStream = Stream.of(10, 20, 30, 40);
    }
}

2. Stream常见的中间操作方法

2.1 filter

  • Stream filter(Predicate predicate):用于对流中的数据进行过滤Predicate接口中的方法
  • boolean test(T t):对给定的参数进行判断，返回一个布尔值
package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("张添胜");
        arrayList.add("张天");
        arrayList.add("张天神");
        arrayList.add("文天");
        arrayList.add("胜");
        arrayList.add("添胜");
        arrayList.add("张天胜");
        System.out.println(arrayList);

        arrayList.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() >= 3).forEach(System.out::println);
        //张添胜
        //张天神
        //张天胜
    }
}

2.2 limit和skip

  • Stream limit(long maxSize):返回此流中的元素组成的流，截取前指定参数个数的数据
  • Stream skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流
package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("张添胜");
        arrayList.add("张天");
        arrayList.add("张天神");
        arrayList.add("文天");
        arrayList.add("胜");
        arrayList.add("添胜");
        arrayList.add("张天胜");

        //取前三个 输出
        arrayList.stream().limit(3).forEach(System.out::println);
        System.out.println("---------------------");

        //跳过前三个
        arrayList.stream().skip(3).forEach(System.out::println);
        System.out.println("---------------------");

        //跳过前两个，剩下的前三个
        arrayList.stream().skip(2).limit(3).forEach(System.out::println);
    }
}

2.3 concat和distint

  • static Stream concat(Stream a, Stream b):合并a和b两个流为一个流
  • Stream distinct():返回由该流的不同元素（去重）(根据Objectequals(Object)）组成的流
package Lambda;

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

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("张添胜");
        arrayList.add("张天");
        arrayList.add("张天神");
        arrayList.add("文天");
        arrayList.add("胜");
        arrayList.add("添胜");
        arrayList.add("张天胜");

        //流1：前四个   .3
        Stream<String> s1 = arrayList.stream().limit(4);

        //流2：跳过前两个  5
        Stream<String> s2 = arrayList.stream().skip(2);

        //合并两个流 输出
        //Stream.concat(s1,s2).forEach(System.out::println);

        //合并， 去重 输出
        Stream.concat(s1, s2).distinct().forEach(System.out::println);

    }
}

2.4 sorted

  • Stream sorted):返回由此流的元素组成的流，根据自然顺序排序
  • Stream sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序
package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("adjflka");
        arrayList.add("jfldfjaldk");
        arrayList.add("osdfsf");
        arrayList.add("xncod");
        arrayList.add("werod");
        arrayList.add("nclasdnf");

        //按照字母顺序排序 默认
        //  arrayList.stream().sorted().forEach(System.out::println);

        //按照字符串长度 次：字母顺序
        arrayList.stream().sorted((s1, s2) -> {
            int num = s1.length() - s2.length();
            int num1 = num == 0 ? s1.compareTo(s2) : num;
            return num1;
        }).forEach(System.out::println);
        //werod
        //xncod
        //osdfsf
        //adjflka
        //nclasdnf
        //jfldfjaldk
    }
}

2.5 Map和MapToInt

  • Stream map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流Function接口中的方法 R apply(T t)
  • IntStream mapTolnt(TolntFunction mapper):返回一个Stream其中包含将给定函数应用于此流的元素的结果 ， 比如sum()

IntStream:表示原始int流
ToIntFunction接口中的方法 ： int applyAsInt(T value)

package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("10");
        arrayList.add("20");
        arrayList.add("30");
        arrayList.add("40");
        arrayList.add("50");

        //Stirng -> int , 输出
        arrayList.stream().map(Integer::parseInt).forEach(System.out::println);
        arrayList.stream().mapToInt(Integer::parseInt).forEach(System.out::println);//都可以转类型

        //mapToInt求和
        int sum = arrayList.stream().mapToInt(Integer::parseInt).sum(); //注意返回类型
        System.out.println(sum);
    }
}

3. Stream常见的终结操作方法

  • forEach()方法:对每个元素操作
  • count()方法：返回此流的元素数
package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();

        arrayList.add("张添胜");
        arrayList.add("张天");
        arrayList.add("张天神");
        arrayList.add("文天");
        arrayList.add("添胜");
        arrayList.add("张天胜");

        //姓张的数量
        long sum = arrayList.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(sum);//4
    }
}

Stream练习：

package Lambda;

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

//测试类
public class Demo {
    public static void main(String[] args) {
        //创建男女集合
        ArrayList<String> manList = new ArrayList<>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");

        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");

        //男演员只要名字3个字 前三人
        Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);

        //女演员 姓林 第一个不要
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);

        //合并过滤后的男女
        Stream<String> concatStream = Stream.concat(manStream, womanStream);

        //把结果创建成对象
        concatStream.map(Actor::new).forEach(p -> System.out.println(p.getName()));//这确实离谱 创建对象的Lambda表达式不熟练
        System.out.println("-----------------------");

        //熟练方法
        Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3),
                        womanList.stream().filter(s -> s.startsWith("林")).skip(1))
                .map(Actor::new)
                .forEach(p -> System.out.println(p.getName()));
    }
}

4. Stream流的收集操作

把流中的数据收集到集合中：
收集方法：

  • R collect(Collector collector)
  • 但是这个收集方法的参数是一个Collector接口

工具类Collectors提供了具体的收集方式：

  • public static Collector toListi():把元素收集到List集合中
  • public static Collector toSet():把元素收集到Set集合中
  • publicstatic Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中
package Lambda;

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

//测试类
public class Demo {
    public static void main(String[] args) {
        //  1.  名字大于3个字存入list集合 遍历
        List<String> list = new ArrayList<>();
        list.add("文天圣");
        list.add("天圣");
        list.add("文天s");
        list.add("文t圣");

        Stream<String> listStream = list.stream().filter(s -> s.length() >= 3);
        List<String> list1 = listStream.collect(Collectors.toList());

        for (String s : list1) {
            System.out.println(s);
        }
        //文天圣
        //文天s
        //文t圣


        //  2.   数值大于25存入set集合
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(32);

        Stream<Integer> integerStream = set.stream().filter(i -> i > 25);
        Set<Integer> set1 = integerStream.collect(Collectors.toSet());

        for (Integer i : set1) {
            System.out.println(i);
        }
        //32
        //30


        // 3. 流存入map集合  年龄大小于30
        String[] strarray = {"wts,20", "xwb,30", "cyc,40"};
        Stream<String> mapStream = Stream.of(strarray).filter(s -> Integer.parseInt(s.split(",")[1]) >= 30);
        Map<String, Integer> map1 = mapStream.collect(Collectors.toMap(k -> k.split(",")[0], v -> Integer.parseInt(v.split(",")[1])));

        Set<String> keySet = map1.keySet();
        for (String k : keySet) {
            Integer value = map1.get(k);
            System.out.println(k + value);
            //xwb30
            //cyc40
        }
    }
}

反射（一言难尽）

1. 类加载和类加载器

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，VM将会连续完成故三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化

类加载：

  • 就是指将class文件读入内存，并为之创建一个java.lang.Class对象
  • 任何类被使用时，系统都会为之建立一个java.lang.Class对象

类的连接：

  • 验证阶段:用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
  • 准备阶段:负责为类的类变量分配内存，并设置默认初始化值
  • 解析阶段:将类的二进制数据中的符号引用替换为直接引用

类的初始化：
在该阶段，主要就是对类变量进行初始化

类的初始化步骤

  • 假如类还未被加载和连接，则程序先加载并连接该类
  • 假如该类的直接父类还未被初始化，则先初始化其直接父类（先父后子）
  • 假如类中有初始化语句，则系统依次执行这些初始化语句

类初始化时机

  • 创建类的实例
  • 调用类的类方法
  • 访问类或者接口的类变量，或者为该类变量赋值
  • 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
  • 初始化某个类的子类
  • 直接使用java.exe命令来运行某个主类

类加载器
在这里插入图片描述

2. 反射

java反射机制:
是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展

在这里插入图片描述

大概是犬青
关注
注解和反射Stream 流以及四大函数式接口及Lambda表达式
m0_50507927的博客
05-17 4025
一，
java 集合反射_java List集合利用反射结合流的filter做一个筛选
weixin_35193131的博客
02-21 647
stream流使用filter可以做到过滤筛选作用，本测试基于现有的筛选功能做了点修改，根据传入的参数可以实现动态的过滤筛选。传入的查询参数对象和集合里的对象可以不一样，但字段需要一致。主要步骤：1.利用反射获取查询参数queryParam对象的说所有方法2.遍历反射获取到的所有方法，如果传入了参数，通过get方法可以获取到一个非空的值(查询参数对象queryParam里面的基本数据类型都需要转换...
stream流
qq_41141896的博客
05-30 242
Stream API(java.util.stream.*) Stream 是 Java8 中处理集合的关键抽象概念， 它可以指定你希望对集合进行的操作， 可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。 简而言之，Stre...
java 反射 取stream_Java的反射机制
weixin_42551227的博客
02-24 313
一、反射机制1、反射的定义：在运行状态中，对于任意一个类，都能够获取到这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性(包括私有的方法和属性)，这种动态获取的信息以及动态调用对象的方法的功能就称为java语言的反射机制。通俗点讲，通过反射，该类对我们来说是完全透明的，想要获取任何东西都可以。2、关于Class(类)(1) Class是一个类，一个描述类的类(也就是描述类...
java 反射 取stream_Java 之反射
weixin_42322347的博客
02-24 245
反射概述反射概述：反射(Reflection) 是被视为 动态语言 的关键，反射机制允许程序在执行期间借助于Reflection API 取得任何内部类的信息，并能直接操作任意对象的内部属性及方法。加载完类之后，在堆内存的方法区中就产生了一个Class 类的对象(一个类只有一个Class 对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜...
java 反射 stream对象_JAVA基础知识之JVM-——使用反射生成并操作对象
weixin_31572189的博客
02-13 166
Class对象可以获取类里的方法，由Method对象表示，调用Method的invoke可以执行对应的方法；可以获取构造器，由Constructor对象表示，调用Constructor对象的newInstance方法可以执行类对应的构造方法；可以获取成员变量，由Field对象表示，通过Field对象可以直接修改类的成员变量的访问权限和值。创建对象通过反射有两种方式创建对象使用Class对象的new...
动力节点老杜Java基础入门视频教程（适合Java 0基础，Java初学入门）——day16作业题
09-18
005-JavaSE进阶-day16作业题
一起学java——Day01.txt
04-03
从0开始一起学java，互帮互助 本文主要讲述变量，数据类型，Scanner类的应用以及printf()的相关知识
一起学Java——Day02.md
04-04
该资源为md格式，类似于笔记，内容包括运算符，三目运算符，以及数据类型的转换，注意笔记是我的笔记，学到了才是你的。
Java反射机制
Stream_who的博客
01-06 513
一、基本概念 1.Java语言允许通过程序化的方式间接对Class进行操作，Class文件由类装载器装载后，在JVM中将形成一份描述Class结构的元信息对象，通过该元信息对象可以获知Class的结构信息：如构造函数、属性和方法等 2.Java允许用户借由这个Class相关的元信息对象间接调用Class对象的功能，这就为使用程序化方式操作Class对象开辟了途径 3.反射、映像、倒影，用在Ja
java 反射 取stream_java Stream流，方法引用
weixin_34212182的博客
02-17 482
1.Stream流1.1两种获取流的方法java.util.stream.Stream 是Java 8新加入的最常用的流接口。(这并不是一个函数式接口。)获取一个流非常简单，有以下几种常用的方式：所有的 Collection 集合都可以通过 stream 默认方法获取流；Stream 接口的静态方法 of 可以获取数组对应的流。根据Collection获取流importjava.util.*;i...
Java 8个反射实例
01-10
Java 8个反射实例 项目实例 项目工程
Java学习笔记-StreamApi,类加载与反射机制
qq_43925052的博客
08-02 193
一、Stream流 //生成流 static stream(T[] array) //根据数组生成流 default stream() //根据引用该方法的集合生成流 static of(T...values) //根据给定的各个元素生成有序的流 static of(T t) //生成包含单个元素的流 //中间操作(对流进行) //一个流的后面可以跟若干中间操作，目的是打开流，对其中数据进行过滤/映射，然后返回一个新的流，交给下一个操作使用 filter(Predicate<? super T
反射、类对象、Stream API
a__handsome的博客
12-05 363
反射 reflect 定义：在运行期间，可以获取对象的类型、类型的方法、类型构造方法等等，让对象可以认识到自身的结构。 获取对象的类型（类对象） 方式一:Object.getclass() 方式二：class.forName(“全类名加包”) 方式三：类名.class 类对象的功能 （1）用反射方式创建对象 正常创建对象：new 类名(); 反射的方式创建对象：类对象.newInstance（）；...
18、Java 8 - 流 Stream ( 上 )
最新发布
qq_33291299的博客
01-11 81
流(Stream ) 是 Java 8 新增加的一个重磅级的功能。流是一个抽象层。有了流，我们就可以使用类似于 SQL 语句的声明方式来处理数据。比如，下面的 SQL 语句上面这条 SQL 会自动返回最高学习绩点的学生的信息，而全程，开发人员却不用直接面对任何计算和比较。在流（ Stream ) 出现之前，对于Java 中的集合框架的使用。开发人员不得不一次次的写一个循环，一次次的重复检查。当然了，这也什么，毕竟大家都是这样过来的。更大的问题在于开发效率。面对当前的多核 CPU 计算机，面对并发编程。
Java基础（五）——反射、lambda、stream
波仔头的博客
09-30 682
Java基础一级目录二级目录三级目录 一级目录 二级目录 三级目录
使用stream流的map调用set()方法提示不存在变量R的实例，因此void符合R
qq_42191033的博客
09-20 1304
会返回一个对象，而不是void。，因为不要求返回一个对象。原因：因为使用map。
Java Stream特性与lambda表达式
We_chuan的博客
12-04 938
古人学问无遗力，少壮工夫老始成 Stream 简介 Stream 流是jdk1.8版本引进的，那么Stream主要是对Java中的集合所提出的的集合流抽象工具（java.util.stream）,主要用于集合内的元素的计算，准确的说是过滤和统计计算。 lambda简介 Java9 在语法上提供了Lambda表达式来传递方法体,简化了之前方法必须藏身在不必要的类中的繁琐。Lambda表达式体现了...
java反射set方法_面试宝典Java基础 [ PART 02 ]
weixin_32101377的博客
12-14 364
1.如何改变String类的值，保证地址不变？我们都知道String是一个不可变类，因为它的源码内部维护着一个final修饰的char数组，final修饰的变量不可以被改变，修饰的方法不可以被重写，修饰的类不可以被继承：(简要源码)public final class String implements java.io.Serializable, Comparable<St...
Java基础教程：Day01-变量与数据类型解析
"一起学Java—Day01：Java基础语法，包括注释、变量、数据类型和Scanner类的应用及printf()的相关知识" 在Java编程语言中，掌握基础语法是学习的关键步骤。本文主要涵盖了以下几个方面： 1. **Java中的注释**： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值