Java 疑惑问题解答(长期更新)

Java 疑惑问题解答

一个类所实现的两个不同的接口中，有同名的方法，怎么知道实现的是哪个接口中的方法

答:如果这个类实现了这个同名方法,那么这个方法可以理解为属于这两个接口。

**注意事项：**但是这个两个接口的同名方法的返回值是必须相同的，否则编译器会报错。

同时如果接口会抛异常，那么该类只能抛出两个同名方法异常的交集，且只针对Checked Exception

Java 数组==运算符的判断原理

		int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};
        System.out.println(a == b);

答案是false,所以很明显，还是判断引用。

GC工作地点

1. 在ArrayList的remove方法

 public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

函数式接口的定义

只有一个抽象方法的接口

Java 1.8 新增的特性

1. lamda表达式
2. （1）功能性接口：Function，传入一个值，返回一个值
   （2）断言性接口：Predicate，理解为判断，传入一个值，返回boolean
   （3）供给性接口：Supplier，理解为提供，无参数，但返回一个值
   （4）消费性接口：Consumer，理解为消耗，传入一个值，但返回void
3. 访问局部变量不需要手动添加final参数，但是还是不能修改

Function<T, R>接口解析

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }

可以看到，这里面有4个方法，1个是抽象的，符号函数式接口的定义。

apply方法，规定传入一个t值，然后返回一个R类型的对象。

compose方法，会先调用before的apply方法，然后将返回值传给自己的apply方法，然后调用这个apply方法

andThen方法，和compose方法相反，先调用自己的apply，然后调用传入的after的apply方法

identity方法，相当于y=x的用法

提供一个理解andThen方法的代码

public static Integer modifyTheValue2(int value, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
        Function<Integer, Integer> function3 =function1.andThen(function2);
        return function3.apply(value);
    // return function1.andThen(function2).apply(value);//等价于这句话
    }

    public static void main(String[] args) {
        System.out.println(modifyTheValue2(3, val -> {
            System.out.println("f1");
            return val + 2;
        }, val -> {
            System.out.println("f2");
            return val + 3;
        }));
    }

一开始对注释的整段不是很理解，但是把这个拆分开来之后，就容易理解多了。

function1.andThen(function2)返回的同样是一个function类型的，也就是等价于function3，相当于定义了一个新的function，然后传入参数value。

String的intern方法

public static void main(String[] args) throws Exception {
    String aString = new String("0102");
    String bString = aString.intern();
    String cString = "0102";
    System.out.println(aString == bString);//false
    System.out.println(aString == cString);//false
    System.out.println(bString == cString);//true
}

intern方法是一个native类型的,作用是从常量池中寻找所要的String,如果没有,则会将String加入到常量池中。

这也就是为什么第三个返回true，因为cString直接声明字符串是在常量池中，bString调用intern方法也获得了常量池中的“0102”，所以对应地址相等，返回true。