JDK8新特性

1 可变参数

//可变参数
    public static  void method1(int ... num){
        //[[email protected]
        System.out.println(num);
        for (int i : num) {
            System.out.println(i);
        }
    }
    //可变参数和其他类型参数的传参
    public static  void method2(String str,int ... num){
        //[[email protected]
        System.out.println(num);
        for (int i : num) {
            System.out.println(i);
        }
        System.out.println(str);
    }

2.增强for循环

 //增强for循环
    public static void method3(int ...num){
        //在增强for循环中数据的类型必须是集合或者数组中元素的数据类型。
        for (int i : num) {
            System.out.println(i);
        }
    }

3.lambda 表达式

lambda 表达式的形式
<函数式接口> <变量名称>=(参数列表)->{
方法体:
}

lambda 表达式的特点

• 函数式接口是接口中只有一个抽象方法的接口。
• = 右边的类型会根据左边的函数式接口类型自动判断
• 如果参数列表为空，只保留()
• 如果参数只有一个，可以省略数据类型，保留变量名称即可。
• 如果是想语句只有一句，且没有返回值则可以省略{},如果有返回值，执行语句只有一句想省略{} 则雅瑶省略return.
• lambda 不会生成一个单独的内部类文件。

public interface LambdaDemo1 {
    void eat(String str);
}

 //lambda 表达式
        LambdaDemo1  lambdaDemo1 = (String str)->{
            System.out.println("eat foods!!!!" + str);
        };

        LambdaDemo1  lambdaDemo3 = (String str)->

            System.out.println("eat foods!!!!" + str);
        //lambda 简化以后
        LambdaDemo1  lambdaDemo4 = str ->
            System.out.println("eat foods!!!!" + str);

        lambdaDemo1.eat("World");
        lambdaDemo3.eat("World");
        lambdaDemo4.eat("World");

public interface Demo1 {
    //默认的方法 是允许有方法体的,并且被所有实现类的对象直接使用。
    public default  void hello(){
        System.out.println("HelloWolrd");
    };

        public void  eat();
}

public class Demo1Impl implements  Demo1 {
    @Override
    public void eat() {
        System.out.println("Demo01Impl eat foods!!!");
    }
}

 public static void method5(){
       Demo1Impl  demo1  = new Demo1Impl();
                demo1.hello();
                demo1.eat();
    }


// 带返回值的方法
    public interface LambdaDemo2 {
   int  sum(int  a,int b);
}

//lambda 表达式
 public  static  void test3(){
        LambdaDemo2  lambdaDemo2 = (int a,int b)->{return a+b;};
        System.out.println(lambdaDemo2.sum(10,20));
        //省略{} 和 return
        LambdaDemo2  lambdaDemo3 = (int a,int b)-> a+b;;
        System.out.println(lambdaDemo3.sum(100,200));

        // 省略数据类型
        LambdaDemo2  lambdaDemo4 = (a,b)-> a+b;;
        System.out.println(lambdaDemo4.sum(1000,2000));

    }

4集合Stream

public static void method4(){
        ArrayList<String>  list = new ArrayList<>();
            list.add("String");
            list.add("Hello");
            list.add("Javav");
            list.add("World");
            list.add("c++");
            list.add("lambda");
            list.add("switch");
            list.add("small");
            list.add("shell");
            //Stream  流
        //Stream<String> stringStream = list.parallelStream();
        //计算流中元素的个数
        //System.out.println(stringStream.count());
        //lambda 表达式结合集合流
        // 从容器中获取最大值
       // System.out.println(stringStream.max((a,b)->{return  a.compareTo(b) ;}).get());
        //System.out.println(stringStream.min((a,b)->{return  a.compareTo(b) ;}).get());

        System.out.println(list.parallelStream().count());
        System.out.println(list.parallelStream().max((a,b)->a.compareTo(b)).get());
        System.out.println("------");
        //过滤集合中以s开头的元素
        Object[] s = list.stream()
        //过滤值不为空
                .filter(num -> num != null)
                //过滤值以s开头
                .filter(str -> str.startsWith("s"))
                //转换为数组
                .toArray();
        for (Object o : s) {
            System.out.println(o);
        }
    }


     public static  void method7(){
        ArrayList<Integer> list = new ArrayList<>();
                    list.add(23);
                    list.add(44);
                    list.add(55);
                    list.add(2);
                    list.add(88);
                    list.add(54);
                    list.add(12);
        Stream<Integer> stream = list.stream();
            //过滤
      long count =  stream.filter(num->num!=null).filter(num->num<50).count();
        System.out.println(count);
    }

5 字符串格式化

System.out.printf("Line %s",123);

//输出结果是
Line 123

6 类加载机制

先编译后运行，编译后的文件是一个.class 二进制字节码文件。
JVM加载我们的类去运行。

6.1类的加载

• 将class 文件加载到内存中，生成一个Class对象。
• Class 类的实例表示正在运行的 Java 应用程序中的类和接口。
• 连接
  • 验证 验证是否有正确的内部结构。(成员和构造器)
  • 准备 如果有静态的成员分配内存，默认初始化值。
  • 解析 将类的二进制数据中的符号替换为直接引用。
• 初始化(new )

6.2 类加载器

将.class 文件加载到内存中，生成对应的Class对象。(运行时类的对象)
我们不需要关系类加载器的加载机制。

• 类加载器的组成
  • 根类加载器
  • 扩展类加载器(第三方的jar文件)
  • 系统类加载器(环境变量指定的jar路径)

7 反射

反射机制是在运行状态中，对于任意一个类都能够知道类的属性和方法。
对于任意一个对象都能调用他的任意方法和属性
这种获取信息以及调用的对象方法的功能称为反射机制

要解刨一个类，首先要获取类的二进制字节码文件。解剖使用的就是Class类中的方法。

7.0 反射获取Class对象(三种放式)

• Student stu = new Student();
  Class aClass = stu.getClass();
• Class c = Student.class：
• Class classz = Class.forName(“com.hdrj.reflect.Student”);

7.1 反射技术获取字段

     public static  void method()throws Exception{
        //反射技术
        //获取类的Class对象
        Class  classz =  Class.forName("com.hdrj.reflect.Student");
        //com.hdrj.reflect.Student
        System.out.println(classz.getName());

        //获取所有的字段  公共字段。
        Field[] fields = classz.getFields();
        for (Field field : fields) {
            System.out.println("field--"+field);
        }
        //获取所有的字段
        Field[] fields1 = classz.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println(field);
        }
        //获取单个公共的字段
        Field name = classz.getField("address");
        System.out.println(name);

            //实例化对象
        Object o = classz.newInstance();
        //设置值
        name.set(o,"admin");
        //获取 o 对象name 字段的值
        System.out.println(name.get(o));
    }

7.2 反射获取构造器

 Constructor<T> getConstructor(Class<?>... parameterTypes) 
          返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。 
 Constructor<?>[] getConstructors()
          返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。



public static  void method3()throws Exception{
        Class  classz =  Class.forName("com.hdrj.reflect.Student");
        Constructor[] constructors =
                classz.getConstructors();
        for (Constructor constructor : constructors) {
            //public com.hdrj.reflect.Student()
            //public com.hdrj.reflect.Student(int,java.lang.String)
            System.out.println(constructor);
        }
        //获取带参数的构造器
        Constructor constructor = classz.getConstructor(int.class, String.class);
        //使用带参数的构造器实例化对象
        Object java = constructor.newInstance(12, "JAVA");
        System.out.println("constructor==="+constructor);
        System.out.println("java==="+java);

    }

7.3 反射获取方法

Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
          返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Method[] getMethods()
Method getMethod(String name, Class<?>... parameterTypes)
          返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。 
Object invoke(Object obj, Object... args) 
          对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。


 public static  void method2()throws Exception{
        Class classz = Class.forName("com.hdrj.reflect.Student");
        //拿到的是自己和父类的方法
        Method[] methods =  classz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("-----------------------------------------");
        //获取方法
        Method hello = classz.getMethod("hello", null);
        //方法的执行
        Object o = classz.newInstance();
            hello.invoke(o,null);

        Method say = classz.getMethod("say", String.class);
            say.invoke(o,"reflect");

        //获取私有方法执行
     Method sum = classz.getDeclaredMethod("sum", null);
        //暴力访问方法
             sum.setAccessible(true);
             sum.invoke(o,null);
    }