八股文第三天

时间：2022年7月22日

第一题:反射（了解）

在 Java 中的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有 的 属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获 取信息 以及动态调用对象方法的功能成为 Java 语言的反射机制。

获取 Class 对象的 3 种方法 ：
​ 1.使用类名调用.class属性(.class不是只有类能调用)
​ 2.使用一个类的对象调用.getClass()方法
​ 3.使用Class类的静态方法forName(“类全名”),最安全/性能最好## 标题

public class Demo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取字节码对象三个方式

        //​	1.使用类名调用.class属性(.class不是只有类能调用)
        Class c1 = String.class;

        //​	2.使用一个类的对象调用.getClass()方法
        Class c2 = "abc".getClass();

        //​	3.使用Class类的静态方法forName("类全名")
        Class c3 = Class.forName("java.lang.String");

        System.out.println(c1 == c2);
        System.out.println(c2 == c3);
    }
}

第二题:jdk1.8 的新特性（高薪常问）

1. Lambda 表达式
Lambda 允许把函数作为一个方法的参数

1.如果小括号里面有参数,参数类型可以直接省略

2.如果小括号里面只有一个参数,小括号可以省略

3.如果大括号中只有一句代码,可以省略大括号和return关键字和语句里面的分号;

2. 方法引用
方法引用允许直接引用已有 Java 类或对象的方法或构造方法。
如果lambda表达式里面只有一行代码，且这一行代码是调用了一个已经存在的方法
​ 我们自己没有写任何其他代码逻辑，就可以使用方法引用,做进一步简化
​ 格式:
​ 类名/对象名::方法名**

 @Test
    public void test2(){

        ArrayList<String> list = new ArrayList<>();
        list.add("柳岩");
        list.add("小岳岳");
        list.add("新垣结衣");
        list.add("燕子");
        //把流转回集合,可以把流变成List集合 -> Set集合 或 数组
       Stream<String> stream = list.stream();
      //List<String> collect = stream.collect(Collectors.toList());
      //System.out.println("collect = " + collect);//collect = [柳岩, 小岳岳, 新垣结衣, 燕子]
       //Set<String> collect1 = stream.collect(Collectors.toSet());
       //System.out.println("collect1 = " + collect1);//collect1 = [新垣结衣, 燕子, 柳岩, 小岳岳]
        Object[] array = stream.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }


        //通过集合获取Stream流
        //Stream<String> stream = list.stream();
        //System.out.println(stream);//java.util.stream.ReferencePipeline$Head@725bef66
       // long count = list.stream()
       //         .count();
       // System.out.println(count);
       // list.stream().forEach(System.out::println);
        //list.stream().filter(s -> s.length()>=3).forEach(System.out::println);
        //list.stream().limit(2).forEach(System.out::println);
        //list.stream().skip(2).forEach(System.out::println);
       // list.stream().map(String::length).forEach(System.out::println);
        //Stream<String> stream1 = list.stream();
        //Stream<String> limit1 = stream1.limit(1);//柳岩
        //Stream<String> stream2 = list.stream();
        //Stream<String> skip = stream2.skip(3);//燕子
        //Stream<String> concat = Stream.concat(limit1, skip);
        //concat.forEach(System.out::println);//柳岩，燕子
    }

3. 函数式接口
有且仅有一个抽象方法的接口叫做函数式接口，函数式接口可以被隐式转换为 Lambda 表达式。通常函数式接口 上会添加@FunctionalInterface 注解。

4. 接口允许定义默认方法和静态方法
从 JDK8 开始，允许接口中存在一个或多个默认非抽象方法和静态方法。

5.Stream API
新添加的 Stream API（java.util.stream）把真正的函数式编程风格引入到 Java 中。这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选， 排序，聚合等。可以看成遍历集合的高级方式,可以遍历集合并对集合的元素做操作.

终结方法：

- 终结方法就是流水线的最后一步操作，终结方法之后不能再调用流的其他方法。
- count() :   获取流中元素的个数
- forEach() :    遍历流中的每个元素

非终结方法：

- 非终结方法就是流水线的过程方法，非终结方法之后可以继续调用其他方法。
- filter() :    过滤元素	boolean
- limit():      保留前几个元素  
- skip():    跳过前几个元素   
- map() :  把流中的元素类型换成另一种类型
- static concat() ： 把两个流合并成一个流

6.日期/时间类改进
之前的 JDK 自带的日期处理类非常不方便，我们处理的时候经常是使用的第三方 工具包，比如 commons-lang 包等。不过 JDK8 出现之后这个改观了很多，比如日期时间的创建、比较、调整、 格式化、时间间隔等。 这些类都在 java.time 包下，LocalDate/LocalTime/LocalDateTime。

7.Optional 类
Optional 类是一个可以为 null 的容器对象。如果值存在则 isPresent()方法会返 回 true，调用 get()方法会返回该对象。

 @Test
 /**
     * Optional容器类的常用方法：
     * Optional.of(T t)：创建一个Optional实例
     * Optional.empty()：创建一个空的Optional实例
     * Optional.ofNullable(T t)：若t不为null,创建Optional实列，否则创建空实例
     * isPresent()：判断是否包含值
     * orElse(T t)：如果调用对象包含值，返回该值，否则返回t
     * orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回s获取的值
     * map(Function f)：如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
     * flatMap(Function mapper)：与map类似，要求返回值必须是Optional
     */
    public void test3(){
      String s="abc";
      //创建容器
        Optional<String> s1 = Optional.of(s);
        System.out.println(s1);//Optional[abc]
        boolean present = s1.isPresent();
        System.out.println("present = " + present);//present = true
        String s2 = s1.get();
        System.out.println("s2 = " + s2);//s2 = abc
     //创建容器,若t不为null,创建Optional实列，否则创建空实例
        String a=null;
        Optional<String> a1 = Optional.ofNullable(a);
        System.out.println(a1);//Optional.empty
        boolean present1 = a1.isPresent();
        System.out.println("present1 = " + present1);//present1 = false
        Optional<String> c = Optional.ofNullable(s);
        System.out.println(c);//Optional[abc]

        //类似于设置默认值
        String s3 = s1.orElse("d");
        System.out.println("s3 = " + s3);//s3 = abc
        String s4 = s1.orElse(a);
        System.out.println("s4 = " + s4);//s4 = abc
        String d = a1.orElse("d");
        System.out.println("d = " + d);//d = d
    }

8.Java8 Base64 实现

Java 8 内置了 Base64 编码的编码器和解码器

今天的任务完成