编程语言
首页 > 编程语言> > Java笔记第十三弹

Java笔记第十三弹

作者:互联网

函数式接口

有且仅有一个抽象方法的接口 适用于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){
        String s=getString(()->"刘某人");

        System.out.println(s);

        int m=getInteger(()->123);

        System.out.println(m);

    }
    private static Integer getInteger(Supplier<Integer> sup1){
        return sup1.get();
    }
         private static String getString(Supplier<String> sup){
        return sup.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){
operatorString("liumouren",s-> System.out.println(s));

operatorString("liumouren",System.out::println);

operatorTwoString("刘某人",s-> System.out.println(s),s-> System.out.println(new StringBuilder(s).reverse().toString()));
    }
    //定义一种方法,能够两种方法对不同的字符串进行操作
    private static void operatorTwoString(String name,Consumer<String>con1,Consumer<String>con2){
        con1.andThen(con2).accept(name);
    }
    private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }
}
案例:按要求打印
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.function.Predicate;

public class Main{
    public static void main(String[] args) {
        boolean b=checkString("helloworld",s-> s.length()>8);

        System.out.println(b);
    }
    private static boolean checkString(String s, Predicate<String> de){
        return de.test(s);
    }
}

//非的实现
import java.util.function.Predicate;

public class Main{
    public static void main(String[] args) {
        boolean b=checkString("helloworld",s-> s.length()>8);

        System.out.println(b);
    }
    private static boolean checkString(String s, Predicate<String> de){
        return !de.test(s);
        //return de.negate().test(s);
    }
}

//and方法
import java.util.function.Predicate;

public class Main{
    public static void main(String[] args) {
        boolean b1=checkString("helloworld",s-> s.length()>8);
        System.out.println(b1);

        boolean b2=checkString("hello",s->s.length()>8);
        System.out.println(b2);

        boolean b=checkTwoString("hello",s->s.length()>8,s->s.length()<10);
        System.out.println(b);

    }
    private static boolean checkTwoString(String s,Predicate<String> d1,Predicate<String> d2){
        return d1.and(d2).test(s);
    }
    private static boolean checkString(String s, Predicate<String> de){
        return de.test(s);
    }
}

//or方法
import java.util.function.Predicate;

public class Main{
    public static void main(String[] args) {
        boolean b1=checkString("helloworld",s-> s.length()>8);
        System.out.println(b1);

        boolean b2=checkString("hello",s->s.length()>8);
        System.out.println(b2);

        boolean b=checkTwoString("hello",s->s.length()>8,s->s.length()<10);
        System.out.println(b);

    }
    private static boolean checkTwoString(String s,Predicate<String> d1,Predicate<String> d2){
        return d1.or(d2).test(s);
    }
    private static boolean checkString(String s, Predicate<String> de){
        return de.test(s);
    }
}
案例:筛选满足条件数据
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) {
        get1("100",s-> Integer.parseInt(s));

        get2(100,m->String.valueOf(m+7));

        get3("564",s->Integer.parseInt(s),m->String.valueOf(m+100));
    }
    private static void get1(String s, Function<String,Integer> f){
        int i=f.apply(s);
        System.out.println(i);
    }

    private static void get2(int m,Function<Integer,String> f){
        String s=f.apply(m);
        System.out.println(s);
    }

    private static void get3(String s,Function<String ,Integer> f1,Function<Integer,String> f2){
        Integer m=f1.apply(s);
        String ss=f2.apply(m);
        System.out.println(ss);
        //简洁的方式
        String sss=f1.andThen(f2).apply(s);
        System.out.println(sss);
    }
}
案例:按照指定要求操作数据
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)生成流
相关应用:
        List<String> list=new ArrayList<String>();
        Stream<String> listStream=list.stream();
        
        Set<String> set=new HashSet<String>();
        Stream<String> setStream=set.stream();
        
        Map<String,Integer> map=new HashMap<String,Integer>();
        Stream<String> mapStream=map.keySet().stream();
        Stream<Integer> valuesStream=map.values().stream();
        Stream<Map.Entry<String,Integer>> entryStream=map.entrySet().stream();
        
        String[] strArray={"hello","world","java"};
        Stream<String> arrayStream=Stream.of(strArray);
        Stream<String> strArrayStream=Stream.of("hello","world","java");
        Stream<Integer> integerStream=Stream.of(10,20,30);
Stream流的常见中间操作方法
一、filter
Stream<T> filter(Prediate predicate)//用于对流中的数据进行过滤
相关应用:
import java.util.*;

public class Main{
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<String>();
        array.add("林青霞");
        array.add("张三丰");
        array.add("周芷若");
        array.add("赵敏");
        array.add("张无忌");
        array.stream().filter(s->s.startsWith("张")).forEach(System.out::println);

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

        array.stream().filter(s->s.length()==3).forEach(System.out::println);
        
        
    }

}
二、limit&skip
    Stream<T> limit(long maxSize)//返回此流中的元素组成的流,截取前指定参数个数的数据
    
    Stream<T> skip(long n)//跳过指定参数个数的数据,返回由该流的剩余元素组成的流
相关应用:
import java.util.*;

public class Main{
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<String>();
        array.add("林青霞");
        array.add("张三丰");
        array.add("周芷若");
        array.add("赵敏");
        array.add("张无忌");

        //控制前三个数据输出
        array.stream().limit(3).forEach(System.out::println);

        System.out.println("-----------------");
        //跳过n个元素输出剩余元素
        array.stream().skip(2).forEach(System.out::println);
    }
}
三、concat&distinct
concat//合并需求
    distinct//保证流元素不重复
相关应用:
import java.util.stream.Stream;
import java.util.*;

public class Main{
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<String>();
        array.add("林青霞");
        array.add("张三丰");
        array.add("周芷若");
        array.add("赵敏");
        array.add("张无忌");

        //取前n个数据组成一个流
        Stream<String> s1=array.stream().limit(4);

        //跳过n个数据组成一个流
        Stream<String> s2=array.stream().skip(2);

        //合并前两个需求
        Stream.concat(s1,s2).forEach(System.out::println);

        System.out.println("------------");
        //需求三的基础上保证不重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);

    }

}
四、sorted
Stream<T> sorted()//返回由此流的元素组成的流,根据自然顺序排序
    Stream<T> sorted(Comparator comparator)//返回由此流的元素组成的流,根据提供的Comparator进行排序
相关应用:
import java.util.*;

public class Main{
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<String>();
        array.add("linqingxia");
        array.add("zhangsanfeng");
        array.add("zhouzhiruo");
        array.add("zhaomin");
        array.add("zhangwuji");

        array.stream().sorted().forEach(System.out::println);

        System.out.println("--------------");
        
        array.stream().sorted((s1,s2)->{
            int num1=s1.length()-s2.length();
            int  num2=num1==0?s1.compareTo(s2):num1;
            return num2;
        }).forEach(System.out::println);
    }

}
五、map&mapToInt
<R>Stream<R> map(Function mapper)//返回由给定函数应用于此流的元素的结果组成的流
    
    IntStream mapToInt(ToIntFunction mapper)//返回一个IntStream其中包含将给定函数应用于此流的元素的结果
相关应用:
import java.util.*;

public class Main{
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<String>();
        array.add("10");
        array.add("20");
        array.add("30");
        array.add("40");
        array.add("50");

        array.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);

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

        array.stream().map(Integer::parseInt).forEach(System.out::println);

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

        array.stream().mapToInt(Integer::parseInt).forEach(System.out::println);

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

        //求和操作
        int sum=array.stream().mapToInt(Integer::parseInt).sum();
        System.out.println("和为:"+sum);
    }

}
Stream流的常见终结操作方法
void forEach(Consumer action)//对此流的每个元素执行操作
    long count()//返回此流中的元素数
相关应用:
import java.util.*;

public class Main{
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<String>();
        array.add("林青霞");
        array.add("张三丰");
        array.add("周芷若");
        array.add("赵敏");
        array.add("张无忌");

        array.stream().forEach(System.out::println);

        long count=array.stream().filter(s->s.startsWith("张")).count();
        System.out.println("个数为:"+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集合中
相关应用:
//List集合
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.*;

public class Main{
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");

        Stream<String> s1=list.stream().filter(s->s.length()==3);

        List<String> names=s1.collect(Collectors.toList());
        for(String s:names){
            System.out.println(s);
        }
    }

}

//Set集合
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.*;

public class Main{
    public static void main(String[] args) {
        Set<Integer> set=new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);
        set.add(50);

        Stream<Integer> setStream=set.stream().filter(s->s>30);

        Set<Integer> set1=setStream.collect(Collectors.toSet());

        for(Integer ii:set1){
            System.out.println(ii);
        }

    }

}

//字符串数组--Map集合
import java.util.stream.Collectors;
import java.util.*;
import java.util.stream.Stream;

public class Main{
    public static void main(String[] args) {
        String[] arr={"林青霞,30","张曼玉,35","王祖贤,33","柳岩,25"};
        Stream<String> s1=Stream.of(arr).filter(s->Integer.parseInt(s.split(",")[1])>28);
        
        Map<String,Integer> map=s1.collect(Collectors.toMap(s->s.split(",")[0],s->Integer.parseInt(s.split(",")[1])));
        
        Set<String> keySet=map.keySet();
        for(String key:keySet){
            Integer value=map.get(key);
            System.out.println(key+","+value);
        }
    }

}

类加载

类的初始化步骤

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

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

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

类的初始化时机:

创建类的实例

调用类的类方法

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

使用反射方式来强制创建某个类或者接口对应的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()//返回父类加载器进行委派
相关应用:
public class Main{
    public static void main(String[] args) {
        ClassLoader c=ClassLoader.getSystemClassLoader();
        System.out.println(c);//AppClassLoader

        ClassLoader c1=c.getParent();
        System.out.println(c1);//PlatformClassLoader

        ClassLoader c2=c1.getParent();
        System.out.println(c2);//null
    }

}

反射

获取Class类的对象
//3种方法
使用类的Class属性来获取该类对应的Class对象
    调用对象的 getClass()方法,返回该对象所属类对应的Class对象
    使用Class类中的静态方法forName(String className),该方法需要传入字符串参数,是完整包名的路径
相关应用:
public class Main{
    public static void main(String[] args) throws ClassNotFoundException {
        Class<Student> c1=Student.class;
        System.out.println(c1);

        Class<Student> c2=Student.class;
        System.out.println(c1==c2);
        System.out.println("---------------");

        Student s=new Student();
        Class<? extends Student> c3=s.getClass();
        System.out.println(c3==c1);

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

        Class<?> c=Class.forName("class Student");
        System.out.println(c==c1);
    }

}
反射获取构造方法并使用
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);

    }

}

模块化

步骤:

创建模块:

点击Project structure

命名模块,新建完成

2、创建一个描述性文件

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

模块导出格式:exports 包名

模块依赖格式:requires 模块名

Alt+Enter提示快捷键)

模块服务的使用

服务提供:provides

服务接口:use

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

标签:Java,第十三,System,笔记,add,println,out,public,String
来源: https://www.cnblogs.com/liuzijin/p/16593113.html