张家港企业网站建设,营销单页模板网站,网站制作前景怎么样,网络投票程序659.每天一考
1.写出获取Class实例的三种常见方式
Class clazz1 String.class;
Class clazz2 person.getClass(); //sout(person); //xxx.yyy.zzz.Person...
Class clazz3 Class.forName(String classPath);//体现反射的动态性2.谈谈你对Class类的理解 Class实例对应着加载…659.每天一考
1.写出获取Class实例的三种常见方式
Class clazz1 String.class;
Class clazz2 person.getClass(); //sout(person); //xxx.yyy.zzz.Person...
Class clazz3 Class.forName(String classPath);//体现反射的动态性2.谈谈你对Class类的理解 Class实例对应着加载到内存中的一个运行时类。 3.创建Class对应运行时类的对象的通用方法代码实现。以及这样操作需要对应的运行时类构造器方面满足的要求。 Object obj clazz.newInstance();//创建了对应的运行时类的对象 1.必须有空参的构造器 2.权限修饰符的权限要够。通常设置为public 4.在工程或module的src下有名为”jdbc.properties”的配置文件文件内容为nameTom。如何在程序中通过代码获取Tom这个变量值。代码实现
5.如何调用方法show() 类声明如下 package com.atguigu.java; class User{ public void show(){ System.out.println(“我是一个中国人”); } }
User user (User)clazz.newInstance();
Method show clazz.getDeclaredMethod(show);
show.setAccessiable(true);
show.invoke(user);660.复习反射与Class 661.ClassLoader与反射的应用
662.代理模式与动态代理
代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上
之前为大家讲解过代理机制的操作属于静态代理特征是代理类和目标对象的类都是在编译期间确定下来不利于程序的扩展。同时每一个代理类只能为一个接口服务这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。
动态代理是指客户通过代理类来调用其它对象的方法并且是在程序运行时 根据需要动态创建目标类的代理对象。
动态代理使用场合: 调试 远程方法调用
动态代理相比于静态代理的优点 抽象角色中接口声明的所有方法都被转移到调用处理器一个集中的方法中 处理这样我们可以更加灵活和统一的处理众多的方法。
663.代理模式与动态代理
静态代理举例 特点代理类和被代理类在编译期间就确定下来了。
package com.atguigu.java;interface ClothFactory{//代理类和被代理类都需要实现ClothFactoryvoid produceCloth();
}//代理类
class ProxyClothFactory implements ClothFactory{private ClothFactory factory;//用被代理类对象进行实例化public ProxyClothFactory(ClothFactory factory){//初始化this.factory factory;}Overridepublic void produceCloth() {System.out.println(代理工厂做一些准备工作);factory.produceCloth();System.out.println(代理工厂做一些后续的收尾工作);}
}//被代理类
class NikeClothFactory implements ClothFactory{Overridepublic void produceCloth() {System.out.println(Nike工厂生产一批运动服);}
}public class StaticProxyTest {public static void main(String[] args) {//创建被代理类的对象ClothFactory nike new NikeClothFactory();//创建代理类的对象ClothFactory proxyClothFactory new ProxyClothFactory(nike);proxyClothFactory.produceCloth();}
}664.代理模式举例
动态代理的举例
package com.atguigu.java;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;interface Human{String getBelief();void eat(String food);
}//被代理类
class SuperMan implements Human{Overridepublic String getBelief() {return I believe I can fly!;}Overridepublic void eat(String food) {System.out.println(我喜欢吃 food);}
}class HumanUtil{public void method1(){System.out.println(通用方法一);}public void method2(){System.out.println(通用方法二);}
}/*
要想实现动态代理需要解决的问题
问题一如何根据加载到内存中的被代理类动态的创建一个代理类及其对象。
问题二当通过代理类的对象调用方法a时如何动态的去调用被代理类中的同名方法a。*/class ProxyFactory{//调用此方法返回一个代理类的对象。解决问题一public static Object getProxyInstance(Object obj){//obj:被代理类的对象MyInvocationHandler handler new MyInvocationHandler();handler.bind(obj);return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);//类的加载器接口}
}class MyInvocationHandler implements InvocationHandler{private Object obj;//需要使用被代理类的对象进行赋值public void bind(Object obj){this.obj obj;}//当我们通过代理类的对象调用方法a时就会自动的调用如下的方法invoke()//将被代理类要执行的方法a的功能就声明在invoke()中Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {HumanUtil util new HumanUtil();util.method1();//method:即为代理类对象调用的方法此方法也就作为了被代理类对象要调用的方法//obj:被代理类的对象Object returnValue method.invoke(obj,args);util.method2();//上述方法的返回值就作为当前类中的invoke()的返回值。return returnValue;}
}public class ProxyTest {public static void main(String[] args) {SuperMan superMan new SuperMan();//proxyInstance:代理类的对象Human proxyInstance (Human) ProxyFactory.getProxyInstance(superMan);//当通过代理类对象调用方法时会自动的调用被代理类中同名的方法String belief proxyInstance.getBelief();System.out.println(belief);proxyInstance.eat(四川麻辣烫);System.out.println(*****************************);NikeClothFactory nikeClothFactory new NikeClothFactory();ClothFactory proxyClothFactory (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);proxyClothFactory.produceCloth();}
}665.AOP与动态代理的举例
前面介绍的Proxy和InvocationHandler很难看出这种动态代理的优势下面介绍一种更实用的动态代理机制 使用Proxy生成一个动态代理时往往并不会凭空产生一个动态代理这样没有 太大的意义。通常都是为指定的目标对象生成动态代理
这种动态代理在AOP中被称为AOP代理AOP代理可代替目标对象AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异 AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理
package com.atguigu.java;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;//动态代理的举例
interface Human{String getBelief();void eat(String food);}
//被代理类
class SuperMan implements Human{Overridepublic String getBelief() {return I believe I can fly!;}Overridepublic void eat(String food) {System.out.println(我喜欢吃 food);}
}class HumanUtil{public void method1(){System.out.println(通用方法一);}public void method2(){System.out.println(通用方法二);}}/*
要想实现动态代理需要解决的问题
问题一如何根据加载到内存中的被代理类动态的创建一个代理类及其对象。
问题二当通过代理类的对象调用方法a时如何动态的去调用被代理类中的同名方法a。*/class ProxyFactory{//调用此方法返回一个代理类的对象。解决问题一public static Object getProxyInstance(Object obj){//obj:被代理类的对象MyInvocationHandler handler new MyInvocationHandler();handler.bind(obj);return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);}}class MyInvocationHandler implements InvocationHandler{private Object obj;//需要使用被代理类的对象进行赋值public void bind(Object obj){this.obj obj;}//当我们通过代理类的对象调用方法a时就会自动的调用如下的方法invoke()//将被代理类要执行的方法a的功能就声明在invoke()中Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {HumanUtil util new HumanUtil();util.method1();//method:即为代理类对象调用的方法此方法也就作为了被代理类对象要调用的方法//obj:被代理类的对象Object returnValue method.invoke(obj,args);util.method2();//上述方法的返回值就作为当前类中的invoke()的返回值。return returnValue;}
}public class ProxyTest {public static void main(String[] args) {SuperMan superMan new SuperMan();//proxyInstance:代理类的对象Human proxyInstance (Human) ProxyFactory.getProxyInstance(superMan);//当通过代理类对象调用方法时会自动的调用被代理类中同名的方法String belief proxyInstance.getBelief();System.out.println(belief);proxyInstance.eat(四川麻辣烫);System.out.println(*****************************);NikeClothFactory nikeClothFactory new NikeClothFactory();ClothFactory proxyClothFactory (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);proxyClothFactory.produceCloth();}
}666.Java8新特性内容概述 667.Java8新特性的好处
Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Java 8 是oracle公司于2014年3月发布可以看成是自Java 5 以 来最具革命性的版本。Java 8为Java语言、编译器、类库、开发 工具与JVM带来了大量新特性。
Java 8新特性简介 速度更快 代码更少(增加了新的语法Lambda 表达式) 强大的 Stream API 便于并行 最大化减少空指针异常Optional Nashorn引擎允许在JVM上运行JS应用
并行流与串行流 并行流就是把一个内容分成多个数据块并用不同的线程分别处理每个数据块的流。相比较串行的流并行的流可以很大程度上提高程序的执行效率。
Java 8 中将并行进行了优化我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流 之间进行切换。
668.Lambda表达式使用举例
Lambda 是一个匿名函数我们可以把 Lambda 表达式理解为是一段可以传递的代码将代码像数据一样进行传递。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格使Java的语言表达能力得到了提升。 import org.junit.Test;
import java.util.Comparator;//Lambda表达式的使用举例
public class LambdaTest {Testpublic void test1(){Runnable r1 new Runnable() {Overridepublic void run() {System.out.println(我爱北京天安门);}};r1.run();System.out.println(***********************);Runnable r2 () - System.out.println(我爱北京故宫);r2.run();}Testpublic void test2(){ComparatorInteger com1 new ComparatorInteger() {Overridepublic int compare(Integer o1, Integer o2) {return Integer.compare(o1,o2);}};int compare1 com1.compare(12,21);System.out.println(compare1);System.out.println(***********************);//Lambda表达式的写法ComparatorInteger com2 (o1,o2) - Integer.compare(o1,o2);int compare2 com2.compare(32,21);//Lambda表达式System.out.println(compare2);System.out.println(***********************);//方法引用ComparatorInteger com3 Integer :: compare;int compare3 com3.compare(32,21);System.out.println(compare3);}
}669.Lambda表达式语法的使用1
import org.junit.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;/*** Lambda表达式的使用** 1.举例 (o1,o2) - Integer.compare(o1,o2);* 2.格式* - :lambda操作符 或 箭头操作符* -左边lambda形参列表 其实就是接口中的抽象方法的形参列表* -右边lambda体 其实就是重写的抽象方法的方法体** 3. Lambda表达式的使用分为6种情况介绍** 总结* -左边lambda形参列表的参数类型可以省略(类型推断)如果lambda形参列表只有一个参数其一对()也可以省略* -右边lambda体应该使用一对{}包裹如果lambda体只有一条执行语句可能是return语句省略这一对{}和return关键字** 4.Lambda表达式的本质作为函数式接口的实例** 5. 如果一个接口中只声明了一个抽象方法则此接口就称为函数式接口。我们可以在一个接口上使用 FunctionalInterface 注解* 这样做可以检查它是否是一个函数式接口。** 6. 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。*/
public class LambdaTest1 {//语法格式一无参无返回值Testpublic void test1(){Runnable r1 new Runnable() {Overridepublic void run() {System.out.println(我爱北京天安门);}};r1.run();System.out.println(***********************);Runnable r2 () - {System.out.println(我爱北京故宫);};r2.run();}//语法格式二Lambda 需要一个参数但是没有返回值。Testpublic void test2(){ConsumerString con new ConsumerString() {Overridepublic void accept(String s) {System.out.println(s);}};con.accept(谎言和誓言的区别是什么);System.out.println(*******************);ConsumerString con1 (String s) - {System.out.println(s);};con1.accept(一个是听得人当真了一个是说的人当真了);}//语法格式三数据类型可以省略因为可由编译器推断得出称为“类型推断”Testpublic void test3(){ConsumerString con1 (String s) - {System.out.println(s);};con1.accept(一个是听得人当真了一个是说的人当真了);System.out.println(*******************);ConsumerString con2 (s) - {System.out.println(s);};con2.accept(一个是听得人当真了一个是说的人当真了);}Testpublic void test4(){ArrayListString list new ArrayList();//类型推断int[] arr {1,2,3};//类型推断}//语法格式四Lambda 若只需要一个参数时参数的小括号可以省略Testpublic void test5(){ConsumerString con1 (s) - {System.out.println(s);};con1.accept(一个是听得人当真了一个是说的人当真了);System.out.println(*******************);ConsumerString con2 s - {System.out.println(s);};con2.accept(一个是听得人当真了一个是说的人当真了);}//语法格式五Lambda 需要两个或以上的参数多条执行语句并且可以有返回值Testpublic void test6(){ComparatorInteger com1 new ComparatorInteger() {Overridepublic int compare(Integer o1, Integer o2) {System.out.println(o1);System.out.println(o2);return o1.compareTo(o2);}};System.out.println(com1.compare(12,21));System.out.println(*****************************);ComparatorInteger com2 (o1,o2) - {System.out.println(o1);System.out.println(o2);return o1.compareTo(o2);};System.out.println(com2.compare(12,6));}//语法格式六当 Lambda 体只有一条语句时return 与大括号若有都可以省略Testpublic void test7(){ComparatorInteger com1 (o1,o2) - {return o1.compareTo(o2);};System.out.println(com1.compare(12,6));System.out.println(*****************************);ComparatorInteger com2 (o1,o2) - o1.compareTo(o2);System.out.println(com2.compare(12,21));}Testpublic void test8(){ConsumerString con1 s - {System.out.println(s);};con1.accept(一个是听得人当真了一个是说的人当真了);System.out.println(*****************************);ConsumerString con2 s - System.out.println(s);con2.accept(一个是听得人当真了一个是说的人当真了);}
}670.Lambda表达式语法的使用2
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;/*** java内置的4大核心函数式接口** 消费型接口 ConsumerT void accept(T t)* 供给型接口 SupplierT T get()* 函数型接口 FunctionT,R R apply(T t)* 断定型接口 PredicateT boolean test(T t)*/
public class LambdaTest2 {Testpublic void test1(){happyTime(500, new ConsumerDouble() {Overridepublic void accept(Double aDouble) {System.out.println(学习太累了去天上人间买了瓶矿泉水价格为 aDouble);}});System.out.println(********************);happyTime(400,money - System.out.println(学习太累了去天上人间喝了口水价格为 money));}public void happyTime(double money, ConsumerDouble con){con.accept(money);}Testpublic void test2(){ListString list Arrays.asList(北京,南京,天津,东京,西京,普京);ListString filterStrs filterString(list, new PredicateString() {Overridepublic boolean test(String s) {return s.contains(京);}});System.out.println(filterStrs);ListString filterStrs1 filterString(list,s - s.contains(京));System.out.println(filterStrs1);}//根据给定的规则过滤集合中的字符串。此规则由Predicate的方法决定public ListString filterString(ListString list, PredicateString pre){ArrayListString filterList new ArrayList();for(String s : list){if(pre.test(s)){filterList.add(s);}}return filterList;}
}671.函数式接口的介绍
只包含一个抽象方法的接口称为函数式接口。
你可以通过 Lambda 表达式来创建该接口的对象。若 Lambda 表达式 抛出一个受检异常(即非运行时异常)那么该异常需要在目标接口的抽 象方法上进行声明。
我们可以在一个接口上使用 FunctionalInterface 注解这样做可以检 查它是否是一个函数式接口。同时 javadoc 也会包含一条声明说明这个接口是一个函数式接口。
在java.util.function包下定义了Java 8 的丰富的函数式接口
如何理解函数式接口
Java从诞生日起就是一直倡导“一切皆对象”在Java里面面向对象(OOP) 编程是一切。但是随着python、scala等语言的兴起和新技术的挑战Java不 得不做出调整以便支持更加广泛的技术要求也即java不但可以支持OOP还 可以支持OOF面向函数编程在函数式编程语言当中函数被当做一等公民对待。在将函数作为一等公民的 编程语言中Lambda表达式的类型是函数。但是在Java8中有所不同。在 Java8中Lambda表达式是对象而不是函数它们必须依附于一类特别的 对象类型——函数式接口。简单的说在Java8中Lambda表达式就是一个函数式接口的实例。这就是 Lambda表达式和函数式接口的关系。也就是说只要一个对象是函数式接口 的实例那么该对象就可以用Lambda表达式来表示。所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。
672.Java内置的函数式接口介绍及使用举例
//自定义函数式接口FunctionalInterface
public interface MyInterface {void method1();// void method2();
}673.方法引用的使用情况1
674.方法引用的使用情况2
675.方法引用的使用情况3
676.构造器引用与项目引用的使用
677.Stream API的概述
Java8中有两大最为重要的改变。第一个是 Lambda 表达式另外一个则是 Stream API。
Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这 是目前为止对Java类库最好的补充因为Stream API可以极大提供Java程 序员的生产力让程序员写出高效率、干净、简洁的代码。
Stream 是 Java8 中处理集合的关键抽象概念它可以指定你希望对集合进 行的操作可以执行非常复杂的查找、过滤和映射数据等操作。 使用 Stream API 对集合数据进行操作就类似于使用 SQL 执行的数据库查询。 也可以使用 Stream API 来并行执行操作。简言之Stream API 提供了一种 \高效且易于使用的处理数据的方式。
为什么要使用Stream API 实际开发中项目中多数数据源都来自于MysqlOracle等。但现在数 据源可以更多了有MongDBRadis等而这些NoSQL的数据就需要 Java层面去处理 Stream 和 Collection 集合的区别Collection 是一种静态的内存数据结构而 Stream 是有关计算的。前者是主要面向内存存储在内存中后者主要是面向 CPU通过 CPU 实现计算。
什么是 Stream Stream到底是什么呢 是数据渠道用于操作数据源集合、数组等所生成的元素序列。 “集合讲的是数据Stream讲的是计算”
注意 ①Stream 自己不会存储元素。 ②Stream 不会改变源对象。相反他们会返回一个持有结果的新Stream。 ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
678.Stream的实例化
创建 Stream方式一通过集合 Java8 中的 Collection 接口被扩展提供了两个获取流 的方法 default Stream stream() : 返回一个顺序流 default Stream parallelStream() : 返回一个并行流
创建 Stream方式二通过数组 Java8 中的 Arrays 的静态方法 stream() 可以获取数组流 static Stream stream(T[] array): 返回一个流 重载形式能够处理对应基本类型的数组 public static IntStream stream(int[] array) public static LongStream stream(long[] array) public static DoubleStream stream(double[] array)
创建 Stream方式三通过Stream的of() 可以调用Stream类静态方法 of(), 通过显示值创建一个 流。它可以接收任意数量的参数。 public static Stream of(T… values) : 返回一个流
创建 Stream方式四创建无限流 可以使用静态方法 Stream.iterate() 和 Stream.generate(),创建无限流。 迭代 public static Stream iterate(final T seed, final UnaryOperator f) 生成 public static Stream generate(Supplier s)
package com.atguigu.java2;
import java.util.ArrayList;
import java.util.List;
//提供用于测试的数据
public class EmployeeData {public static ListEmployee getEmployees(){ListEmployee list new ArrayList(); list.add(new Employee(1001, 马化腾, 34, 6000.38));list.add(new Employee(1002, 马云, 12, 9876.12));list.add(new Employee(1003, 刘强东, 33, 3000.82));list.add(new Employee(1004, 雷军, 26, 7657.37));list.add(new Employee(1005, 李彦宏, 65, 5555.32));list.add(new Employee(1006, 比尔盖茨, 42, 9500.43));list.add(new Employee(1007, 任正非, 26, 4333.32));list.add(new Employee(1008, 扎克伯格, 35, 2500.32)); return list;}
}import com.atguigu.java2.Employee;
import com.atguigu.java2.EmployeeData;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;/*** 1. Stream关注的是对数据的运算与CPU打交道* 集合关注的是数据的存储与内存打交道** 2.* ①Stream 自己不会存储元素。* ②Stream 不会改变源对象。相反他们会返回一个持有结果的新Stream。* ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行** 3.Stream 执行流程* ① Stream的实例化* ② 一系列的中间操作过滤、映射、...)* ③ 终止操作** 4.说明* 4.1 一个中间操作链对数据源的数据进行处理* 4.2 一旦执行终止操作就执行中间操作链并产生结果。之后不会再被使用** 测试Stream的实例化*/
public class StreamAPITest {//创建 Stream方式一通过集合Testpublic void test1(){ListEmployee employees EmployeeData.getEmployees();//得到EmployeeData集合// default StreamE stream() : 返回一个顺序流拿数据按照集合中的顺序来StreamEmployee stream employees.stream();// default StreamE parallelStream() : 返回一个并行流几个线程同时去集合中取数据不保证顺序StreamEmployee parallelStream employees.parallelStream();}//创建 Stream方式二通过数组Testpublic void test2(){int[] arr new int[]{1,2,3,4,5,6};//调用Arrays类的static T StreamT stream(T[] array): 返回一个流IntStream stream Arrays.stream(arr);Employee e1 new Employee(1001,Tom);Employee e2 new Employee(1002,Jerry);Employee[] arr1 new Employee[]{e1,e2};StreamEmployee stream1 Arrays.stream(arr1);}//创建 Stream方式三通过Stream的of()Testpublic void test3(){StreamInteger stream Stream.of(1, 2, 3, 4, 5, 6);}//创建 Stream方式四创建无限流Testpublic void test4(){// 迭代
// public staticT StreamT iterate(final T seed, final UnaryOperatorT f)//遍历前10个偶数Stream.iterate(0, t - t 2).limit(10).forEach(System.out::println);// 生成
// public staticT StreamT generate(SupplierT s)Stream.generate(Math::random).limit(10).forEach(System.out::println);}
}679.Stream的中间操作筛选与切片
多个中间操作可以连接起来形成一个流水线除非流水线上触发终止操作否则中间操作不会执行任何的处理而在终止操作时一次性全 部处理称为“惰性求值”。
package com.atguigu.java3;
import com.atguigu.java2.Employee;
import com.atguigu.java2.EmployeeData;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;//测试Stream的中间操作
public class StreamAPITest1 {//1-筛选与切片Testpublic void test1(){ListEmployee list EmployeeData.getEmployees();//filter(Predicate p)——接收 Lambda 从流中排除某些元素。StreamEmployee stream list.stream();//先创建顺序流//练习查询员工表中薪资大于7000的员工信息stream.filter(e - e.getSalary() 7000).forEach(System.out::println);//e为EmployeeforEach终止操作//limit(n)——截断流使其元素不超过给定数量。list.stream().limit(3).forEach(System.out::println);//list.stream()生成新的顺序流Stream每次执行终止操作之后需要重新创建 //skip(n) —— 跳过元素返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个则返回一个空流。与 limit(n) 互补list.stream().skip(3).forEach(System.out::println);//distinct()——筛选通过流所生成元素的 hashCode() 和 equals() 去除重复元素list.add(new Employee(1010,刘强东,40,8000));//list里面加一些重复数据list.add(new Employee(1010,刘强东,41,8000));list.add(new Employee(1010,刘强东,40,8000));list.add(new Employee(1010,刘强东,40,8000));list.add(new Employee(1010,刘强东,40,8000));//System.out.println(list);list.stream().distinct().forEach(System.out::println);}
}680.Stream的中间操作映射 //映射Testpublic void test2(){//map(Function f)——接收一个函数作为参数将元素转换成其他形式或提取信息该函数会被应用到每个元素上并将其映射成一个新的元素。ListString list Arrays.asList(aa, bb, cc, dd);list.stream().map(str - str.toUpperCase()).forEach(System.out::println);//返回toUpperCase大写的//练习1获取员工姓名长度大于3的员工姓名。ListEmployee employees EmployeeData.getEmployees();StreamString namesStream employees.stream().map(Employee::getName);//调用Employee的getName方法得到员工的名字namesStream.filter(name - name.length() 3).forEach(System.out::println);System.out.println();//练习2StreamStreamCharacter streamStream list.stream().map(StreamAPITest1::fromStringToStream);streamStream.forEach(s -{s.forEach(System.out::println);});System.out.println();//flatMap(Function f)——接收一个函数作为参数将流中的每个值都换成另一个流然后把所有流连接成一个流。StreamCharacter characterStream list.stream().flatMap(StreamAPITest1::fromStringToStream);characterStream.forEach(System.out::println);}//将字符串中的多个字符构成的集合转换为对应的Stream的实例public static StreamCharacter fromStringToStream(String str){//aaArrayListCharacter list new ArrayList();for(Character c : str.toCharArray()){list.add(c);}return list.stream();}Testpublic void test3(){ArrayList list1 new ArrayList();list1.add(1);list1.add(2);list1.add(3);ArrayList list2 new ArrayList();list2.add(4);list2.add(5);list2.add(6);//list1.add(list2);list1.addAll(list2);//addAll先取出来list2中的数据依次添加到list1得到的list1为6个元素System.out.println(list1);}681.Stream的中间操作排序 //3-排序Testpublic void test4(){
// sorted()——自然排序ListInteger list Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);list.stream().sorted().forEach(System.out::println);//抛异常原因:Employee没有实现Comparable接口
// ListEmployee employees EmployeeData.getEmployees();
// employees.stream().sorted().forEach(System.out::println);// sorted(Comparator com)——定制排序ListEmployee employees EmployeeData.getEmployees();employees.stream().sorted( (e1,e2) - {int ageValue Integer.compare(e1.getAge(),e2.getAge());if(ageValue ! 0){return ageValue;}else{return -Double.compare(e1.getSalary(),e2.getSalary());}}).forEach(System.out::println);}682.Stream的终止操作匹配与查找
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值例 如List、Integer甚至是 void 。 流进行了终止操作后不能再次使用。
package com.atguigu.java3;
import com.atguigu.java2.Employee;
import com.atguigu.java2.EmployeeData;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;//测试Stream的终止操作
public class StreamAPITest2 {//1-匹配与查找Testpublic void test1(){ListEmployee employees EmployeeData.getEmployees();// allMatch(Predicate p)——检查是否匹配所有元素。
// 练习是否所有的员工的年龄都大于18boolean allMatch employees.stream().allMatch(e - e.getAge() 18);System.out.println(allMatch);// anyMatch(Predicate p)——检查是否至少匹配一个元素。
// 练习是否存在员工的工资大于 10000boolean anyMatch employees.stream().anyMatch(e - e.getSalary() 10000);System.out.println(anyMatch);// noneMatch(Predicate p)——检查是否没有匹配的元素。
// 练习是否存在员工姓“雷”boolean noneMatch employees.stream().noneMatch(e - e.getName().startsWith(雷));//startsWith以这个开头的System.out.println(noneMatch);// findFirst——返回第一个元素OptionalEmployee employee employees.stream().findFirst();System.out.println(employee);// findAny——返回当前流中的任意元素OptionalEmployee employee1 employees.parallelStream().findAny();System.out.println(employee1);}Testpublic void test2(){ListEmployee employees EmployeeData.getEmployees();// count——返回流中元素的总个数long count employees.stream().filter(e - e.getSalary() 5000).count();System.out.println(count);
// max(Comparator c)——返回流中最大值
// 练习返回最高的工资StreamDouble salaryStream employees.stream().map(e - e.getSalary());OptionalDouble maxSalary salaryStream.max(Double::compare);System.out.println(maxSalary);
// min(Comparator c)——返回流中最小值
// 练习返回最低工资的员工OptionalEmployee employee employees.stream().min((e1, e2) - Double.compare(e1.getSalary(), e2.getSalary()));System.out.println(employee);System.out.println();
// forEach(Consumer c)——内部迭代employees.stream().forEach(System.out::println);//使用集合的遍历操作employees.forEach(System.out::println);}
}683.Stream的终止操作归约 //2-归约Testpublic void test3(){//reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来得到一个值。返回 T//练习1计算1-10的自然数的和ListInteger list Arrays.asList(1,2,3,4,5,6,7,8,9,10);Integer sum list.stream().reduce(0, Integer::sum);//参数1为初始值设置为0System.out.println(sum);//reduce(BinaryOperator) ——可以将流中元素反复结合起来得到一个值。返回 OptionalT//练习2计算公司所有员工工资的总和ListEmployee employees EmployeeData.getEmployees();StreamDouble salaryStream employees.stream().map(Employee::getSalary);//OptionalDouble sumMoney salaryStream.reduce(Double::sum);OptionalDouble sumMoney salaryStream.reduce((d1,d2) - d1 d2);System.out.println(sumMoney.get());}684.Stream的终止操作收集 //3-收集Testpublic void test4(){//collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现用于给Stream中元素做汇总的方法//练习1查找工资大于6000的员工结果返回为一个List或SetListEmployee employees EmployeeData.getEmployees();ListEmployee employeeList employees.stream().filter(e - e.getSalary() 6000).collect(Collectors.toList());employeeList.forEach(System.out::println);System.out.println();SetEmployee employeeSet employees.stream().filter(e - e.getSalary() 6000).collect(Collectors.toSet());employeeSet.forEach(System.out::println);}685.Optional类的介绍
到目前为止臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。 以前为了解决空指针异常Google公司著名的Guava项目引入了Optional类 Guava通过使用检查空值的方式来防止代码污染它鼓励程序员写更干净的代 码。受到Google Guava的启发Optional类已经成为Java 8类库的一部分。
Optional 类(java.util.Optional) 是一个容器类它可以保存类型T的值代表 这个值存在。或者仅仅保存null表示这个值不存在。原来用 null 表示一个值不 存在现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
Optional类的Javadoc描述如下这是一个可以为null的容器对象。如果值存在 则isPresent()方法会返回true调用get()方法会返回该对象。
Optional提供很多有用的方法这样我们就不用显式进行空值检测。
创建Optional类对象的方法 Optional.of(T t) : 创建一个 Optional 实例t必须非空 Optional.empty() : 创建一个空的 Optional 实例 Optional.ofNullable(T t)t可以为null 判断Optional容器中是否包含对象 boolean isPresent() : 判断是否包含对象 void ifPresent(Consumer? super T consumer) 如果有值就执行Consumer 接口的实现代码并且该值会作为参数传给它。 获取Optional容器的对象 T get(): 如果调用对象包含值返回该值否则抛异常 T orElse(T other) 如果有值则将其返回否则返回指定的other对象。 T orElseGet(Supplier? extends T other) 如果有值则将其返回否则返回由Supplier接口实现提供的对象。 T orElseThrow(Supplier? extends X exceptionSupplier) 如果有值则将其返 回否则抛出由Supplier接口实现提供的异常。
package com.atguigu.java4;
import org.junit.Test;
import java.util.Optional;/*** Optional类为了在程序中避免出现空指针异常而创建的。** 常用的方法ofNullable(T t)* orElse(T t)*/
public class OptionalTest {/*
Optional.of(T t) : 创建一个 Optional 实例t必须非空
Optional.empty() : 创建一个空的 Optional 实例
Optional.ofNullable(T t)t可以为null*/Testpublic void test1(){Girl girl new Girl();
// girl null;//of(T t):保证t是非空的OptionalGirl optionalGirl Optional.of(girl);}Testpublic void test2(){Girl girl new Girl();
// girl null;//ofNullable(T t)t可以为nullOptionalGirl optionalGirl Optional.ofNullable(girl);System.out.println(optionalGirl);//orElse(T t1):如果单前的Optional内部封装的t是非空的则返回内部的t.//如果内部的t是空的则返回orElse()方法中的参数t1.Girl girl1 optionalGirl.orElse(new Girl(赵丽颖));System.out.println(girl1);}
}686.Optional类的使用举例 public String getGirlName(Boy boy){return boy.getGirl().getName();}Testpublic void test3(){Boy boy new Boy();boy null;String girlName getGirlName(boy);System.out.println(girlName);}//优化以后的getGirlName():public String getGirlName1(Boy boy){//传统写法if(boy ! null){Girl girl boy.getGirl();if(girl ! null){return girl.getName();}}return null;}Testpublic void test4(){Boy boy new Boy();boy null;String girlName getGirlName1(boy);System.out.println(girlName);}//使用Optional类的getGirlName():public String getGirlName2(Boy boy){OptionalBoy boyOptional Optional.ofNullable(boy);//此时的boy1一定非空Boy boy1 boyOptional.orElse(new Boy(new Girl(迪丽热巴)));Girl girl boy1.getGirl();OptionalGirl girlOptional Optional.ofNullable(girl);//girl1一定非空Girl girl1 girlOptional.orElse(new Girl(古力娜扎));return girl1.getName();}Testpublic void test5(){Boy boy null;boy new Boy();boy new Boy(new Girl(张老师));String girlName getGirlName2(boy);System.out.println(girlName);}
