java 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),该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整的包名路径

来源：https://juejin.cn/post/7114557304619401229