java Stream流常见操作方法(反射,类加载器,类加载,反射)

目录
  • Stream流常见的中间操作方法
  • Stream流中常见的终结操作方法
  • 反射
    • 类加载器
  • 反射概述

Stream流常见的中间操作方法

  • Streamfilter(Predicate predicate):用于对流中的数据进行过滤

predicate接口中的方法 boolean test(T t):对给定的参数进行判断,返回一个布尔值

  • Stream limit(long maxSize):返回此流中元素组成的流,截取前指定参数个数的数据
  • Stream skip(long n) :跳过指定参数个数据,返回有该流的剩余元素组成的流
  • staticStreamconcat(Stream a ,Stream b):合并a和b两个流为一个流
  • Streamdiatinct():返回有该留的不同元素(根据Objectequals(Object) 组成的流
  • Stream sorted():返回有潮流的元素组成的流,根据自然顺序排序
  • Stream sorted(Comparator comparator):返回由该流元素组成的流,根据提供的Compatator进行排序
  • Streammap(Function mapper):返回由给定函数应用于此流的元素结果组成的流

function 接口中的方法 R applu(T t)

  • intStream mapToint(TointFunction mapper):返回一个intStream其中包含将给定函数应用于此流的元素的结果
  • intStream: 表示原始int流
  • ToIntFunction接口中的方法
  • int applyAsInt(T value)
package Demo1;
import java.util.ArrayList;
public class Demo32 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        //以张开头
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("-------------");
        //长度为3
        list.stream().filter(s -> s.length()==3).forEach(System.out::println);
        System.out.println("---------------");
        //张,长度为3
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);

    }
}
package Demo1;
import java.util.ArrayList;
public class Demo33 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        //需求一,取前三个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        //跳过前三个元素
        list.stream().skip(3).forEach(System.out::println);
        //跳过前2个元素,把剩下元素中国前两个在控制台上输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
        }
    }
package Demo1;
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo34 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        //需求1,取前4给数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        //跳过前两个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
        //需求3,合并1,2得到的流,结果输出在控制台
 Stream.concat(s1,s2).forEach(System.out::println);
        //4,合并1,2流,输出在控制台,字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
        }
}
package Demo1;
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo34 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("lingqinxia");
        list.add("zhangmanyu");
        list.add("wangzhuxian");
        list.add("liuyan");
        list.add("zhangming");
        list.add("zhangwuji");
 //按照字母顺序输出
      //  list.stream().sorted().forEach(System.out::println);
        //按照长度排列输出
        //list.stream().sorted((s1,s2) -> s1.length() - s2.length()).forEach(System.out::println);
list.stream().sorted((s1,s2) ->{
    int num = s1.length()-s2.length();
    int num2 = num ==0?s1.compareTo(s2):num;
    return num2;
}).forEach(System.out::println);
    }
}
package Demo1;
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo34 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("30");
        list.add("40");
        list.add("50");
        list.add("7");
        list.add("87");
        list.add("756");
//将集合中的制度串数据转换为整数输出
//list.stream().map(Integer::parseInt).forEach(System.out::println);
      //  list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
//int sum 返回流中的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

Stream流中常见的终结操作方法

  • void forEach(Consumer action):对此流的每个元素操作

Consumer接口中的方法

void accept(T t ):对给定的参数执行此操作

  • long count():返回此流中的元素数
package Demo1;
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo34 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
//list.stream().forEach(System.out::println);
       long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);
    }
}

反射

类加载器

类加载:

  • 当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过类的加载,类的连接,类的初始化三个步骤对类进行初始化,JVM将会连续完成这三个步骤,所有有时也罢这三个步骤统称为类加载或者类初始化

类的加载:

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

类的连接:

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

类的初始化:

  • 在该阶段,主要就是对类变量进行初始化

类的初始化步骤:

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

注意:在执行第二个步骤的时候,系统对字节父类的初始化步骤也遵循初始化步骤1-3

类的初始化时机:

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

反射概述

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

  • 获取class类的对象
  • 使用class属性来获取对应的class对象,举例:student.class将会返回student类对应的class对象
  • 调用对象的getclass()方法,返回该对象所属类对应的class对象,该方法是object类中的方法,所有的java对象都可以调用该方法
  • 使用class类中的静态方法forName(String className),该方法需要传入字符串参数,该字符串参数的值是某个类的全路径,也就是完整的包名路径

到此这篇关于java Stream流常见操作方法(反射,类加载器,类加载,反射)的文章就介绍到这了,更多相关Stream流操作内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java8 Stream流多字段求和、汇聚的实例

    目录 Stream流多字段求和.汇聚 实现方法 对象类型数据处理 Map类型数据处理 Stream分组求和使用笔记 分组求和使用 Stream流多字段求和.汇聚 实现方法 利用 Collectors.toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) keyMapper:代表你最终想要获得的Map<Key, Value> 的Key valueMapper:代表你最终想要获得的Map<K

  • java jdk1.8 使用stream流进行list 分组归类操作

    我就废话不多说了,大家还是直接看代码吧~ import com.alibaba.fastjson.JSON; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; /** * @author czw */ public class Foo{ private String name; private String type; private Double typeValue; p

  • java基础理论Stream管道流Map操作示例

    目录 一.回顾Stream管道流map的基础用法 二.处理非字符串类型集合元素 三.再复杂一点:处理对象数据格式转换 四.flatMap 一.回顾Stream管道流map的基础用法 最简单的需求:将集合中的每一个字符串,全部转换成大写! List<String> alpha = Arrays.asList("Monkey", "Lion", "Giraffe", "Lemur"); //不使用Stream管道流 L

  • Java8特性之用Stream流代替For循环操作详解

    目录 准备一个实体类 准备一个List集合 传统的for循环 使用Stream流 先声明筛选条件,在遍历 Stream操作 嵌套循环(2层) 准备一个实体类 public class Student { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int get

  • Java8之Stream流代替For循环操作

    Stream流代替For循环进行输出可以使代码更简洁. 需求:根据姓名获取员工信息 1.建立实体类:Emp public class Emp { private String id; private String name; public Emp(String id, String name) { this.id=id; this.name=name; } public String getId() { return id; } public void setId(String id) { th

  • Java8 Stream流根据多个字段去重

    目录 Stream流根据多个字段去重 Stream多字段去重,去重求和 完整demo如下 启动主函数 Stream流根据多个字段去重 分组 list.stream().collect(Collectors.groupingBy(ClassEntity::getGrade)); java8有一个collectingAndThen可以根据多个字段去重 list.stream() .collect(Collectors.collectingAndThen(Collectors.toCollection

  • java Stream流常见操作方法(反射,类加载器,类加载,反射)

    目录 Stream流常见的中间操作方法 Stream流中常见的终结操作方法 反射 类加载器 反射概述 Stream流常见的中间操作方法 Streamfilter(Predicate predicate):用于对流中的数据进行过滤 predicate接口中的方法 boolean test(T t):对给定的参数进行判断,返回一个布尔值 Stream limit(long maxSize):返回此流中元素组成的流,截取前指定参数个数的数据 Stream skip(long n) :跳过指定参数个数据

  • Java Stream流的常见生成和操作方法总结

    目录 一.Stream流简单示例 二.Stream流常见生成方式 三.Stream流中间操作方法 filter代码示例 limit&skip代码示例 concat&distinct代码示例 sorted代码示例 map&mapToInt代码示例 一.Stream流简单示例 需求: 按照要求集合创建和遍历 创建一个结合,存储多个字符串元素 把集合中所有以"张"开头的元素存储到一个新的集合 把"张"开头的集合中的长度为3的元素存储到一个新的集合

  • Java Stream流语法示例详解

    目录 如何使用Stream? Stream的操作分类 1.创建流 2.操作流 1)过滤 2)映射 3)匹配 4)组合 3.转换流 如何使用Stream? 聚合操作是Java 8针对集合类,使编程更为便利的方式,可以与Lambda表达式一起使用,达到更加简洁的目的. 前面例子中,对聚合操作的使用可以归结为3个部分: 1)  创建Stream:通过stream()方法,取得集合对象的数据集. 2)  Intermediate:通过一系列中间(Intermediate)方法,对数据集进行过滤.检索等数

  • Java Stream 流实现合并操作示例

    本文实例讲述了Java Stream 流实现合并操作.分享给大家供大家参考,具体如下: 1. 前言 Java Stream Api提供了很多有用的 Api 让我们很方便将集合或者多个同类型的元素转换为流进行操作.今天我们来看看如何合并 Stream 流. 2. Stream 流的合并 Stream 流合并的前提是元素的类型能够一致. 2.1 concat 最简单合并流的方法是通过 Stream.concat() 静态方法: Stream<Integer> stream = Stream.of(

  • Java Stream流知识总结

    说明 在Java 8中,得益于Lambda所带来的函数式编程,引入了一个全新的Stream概念,用于解决已有集合类库既有的弊端 遍历 传统集合在于使用循环遍历 Java 8的Lambda让我们可以更加专注于做什么(What),而不是怎么做(How),这点此前已经结合内部类进行 了对比说明.现在,我们仔细体会一下上例代码,可以发现: for循环的语法就是"怎么做" for循环的循环体才是"做什么" 传统集合遍历 import java.util.ArrayList;

  • 详解JAVA Stream流

    摘要 Stream 是对集合对象功能的增强,它专注于对集合对象进行各种非常便利.高效的聚合操作,或者大批量数据操作.通常我们需要多行代码才能完成的操作,借助于Stream流式处理可以很简单的实现. Stream 不是集合元素,它不是数据结构并不保存数据,它是有关算法和计算的. 创建Steam流 调用Collection.stream()函数创建一个Stream对象 Stream 接口的静态方法 of 可以获取数组对应的流 List<String> list = new ArrayList<

  • 一篇文章带你了解Java Stream流

    目录 一.Stream流引入 现有一个需求: 1.用常规方法解决需求 2.用Stream流操作集合,获取流,过滤操作,打印输出 二.Stream流的格式 三.获取流 四.Stream流的常用方法 方法演示: 1.count方法: 2.filter方法: 3.forEach方法 4.limit方法 5.map方法 6.skip方法 7.concat方法 五.收集Stream流 总结 一.Stream流引入 Lambda表达式,基于Lambda所带来的函数式编程,又引入了一个全新的Stream概念,

  • Java Stream流之求和的实现

    BigDecimal: BigDecimal bb =list.stream().map(Plan::getAmount).reduce(BigDecimal.ZERO,BigDecimal::add); int.double.long: double max = list.stream().mapToDouble(User::getHeight).sum(); 补充:java8-Stream流之数值函数(求和.最大值.最小值.平均值) 我就废话不多说了,大家还是直接看代码吧~ //todo s

  • Java Stream 流的使用过程解析

    1. 筛选和切片 用谓词筛选 filter方法接受一个返回boolean的方法. List<Dish> vegetarianMenu=menu.stream().filter(Dish::isVegetarian) .collect(toList()); distinct去重 distinct方法,根据流中元素的hashCode和equals方法.例: List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4); numbe

  • Java类加载器ClassLoader用法解析

    这篇文章主要介绍了Java类加载器ClassLoader用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 正文 当程序主动使用某个类时,如果该类还未被加载到内存中,则JVM会通过加载.连接.初始化3个步骤来对该类进行初始化.如果没有意外,JVM将会连续完成3个步骤,所以有时也把这个3个步骤统称为类加载或类初始化. 一.类加载过程 1.加载 加载指的是将类的class文件读入到内存,并为之创建一个java.lang.Class对象,也就是说

随机推荐