java基础学习笔记

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 stringComparator = new Comparator(){
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        };
//        return stringComparator;
        
        
//        return new Comparator(){
//            @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

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

//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流

函数式编程风格。

  1. 生成流

    通过数据源(集合数组等)生成流

    如list.stream()

  2. 中间操作

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

  3. 中结操作

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

    如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));
    }
}

生成方式

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

常见中间操作

  1. filter(Predicate predicate)

  2. limit(long maxSize)

    截取前面maxSize个数据,返回流

  3. skip(long n)

    跳过指定参数个数的数据,返回由该流的剩余元素组成的流

  4. concat(Stream a,stream b) ,静态方法。

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

  5. 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
            //第四步操作已经将流关闭了。
        }
    }
    
    
    1. 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())

反射

获取对象的三种方式

  1. 使用类的class属性

  2. 调用对象的getClass()

  3. 使用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
        }
    
    }
    
    

获取构造方法

  1. getConstructors

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

  2. getDeclaredConstructors

    所有构造方法

  3. getConstructor(Class…parameterTypes)

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

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

  4. 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)
    

小练习

  1. 通过反射实现
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_);
    }
}
  1. 通常来说,不能通过私有构造方法创建对象,但反射可以
//访问一个私有
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)

  1. getField() ,getFields()

    得到public 变量

  2. 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);
    }
}

获取成员方法

  1. getMethods()

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

  2. 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);
       }

你可能感兴趣的:(Java)