函数式接口

有且仅有一个抽象方法的接口适用于Lambda使用的接口

@FunctionalInterface//表示函数式接口

函数式接口作为方法的参数

public class Main{
    public static void main(String[] args){
        startThread(new Runnable(){
            @Override
            public void run(){
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });
        
        startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));
    }
private static void startThread(Runnable r){
        //Thread t=new Thread(r);
        //t.start();
    new Thread(r).start();
}

}

函数式接口作为方法的返回值

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Main{
    public static void main(String[] args){
        //构造使用场景
        //定义集合，存储字符串元素
        ArrayList<String>array=new ArrayList<String>();

        array.add("hello");
        array.add("world");
        array.add("java");

        System.out.println("排序前，"+array);

        Collections.sort(array);

        System.out.println("排序后，"+array);

        Collections.sort(array,getcomparator());

        System.out.println("排序后，"+array);

         }


         private static Comparator<String> getcomparator() {
        //匿名内部类
             /*Comparator<String> comp = new Comparator<String>() {
                 @Override
                 public int compare(String s1, String s2) {
                     return s1.length() - s2.length();
                 }
             };
             return comp;*/

             /*return new Comparator<String>(){
                 @Override
                 public int compare(String s1,String s2){
                     return s1.length()-s2.length();
                 }
             };*/

             //Lambda表达式
             return ((String s1,String s2)->{
                 return s1.length()-s2.length();
             });
         }

}

常用的函数式接口

Supplier接口

Supplier<T>://包含一个无参方法--被称为生产接口
    T get();//获得结果--不需要参数

案例：获取最大值

import java.util.function.Supplier;

public class Main{
    public static void main(String[] args){
        int[] arr={19,45,67,9,23};
        int mm=getMax(()->
        {
            int max=arr[0];
            for(int i=0;i<arr.length;i++){
                if(arr[i]>=max){
                    max=arr[i];
                }
            }
            return max;
        });

        System.out.println("最大值为："+mm);

    }
    private static Integer getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

Consumer接口

void accept(T t);//对给定的参数执行此操作
default Consumer<T> andThen(Consumer after);//返回一个组合的Consumer，依次执行此操作，然后执行after操作

案例：按要求打印

import java.util.function.Consumer;

public class Main{
    public static void main(String[] args){
        String[] strArray={"刘某人,19","liumouren,20"};

        operator(strArray,(String str)->{
            String name=str.split(",")[0];
            System.out.print("姓名："+name);
        },(String str)->{
            int age=Integer.parseInt(str.split(",")[1]);
            System.out.println(" 年龄："+age);
        });
    }
    private static void operator(String[] strArray,Consumer<String>con1,Consumer<String>con2){
        for(String str:strArray){
            con1.andThen(con2).accept(str);
        }
    }

}

Predicate接口

//常用的四个方法
boolean test(T t);//Lambda判断，返回一个布尔值
default Predicate<T> negate();//返回一个逻辑的否定，对应逻辑非
default Predicate<T> and(Predicate other);//返回一个组合判断，对应短路与
default Predicate<T> or(Predicate other);//返回一个组合判断，对应短路或

案例：筛选满足条件数据

import java.util.ArrayList;
import java.util.function.Predicate;

public class Main{
    public static void main(String[] args) {

        String[] strArray={"liumoumou,19","liumouren,20"};

        ArrayList<String> array=get(strArray,s->s.split(",")[0].length()>2,
                s->Integer.parseInt(s.split(",")[1])<20);
        System.out.println(array);

    }
    private static ArrayList<String> get(String[] strArray,Predicate<String>pre1,Predicate<String>pre2){
        ArrayList<String> arr=new ArrayList<String>();
        for(String str:strArray){
            if(pre1.and(pre2).test(str)){
                arr.add(str);
            }
        }
        return arr;
    }
}

Function接口

//常用方法
R apply(T t);//将此函数应用于给定的参数
default<V> Function andThen(Function after);//返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

案例：按照指定要求操作数据

import java.util.function.Function;

public class Main{
    public static void main(String[] args) {
        String s="林青霞,30";
        get(s,(String ss)->{
            return s.split(",")[1];
        },(String sss)->{
            return Integer.parseInt(sss);
        },(Integer i)->{
            return i+70;
        });
    }
private static void get(String s,Function<String,String> f1,Function<String,Integer> f2,Function<Integer,Integer> f3){
        int i=f1.andThen(f2).andThen(f3).apply(s);
    System.out.println(i);
}
}

Stream流

//生成流
//--------通过数据源（集合、数组等）生成流
list.stream()
    
//中间操作
//过滤、映射等
    filter()
    
//终结操作
    forEach()

Stream流的常见生成方式

Collections体系的集合可以使用默认方法stream()生成流
    default Stream<E> stream()
    
    Map体系的集合间接的生成流
    
    数组可以通过Stream接口的静态方法 of(T...values)生成流

Stream流的常见中间操作方法

一、filter

Stream<T> filter(Prediate predicate)//用于对流中的数据进行过滤

二、limit&skip

    Stream<T> limit(long maxSize)//返回此流中的元素组成的流，截取前指定参数个数的数据
    
    Stream<T> skip(long n)//跳过指定参数个数的数据，返回由该流的剩余元素组成的流

三、concat&distinct

concat//合并需求
    distinct//保证流元素不重复

四、sorted

Stream<T> sorted()//返回由此流的元素组成的流，根据自然顺序排序
    Stream<T> sorted(Comparator comparator)//返回由此流的元素组成的流，根据提供的Comparator进行排序

五、map&mapToInt

<R>Stream<R> map(Function mapper)//返回由给定函数应用于此流的元素的结果组成的流
    
    IntStream mapToInt(ToIntFunction mapper)//返回一个IntStream其中包含将给定函数应用于此流的元素的结果

Stream流的常见终结操作方法

void forEach(Consumer action)//对此流的每个元素执行操作
    long count()//返回此流中的元素数

Stream流综合练习

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

public class Main{
    public static void main(String[] args) {
        ArrayList<String> arr1=new ArrayList<String>();
        ArrayList<String> arr2=new ArrayList<String>();
        arr1.add("周润发");
        arr1.add("成龙");
        arr1.add("刘德华");
        arr1.add("吴京");
        arr1.add("周星驰");
        arr1.add("李连杰");

        arr2.add("林心如");
        arr2.add("张曼玉");
        arr2.add("林青霞");
        arr2.add("柳岩");
        arr2.add("林志玲");
        arr2.add("王祖贤");

        Stream<String> manStream=arr1.stream().filter(s->s.length()==3).limit(3);

        System.out.println("---------------");

        Stream<String> womanStream=arr2.stream().filter(s->s.startsWith("林")).skip(1);

        System.out.println("---------------");
        
        Stream<String> s=Stream.concat(manStream,womanStream);

        System.out.println("---------------");
        
        //Queations
        s.map(Actor::new).forEach(p->System.out.println(p.getName()+" "+p.getAge()));
        
    }

}

//升级版
import java.util.stream.Stream;
import java.util.*;

public class Main{
    public static void main(String[] args) {
        ArrayList<String> arr1=new ArrayList<String>();
        ArrayList<String> arr2=new ArrayList<String>();
        arr1.add("周润发");
        arr1.add("成龙");
        arr1.add("刘德华");
        arr1.add("吴京");
        arr1.add("周星驰");
        arr1.add("李连杰");

        arr2.add("林心如");
        arr2.add("张曼玉");
        arr2.add("林青霞");
        arr2.add("柳岩");
        arr2.add("林志玲");
        arr2.add("王祖贤");

        Stream.concat(arr1.stream().filter(s->s.length()==3).limit(3),
                arr2.stream().filter(s->s.startsWith("张")).skip(1).map(Actor::new).
                        forEach(p->System.out.println(p.getName()+" "+p.getAge()));
        
    }

}

Stream流的收集操作

R collect(Collector collector)//一个collector接口
    工具类Collectors提供了具体的收集方式
    public static <T> Collector toList()//吧元素收集到List集合中
    public static <T> Collector toSet()//把元素收集到Set集合中
    public static Collector toMap(Function keyMapper,Function valueMapper)//把元素收集到Map集合中

类加载

类的初始化步骤

假如类还未被加载和连接，则程序先加载并连接该类

假如该类的直接父类还未被初始化，则先初始化其直接父类

假如类中有初始化语句，则系统依次进行这些初始化语句

类的初始化时机：

创建类的实例

调用类的类方法

访问类或者接口的类变量，或者为该类变量赋值

使用反射方式来强制创建某个类或者接口对应的java.lang.Class对象

初始化某个类的子类

直接使用java.exe命令来运行某个主类

类加载器

JVM的类加载机制

1、全盘负责

2、父类委托

3、缓存机制

ClassLoader//负责加载类的对象
    
    //内置类加载器
    Bootstrap class loader
        Platform class loader
            System class loader
    //System的父加载器为Platform Platform的父加载器为Bootstrap
                
                //两个方法
                static ClassLoader getSystemClassLoader()//返回用于委派的系统类加载器
                ClassLoader getParent()//返回父类加载器进行委派

反射

获取Class类的对象

//3种方法
使用类的Class属性来获取该类对应的Class对象
    调用对象的 getClass()方法，返回该对象所属类对应的Class对象
    使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，是完整包名的路径

反射获取构造方法并使用

import java.lang.reflect.Constructor;

public class Main{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class<?> c=Class.forName("class Student");
        Constructor<?>[] cons=c.getConstructors();
        //私有的、默认的
        //Constructor<?>[] cons=c.getDeclaredConstructors();
        for(Constructor con:cons){
            System.out.println(con);
        }
    }

}

案例1：获取学生类

import java.lang.reflect.Constructor;

public class Main{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<?> c=Class.forName("class Student");
        Constructor<?> con = c.getConstructor(String.class, int.class);
        
        Object obj=con.newInstance("林青霞",30);
        System.out.println(obj);
        
    }

}
//基本数据类型也可以通过.class得到对应的Class类型

案例2：获取学生类

import java.lang.reflect.Constructor;

public class Main{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<?> c=Class.forName("class Student");
        Constructor<?> con = c.getDeclaredConstructor(String.class);

        Object obj=con.newInstance("林青霞");
        con.setAccessible(true);
        
        System.out.println(obj);

    }

}
//访问私有
//public void setAccessible(boolean flag)//值为true，取消访问检查

反射获取成员变量并使用

    Field[] getFields()//返回所有公共成员变量对象的数组
    Field[] getDeclaredFields()//返回左右成员变量对象的数组
    Field getField(String name)//返回单个公共成员变量对象
    Field getDeclaredField(String name)//返回单个成员变量对象

案例3：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Field;

public class Main{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class<?> c=Class.forName("class Student");

        Constructor<?> con = c.getConstructor();
        Object obj=con.newInstance();
        System.out.println(obj);
        
        Field nameField=c.getDeclaredField("name");
        nameField.setAccessible(true);//取消访问检查--私有
        nameField.set(obj,"林青霞");
        System.out.println(obj);

        Field ageField=c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj,30);
        System.out.println(obj);
    }

}

反射获取成员方法并使用

    Method[] getMethods()//返回所有公共成员方法对象的数组，包括继承的
    Method[] getDeclaredMethods()//返回所有成员方法对象的数组，不包括继承的
    Method getMethod(String name,Class<?>...parameterTypes)//返回单个公共成员方法对象
    Method getDeclaredMethod(String name,Class<?>...parameterTypes)//返回单个成员方法对象

案例4：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class<?> c=Class.forName("class Student");

        Constructor<?> con = c.getConstructor();
        Object obj=con.newInstance();

        Method m1=c.getMethod("method1");
        m1.invoke(obj);

        //两个变量
        Method m2=c.getMethod("method2",String.class);
        m2.invoke(obj,"林青霞");

        //有返回值
        Method m3=c.getMethod("method3",String.class,int.class);
        Object o=m3.invoke(obj,"林青霞",30);
        System.out.println(o);

        Method m4=c.getDeclaredMethod("function");
        m4.setAccessible(true);
        m4.invoke(obj);
    }

}

案例5：越过泛型检查

import java.util.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        ArrayList<Integer> arr=new ArrayList<Integer>();

        Class<? extends ArrayList> c=arr.getClass();
        Method m=c.getMethod("add",Object.class);

        m.invoke(arr,"hello");
        m.invoke(arr,"world");
        m.invoke(arr,"java");

        System.out.println(arr);

    }

}

模块化

步骤：

创建模块：
Java笔记第十三弹
点击Project structure

命名模块，新建完成

2、创建一个描述性文件

模块中所有未导出的包都是私有的，不能在模块之外被访问

模块导出格式：exports 包名

模块依赖格式：requires 模块名

（Alt+Enter提示快捷键）

模块服务的使用

服务提供：provides

服务接口：use

ServiceLoader：一种加载服务器实现的工具

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/280943.html

Java笔记第十三弹

函数式接口

函数式接口作为方法的参数

函数式接口作为方法的返回值

常用的函数式接口

Supplier接口

相关应用：

案例：获取最大值

Consumer接口

相关应用：

案例：按要求打印

Predicate接口

相关应用：

案例：筛选满足条件数据

Function接口

相关应用：

案例：按照指定要求操作数据

Stream流

Stream流的常见生成方式

相关应用：

Stream流的常见中间操作方法

一、filter

相关应用：

二、limit&skip

相关应用：

三、concat&distinct

相关应用：

四、sorted

相关应用：

五、map&mapToInt

相关应用：

Stream流的常见终结操作方法

相关应用：

Stream流综合练习

Stream流的收集操作

相关应用：

类加载

类的初始化步骤

类的初始化时机：

类加载器

相关应用：

反射

获取Class类的对象

相关应用：

反射获取构造方法并使用

案例1：获取学生类

案例2：获取学生类

反射获取成员变量并使用

案例3：

反射获取成员方法并使用

案例4：

案例5：越过泛型检查

模块化

模块服务的使用

相关推荐

发表回复