当前位置：移动技术网 > IT编程>开发语言>Java > java基础学习笔记

java基础学习笔记

2020年07月07日 | 移动技术网IT编程 | 我要评论

Lambda表达式

要求接口中只有一个抽象方法。

匿名内部类连抽象类都可以的。

public class EatableDemo {
    public static void main(String[] args) {
        Eatable eatStac = new EatStac();//实现接口
        useEatable(eatStac);
        
        //匿名内部类（实际工作不推荐使用）
         useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println(120);
            }
        });
        
        //lambda表达式
       useEatable(()->{
           System.out.println(120);
       });
        
    }
    private  static void useEatable(Eatable e){
        e.eat();
    }
}
//无参

//有参
public class FlyableDemo {
    public static void main(String[] args) {
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("坠毁");
            }
        });

        //lambda
        useFlyable((String s)->{
            System.out.println(s);
            System.out.println("坠毁");
        });
    }
    private  static void useFlyable(Flyable f){
        f.fly("起飞。");
    }
}

public class AddableDemo {
    public static void main(String[] args) {
        useAddable((int x,int y)->{
            return  x+y;
        });
    }
    private staticvoid useAddable(Addable a){
        int sum=a.add(4,5);
        System.out.println(sum);
    }
}

lambda作为返回值

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

        ArrayList<String> list = new ArrayList<>();
        list.add("1234");
        list.add("12345");
        list.add("123");
        list.add("1");
        System.out.println(list);
        Collections.sort(list,getComparator());
        System.out.println(list);
    }
    private static Comparator<String> getComparator(){
        //三次简化。
//        Comparator<String> stringComparator = new Comparator<String>(){
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        };
//        return stringComparator;
        
        
//        return new Comparator<String>(){
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        };

        
       // return (String s1,String s2)->{
       //     return s1.length()-s2.length();
       // };
        
         return (s1,s2)-> s1.length()-s2.length();
    }
}

predicate 接口

Interface Predicate< T>

Functional Interface:

这是一个功能界面，因此可以用作lambda表达式或方法引用的赋值对象

所有方法：test,or,and,isEqual , negate（逻辑非）

通常用于判断参数是否满足特定的条件。

public class InterDemo {
    public static void main(String[] args) {
        boolean b = getComparator("123", (s) -> {
            return s.length() >= 5;
        });
        boolean b1 = getComparator("123456", (s) -> {
            return s.length() >= 5;
        });
        System.out.println(b);
        System.out.println(b1);

    }
    private static boolean getComparator(String s, Predicate<String> predicate){
        return predicate.test(s);
        //return predicate.negate().test(s);
    }
}

public class InterDemo {
    public static void main(String[] args) {
        boolean b1 = getComparator("13588", s -> {
            return s.length() > 2;
        }, s -> {
            return s.startsWith("1");
        });
        
        
        boolean b2= getComparator("23588", s -> {
            return s.length() > 2;
        }, s -> {
            return s.startsWith("1");
        });
        
        
        System.out.println(b1);//ture
        System.out.println(b2);//false

    }
    private static boolean getComparator(String s, Predicate<String> predicate,Predicate<String> pr2)	{
        return predicate.and(pr2).test(s);
    }
}

实例

public class InterDemo {
    public static void main(String[] args) {
        String[] strArray={"林青霞,30","柳岩,34","张曼玉,35","貂蝉,31","王祖贤,33"};
        ArrayList<String> list = new ArrayList<>();
        for (String s: strArray
             ) {
            if(getPredicate(s,a->{
                    return  a.split(",")[0].length()>2;
            },a->{
                return  Integer.parseInt(a.split(",")[1])>33;
            })){
                list.add(s);
            }
        }
        System.out.println(list);
    }
    private static boolean getPredicate(String s,Predicate<String> p1,Predicate<String> p2){
        return p1.and(p2).test(s);
    }
}


public class InterDemo {
    public static void main(String[] args) {
        String[] strArray={"林青霞,30","柳岩,34","张曼玉,35","貂蝉,31","王祖贤,33"};
        ArrayList<String> list = getPredicate(strArray,s->{
            return s.split(",")[0].length()>2;
        },s->{
            return  Integer.parseInt(s.split(",")[1])>33;
        });
        System.out.println(list);
    }
    private static ArrayList<String> getPredicate(String[] strings,Predicate<String> p1,Predicate<String> p2){
        ArrayList<String> list = new ArrayList<>();
        for (String s: strings
             ) {
            if(p1.and(p2).test(s)){
                list.add(s);
            }
        }
        return  list;
    }
}

Function 接口

Interface Function<T,R>

表示接受一个参数并产生结果的函数。

//int->string
public class Jademo {
    public static void main(String[] args) {
        String s1 = iToS(5, s -> {
            return s.toString();
        });
        System.out.println(s1);
    }
    private  static String iToS(Integer i, Function<Integer,String> f){
        return f.apply(i);
    }
}

//string->int
public class Jademo {
    public static void main(String[] args) {
        int i = sToI("135", s -> {
            return Integer.parseInt(s);
        });
        System.out.println(i );
    }
    private static int sToI(String s,Function<String,Integer> f){
        return f.apply(s);
    }
}

public class Jademo {
    public static void main(String[] args) {
       sToI("136",s->Integer.parseInt(s),s->s+1);
    }
    private static void sToI(String s,Function<String,Integer> f1,Function<Integer,Integer> f2){
        Integer tep = f1.apply(s);
        Integer tep1 = f2.apply(tep);
        System.out.println(tep1);
    }
}
//string->int->int+1

consumer 接口

Interface Consumer< T >

表示接受单个输入参数并且不返回结果的操作。与大多数其他功能接口不同， Consumer预期通过副作用进行操作

方法：accept 和andThen

和functional和predicate不同的时，他不用返回任何值。

接口中的default

要实现接口，那么接口中的全部方法都要实现。

但是接口方法前加上default，可以不实现。

但也能重写。

public interface Flyable {
    void fly(String s);
    void run(String s);
    default void flyAndrun(){
        System.out.println("fly和run");
    }
}

public class FlyableImp implements Flyable {
    @Override
    public void fly(String s) {
        System.out.println("fly");
    }

    @Override
    public void run(String s) {
        System.out.println("run");
    }
	//下面可以不实现，
    @Override
    public void flyAndrun() {
        System.out.println("重写了");
    }
}

接口中的静态方法

首先不能被重写。

其次只能通过接口名调用，不能通过实现类名或者对象名调用。

防止（一个实现类implements多个接口，那么有重复名称的静态类。）

public interface demo{
    public static void show(){
        System.out.println("11");
    }
}

//只能这样用
demo.show();

接口中私有方法

java 9(即jdk 1.9) 新增加的内容。

public interface Flyable {
    default void show1(){
        show();
    }
    private void show(){
        System.out.println("11");
    }
}

stream流

函数式编程风格。

生成流

通过数据源（集合数组等）生成流

如list.stream()
中间操作

做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
如 filter
中结操作

一个流只能有一个终结操作，当这个操作执行完后，流就被用光了，无法再被操作。

如forEach（）


public class Jademo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("张无忌他哥");
        list.add("张无忌特美");
        list.add("张三丰");
        list.add("张敏");
        list.add("李小龙");
        list.add("球球呀");
        System.out.println(list);
        ArrayList<String> list1 = new ArrayList<>();
        list.stream().filter(s->{
            return s.startsWith("张");
        }).filter(s->{
            return s.length()>=3;
        }).forEach(s-> System.out.println(s));
    }
}

生成方式

Collection体系的集合可以使用默认方法stream（）生产流
Map体系的集合间接生成流
数组通过Stream接口的静态方法0f()生成流。stream.of()

常见中间操作

filter(Predicate predicate)
limit(long maxSize)

截取前面maxSize个数据，返回流
skip(long n)

跳过指定参数个数的数据，返回由该流的剩余元素组成的流
concat(Stream a,stream b) ,静态方法。

合并a和b两个流为一个流。stream.concat();

distinct()

返回由该流的不同元素组成的流

public class Jademo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("张无忌他哥");
        list.add("张无忌特美");
        list.add("张三丰");
        list.add("张敏");
        list.add("李小龙");
        list.add("张三丰");
        ArrayList<String> list1 = new ArrayList<>();
        //1.filter()使用
        Stream<String> stringStream = list.stream().filter(s -> {
            return s.length() == 3;
        });
        Stream<String> stringStream1 = list.stream().filter(s -> {
            return s.startsWith("张");
        });
        System.out.println("----------------------");
        //2.limit()
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("----------------------");//输出前三个
        //3.skip()
        list.stream().skip(4).forEach(System.out::println);
        System.out.println("----------------------");//跳过前4个，输出后面
        //4. concat()
        Stream.concat(stringStream,stringStream1).forEach(System.out::println);
        System.out.println("----------------------");
        //5. distinct()
        Stream.concat(stringStream,stringStream1).distinct().forEach(System.out::println);
        //错误，stream has already been operated upon or closed
        //第四步操作已经将流关闭了。
    }
}

sorted()和sorted(Comparator comp)排序

public class Jademo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("123");
        list.add("4");
        list.add("6");
        list.add("456");
        list.add("7");
        list.add("1");
        //默认是自然排序
        list.stream().sorted().forEach(s-> System.out.println(s));
        //带comparator的自定义排序
        list.stream().sorted((s1,s2)->{
            return s1.length()-s2.length();
        }).forEach(s-> System.out.println(s));
    }
}

收集到集合中

  collect() 接口
  
  某个stream.collect(Collectors.toList())

反射

获取对象的三种方式

使用类的class属性
调用对象的getClass()

使用Class类中的forName(String className) 最为灵活

public class Jademo {

    public static void main(String[] args) throws ClassNotFoundException {
        Deom deom = new Deom();
        Class<? extends Deom> aClass = deom.getClass();//使用对象的getClas


        Class<Deom> deomClass = Deom.class;//使用类的class属性

        Class<?> deom1 = Class.forName("Deom");//使用Class类，最为灵活

        System.out.println(deom1);
        System.out.println(aClass==deomClass&&aClass==deom1);//true
    }

}

获取构造方法

getConstructors

获取所有public构造方法，返回数组
getDeclaredConstructors

所有构造方法
getConstructor(Class<?>…parameterTypes)

返回单个公共构造方法对象。

无参代表返回的是无参构造

getDeclaredConstructor(Class<?>…parameterTypes)

返回单个构造方法对象

import java.lang.reflect.Constructor;
public class Jademo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class<?> deom = Class.forName("Deom");//字节码文件
        Constructor<?>[] deoms = deom.getConstructors();
        for (Constructor c:deoms){
            System.out.println(c);
        }
        System.out.println("-----------");
        Constructor<?>[] declaredConstructors = deom.getDeclaredConstructors();
        for (Constructor constructor:declaredConstructors) {
            System.out.println(constructor);
        }
        System.out.println("------------");
        Constructor<?> constructor = deom.getConstructor(String.class,String.class);
        //不存在这个构造方法，异常。由于是抛出异常，所以程序会终止。可catch一下
        System.out.println(constructor);
        System.out.println("------------");
        Constructor<?> declaredConstructor = deom.getDeclaredConstructor(String.class);
        System.out.println(declaredConstructor);
    }

}
//完全输出
public Deom()
public Deom(java.lang.String,java.lang.String,int)
-----------
private Deom(java.lang.String)
public Deom()
public Deom(java.lang.String,java.lang.String,int)
------------
java.lang.NoSuchMethodException: Deom.<init>(java.lang.String, java.lang.String)
	at java.lang.Class.getConstructor0(Class.java:3082)
	at java.lang.Class.getConstructor(Class.java:1825)
	at Jademo.main(Jademo.java:19)
null
------------
private Deom(java.lang.String)

小练习

通过反射实现

Deom demo=new Deom("qiuqiu","China",50);

sout(demo)

public class Jademo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        
        Class<?> aClass = Class.forName("Deom");// 获得到了字节码文件
        Constructor<?> constructor = aClass.getDeclaredConstructor(String.class, String.class, int.class);//注意，参数个数要一致。
        Object asd_ = constructor.newInstance("qiuqiu","China",50);
        System.out.println(asd_);
    }
}

通常来说，不能通过私有构造方法创建对象，但反射可以

//访问一个私有
public class Jademo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> aClass = Class.forName("Deom");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class);
        System.out.println(declaredConstructor.newInstance("qiuqiu").toString());
    }
}
异常
     Class Jademo can not access a member of class Deom with modifiers "private"

public class Jademo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> aClass = Class.forName("Deom");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class);
        declaredConstructor.setAccessible(true);//取消访问检查
        System.out.println(declaredConstructor.newInstance("qiuqiu").toString());
    }

获取成员变量

同理，私有的要setAccessible(true)

getField() ，getFields()

得到public 变量

getDeclaredField() ，getDeclaredFileds()

得到所有对象


public class Jademo {

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

        Constructor<?> declaredConstructor = deom.getDeclaredConstructor(String.class);
        declaredConstructor.setAccessible(true);
        Object o = declaredConstructor.newInstance("qiuqiu");

        Field age = deom.getDeclaredField("age");
        age.setAccessible(true);//私有成员变量
        age.set(o,50);
        System.out.println(o);//将o的age 字段设置为50
    }

}

练习

public class Jademo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Class<?> deom = Class.forName("Deom");
        Constructor<?> declaredConstructor = deom.getDeclaredConstructor();
        Object o = deom.newInstance();

        Field name = deom.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"qiuqiu");


        Field address = deom.getDeclaredField("address");
        address.setAccessible(true);
        address.set(o,"china");

        Field age = deom.getDeclaredField("age");
        age.setAccessible(true);
        age.set(o,50);
        System.out.println(o);
    }
}

获取成员方法

getMethods()

连继承的public方法也都返回了
getDeclaredMethods()

返回非继承所有方法

getDeclaredMethod(方法名称，参数.class)


public class Jademo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Class<?> deom = Class.forName("Deom");
        Constructor<?> declaredConstructor = deom.getDeclaredConstructor();//无参构造方法
        Object o = deom.newInstance();//由无参构造方法 创建对象

        Field age = deom.getDeclaredField("age");
        age.setAccessible(true);
        age.set(o,50);

        Method getAdd = deom.getDeclaredMethod("getAdd", int.class);//此成员方法有一个int值的参数
        getAdd.setAccessible(true);
        getAdd.invoke(o,30);//调用o对象的getAdd()方法，参数是30
        
        //带返回值的成员方法
        Method getAdd = deom.getDeclaredMethod("getAdd", int.class);
        Object invoke = getAdd.invoke(o, 30);
        System.out.println(invoke);
    }
}

越过泛型检查

 		ArrayList<Integer> list = new ArrayList<>();
        list.add(126);

        Class<? extends ArrayList> aClass = list.getClass();
        Method add = aClass.getDeclaredMethod("add", Object.class);
        add.invoke(list,"pop");
        add.invoke(list,"998+");

       for (Object a:list){
           System.out.println(a);
       }

本文地址：https://blog.csdn.net/qq_43179428/article/details/107164462

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

Attribute ‘sklearn.linear_model._logistic.LogisticRegression.multi_class‘ must be explicitly set to

试图python模型转化为java加载,碰到个硬茬,完整报错信息如下:Jul 13, 2020 3:13:45 ... [阅读全文]
python面向对象（一）

1.定义类下面定义了一个简单的People类：class People: pass# 构建对象people... [阅读全文]
IDEA 方法注释设置（包括获取参数）

File–Setting–Live Templates：添加一个自己的注释模板设置模板名：名字随意选择设置模板具... [阅读全文]
tta

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC58eVE6F5OedOYE3nf... [阅读全文]
Java/Python实现 LeetCode剑指Offer 14-I.剪绳子（动态规划）

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段... [阅读全文]
Python - paramiko 模块远程执行ssh 命令 nohup 不生效的问题解决

文章目录Python - paramiko 模块远程执行ssh 命令 nohup 不生效的问题解决1、使用 pa... [阅读全文]
SpringCloud-微服务架构之浅尝辄止

SpringCloudSpringCloud的简单了解微服务框架单一职责：微服务中每一个服务都对应唯一的业务能力... [阅读全文]
Java多线程系列1: 并发

Java多线程系列1: 并发本文是作者的读博客笔记和心得整理，也引用了一些比较好的博客文章,部分内容来源于网络，... [阅读全文]
DARTS论文和算法解析

DARTS，论文的全名是Differentiable Architecture Search，即可微分的架构搜索... [阅读全文]
Haproxy 五个配置部分详解

根据功能和用途将haproxy分为了5个部分，这五个部分不都是必须的，可以根据需要选择就行了，只是将haprox... [阅读全文]

网友评论


验证码：