stringbuilder和stringbuffer都是abstractstringbuilder的子类，但是stringbuffer中的方法都是被synchronized关键字修饰的，也就代表着stringbuffer是线程安全的，但也意味着会影响运行效率，所以在线程安全的环境下使用stringbuilder否则使用stringbuffer。以append方法举例，这两个类的append方法基本一致都是调用父类的append方法但是stringbuffer因为维护了一个toStringcache所以在对字符串修改时会先清空缓存。还有一点需要补充，就是虽然stringbuffer的方法被synchronized修饰，但是锁住的只是当前的stringbuffer对象，如果拼接的是string对象那无可厚非，但是如果拼接的是另外一个stringbuffer或stringbuilder，我们无法保证它们是线程安全的。

1.String 为什么要设计为不可变类?

这个问题可以从两个角度来分析
从安全性来看，String被final修饰就意味着该类不可被继承，并且底层的char数组被private修饰且没有对外访问的接口，这样在多线程的环境下，我们就不需要担心String类型的线程安全问题，因为每次对String的修改都指的是创建一个新对象，或是由字符串常量池中返回一个对象。

从性能的角度分析，首先java为了使字符串可以复用，在jvm中有专门的字符串常量池存放String对象，如果String提供给外界可以修改字符串的接口，那么这个字符串常量池也失去了它的意义，并且因为String类型经常作为HashMap中的key所以String中就专门缓存了用private修饰的hash值，这个hash值在第一次调用String重写的hashcode方法后就会缓存到对象中，提高了效率，而且由于String是final修饰的，我们也就不用担心由于它的哈希值改变在通过key查询value时，查询不到值。

2.String a = new String(“aa”) + “bb” “这句话创建了多少个对象

如果字面量“aa”和“bb”在之前都没有出现过，那么首先会在字符串常量池中创建两个String对象，之后会创建一个StringBuilder对象调用append方法拼接“aa”和“bb”，最后调用toString在堆内存中创建了一个String对象存放“aabb”，假如这两个垃圾对象StringBuilder和new String(“aa”)都被gc那么，在最后的状态在堆内存中存在3个String对象，但是在这个过程中创建了5个对象

3.String 对象最多可以存放多少个字符（长度）?

理论上是Integer.MAX_VALUE大小个字符，也就是21亿多，因为String底层使用char数组存放字符串，而通过String的length()方法可以发现，char[]的长度是int类型，所以理论上的最大值是21亿，但是由于很多虚拟机会在数组中加入一些元数据，所以精确来讲可以存放Integer.MAX_VALUE – 8个字符，这一点可以在ArrayList源码中定义的数组最大长度可以发现。

4.字符串常量池是放在堆中吗？

在java6及以前常量池放在永久代中，java7开始字符串常量池从永久代移动到堆内存中，这样设计可能字符串常量池就可以存放更多的数据，并且java8开始永久代就被废除，方法区的实现变成了元数据空间。

5.String中 “+” 和 StringBuffer 中的 append 会有性能上的差别吗?

会有。如果使用+就可能会创建新的String对象，而使用StringBuffer的append方法只是对原有的char[]数组修改，具体的实现逻辑就是判断char[]数组是否需要扩容，之后调用System.arraycopy方法将String中的char[]拷贝到StringBuffer中的char[]中，不需要创建一个新的对象。

final 字面意思是 “最终的”，就是说无论用它来修饰字段，方法还是类，都表示它是最终的，不可变了。具体来说，一个 final 类不可被继承，final 方法不可被重写， final 字段不可被修改，但对于引用类型可以更改其内部的值。实践中通常将一个常量，或者确定在之后的代码中不应该被修改的字段声明为 final。

equals( ) 和hashCode( ) 是 Object 类的方法，equals( ）默认是比较引用类型的地址值，在想要比较数值相同时候，重写。hashcode，方法能生成一个hash值，然后根据值是否相同来做一些事情。在比如集合那块，hashset（底层是hashmap），要往table放的话，首先计算哈希值，转成索引值，没有直接放，有的话就要比较equals了，这时候equals也要重写，不重写可能也加进去了。就和我们的想法违背了。用快捷键重写。。。

equals表示判断两个的地址是不是一样的，因为string重写了equals方法，所以有些人认为是判断值是否相等
getclass获取当前运行类的对象
tostring默认返回的是地址值，可以自己重写
hashCode的方法用来获的哈希值，在集合set中判断元素要不要加进去，就要用到，先判断hash值，然后再看equals是不是一样。

1，异常是程序执行中出现的一些意外，就需要我们来解决。
根父类是throwable，包括 Error 和 Exception，一般我们要解决的异常是编译是异常，运行时异常应该避免，error是jvm死机了，严重错误。例子：空指针异常（NullPointerException），角标越界（ArrayIndexOutOfBoundsException），类型不匹配异常（InputMismatchException）等
3.throw是我们自己抛出来异常，需要去解决，或者往上抛，throws则就是不解决往上抛的那个，抛给方法的调用者，当然一般建议别抛到main函数，在main之前try catch。 直接抛出去可能要抛出去多次，每次都try catch影响性能吧，可以交给一个最上面的调用者一块儿解决。
4，出现异常的时候影响，不出就不影响
5，执行，程序先把catch的return暂时存放，然后finally执行后才返回，但是当程序进入 try 块之前就出现异常时，就结束，不会执行 finally 块中的代码。

类加上final证明不能在被继承，方法加上不能重写，变量加上只能赋值一次，比如 final int x = 1，x++就是错的，但是x+1是可以成功的，就是说对象不能再变，但是里面的内容的值是可以变的。一般配上static用（我是菜鸡，大佬们看到哪儿错了可以踢我一下，谢谢）

两个都是可变字符串，StringBuilder是线程不安全的，但是速度快，stringbuffer是安全的，同样速度相对慢一点，都不能被继承，被final修饰，都实现了serialzable接口，也能串行化在网络中传输，内容都存在父类的abstractstringbuilder的char【】vale中。

hashcode：通过key值生成一个hash值，主要用于哈希表的映射。
equals：比较两个对象是否相等，这里比较的是地址是否相同。
我们在实现业务需求时可以重写equals和hashcode方法。
wait、notify、notifyAll主要用于多线程并发场景，等待、唤醒、唤醒全部的功能。
getClass：获取对象的类，返回一个类对象。
toString：默认返回string类型对象的的类名和引用地址，我们可以对它重写以满足自己的业务需求。

equals是object类中的一个方法，用于比较两个对象的引用地址，也就是对象所在堆内存的地址，在平常使用中我们可以重写equals方法，以满足我们的业务需求。
是一个双目运算符，比较两个两个基本数据类型的值是否相等，比较引用数据类型时比较两个对象的地址是否相同。

1、在Java中，由于会大量的使用String常量，如果每一次声明一个String都创建一个String对象，那将会造成极大的空间资源的浪费。Java提出了String池的概念，在堆中开辟一块存储空间字符串池，当初始化一个String变量时，如果该字符串已经存在了，就不会去创建一个新的字符串变量，而是会返回已经存在了的字符串的引用。另外就是安全性，多个线程共享一个string时是线程安全的，因为不会有修改string造成的线程不安全问题。
2、4个，首先常量池找aa，没有就创建后放入，此时常量池一个对象，new的时候产生一个对象放放在堆内存中，引用地址指向常量池中aa对象地址，bb也在常量池中有一个对象，然后就是常量池中有一个aabb的对象。（总之new一个对象就会在堆内存中单独生成一个对象）
3、string中的字符是用char[int]来存储的，int的长度为2^31-1，这是理论长度，由于常量池限制，在常量池中string最大长度为2^16-2。堆栈中是我们的虚拟机堆内存限制
4、不是的
5、有的，前者的内存和CPU开销会大于后者，毕竟安全高和开销小不可兼得嘛。

equals()是一个Object类的常用方法，用于引用类型的比较，默认实现是比较两个对象的内存地址，但是很多类都重写了equals方法，使得比较的是对象的属性和对应的值，例如String Integer等类，比较是否相等时，都应该用equals()；
而多用在基本数据类型的比较，比如int char等，可以直接比较它们的值是否相等。

时间O(3(N+M))，空间O(2(N+M))。递归练习，有些耗空间。

    public static ListNode linkedListAdd(ListNode head1, ListNode head2){
        ListNode p1 = reserveList(head1);
        ListNode p2 = reserveList(head2);
        //记录进位
        int carry = 0;
        ListNode dummyHead = new ListNode(-1);
        ListNode cur = dummyHead;
        while (p1 != null && p2 != null) {
            int val = p1.val + p2.val + carry;
            if (val >= 10) {
                val %= 10;
                carry = 1;
            }
            cur.next = new ListNode(val);
            cur = cur.next;
            p1 = p1.next;
            p2 = p2.next;
        }
        ListNode nextNode = p1 == null ? p2 : p1;
        while (nextNode != null) {
            int val = nextNode.val + carry;
            if (val >= 10) {
                val %= 10;
                carry = 1;
            }
            cur.next = new ListNode(val);
            cur = cur.next;
            nextNode = nextNode.next;
        }
        if (carry == 1) {
            cur.next = new ListNode(1);
        }
        ListNode newHead = dummyHead.next;
        return reserveList(newHead);
    }
    public static ListNode reserveList(ListNode head) {
        if (head.next == null) {
            return head;
        }
        ListNode newHead = reserveList(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }

将之前L、R的思想互换一下。在mid*mid > x时，R反而可能是我们需要求的。

int myUpperSqrt(int x){
    int l=0,r=x;
    while(l<=r){
        if(r-l<=1){
            return r*r > x ? l:r;
        }
        int mid=l+(r-l)/2;
        if((long)mid*mid < x){
            l=mid+1;
        }else if((long)mid*mid > x){
            r=mid;
        }else{
            return mid;
        }
    }
    return -1;
}

同一套代码，在不同操作系统上运行，不需要对源代码做任何修改，即可顺利运行，这就叫做平台无关性。
java之所以可以实现平台无关性，依靠的是JVM和字节码（Class文件）。java编译器首先把.java文件编译打包成字节码，然后启动JVM，由JVM在不同平台上运行这些字节码，所以java代码的运行是不用直接跟操作系统交互的，而是通过JVM作为中间层，来屏蔽平台的差异，所以java程序员只需要专注于java程序的开发逻辑即可，而不需要过多的关注平台的细节。当然，这并不意味着java程序完全与平台无关，还是要注意一些可能导致问题的因素，例如：文件路径、编码格式、系统属性等。

重载和重写都是多态的体现。Java中每一个类都有一个方法表，如果一个类中有同名的方法，只要参数类型或者个数、排列顺序不同、返回类型不同，Java就会认为它是一个不同的方法，放入方法表中。当调用同名方法时，就会根据参数列表去方法表中找到对应的方法执行，具体调用哪一个方法编译时就已经确定。所以重载是编译时多态的体现。而重写是运行时多态的体现，如果调用一个类的方法时，该方法在类的方法表找不到，Java就会去父类的方法表中找，找不到再去Object类中的方法表找，具体调用哪一个方法是运行时确定的。如果调用子类重写的方法时，方法的符合引用解析后指向子类中方法表的索引值（该索引值和父类方法重写方法的索引值一样），所以重写是运行时多态的体现。
重写适用于子类想要有自己独特的行为。重载适用于向针对不同参数列表分别实现不同功能的场景。

打卡

1、异常是程序在执行过程中可能发生的一些错误，它会暂时终止程序，并转到异常处理部分尝试恢复。异常的出现可以使我们把程序中可能出现错误的代码从正常代码中分离出来，单独进行处理。

2、类似于 Object 类，Throwable 是所有异常的父类。下一层分为 Error 类和 Exception 类。

Error 类表示严重的错误，一般由 JVM 和底层系统引发，并且不可恢复，例如内存溢出，class 没有主方法等。Exception 类是可以被程序捕获和处理的异常情况。

Exception 再往下，按照异常的性质又分为编译异常 CheckedException 和运行时异常 RuntimeException。其中检查异常在编译阶段就能被检测出，例如 IO 异常 IOException，文件找不到异常 FileNotFoundException等。运行时异常只有在程序运行时才能被检测出，例如空指针异常 NullPointerException，数组下标越界 ArrayIndexOutOfBoundsException 等。

3、throw 用在方法体内，表示某个地方需要抛出一个异常，是一个具体的动作。而 throws 用在方法声明后面，表示这个方法可能会抛出哪些异常，是一个声明。

这个需要分情况对待。首先，对于能在方法内处理的异常，可以直接用 try catch，但对于在当前方法内无法处理的异常，我们只能选择抛出，将它交给方法调用者去处理。其次，有时多个方法可能会抛出相同类型的异常，如果每个方法都用 try catch 会非常冗余，这时可以在这些方法中只 throw，在调用这些方法的地方整体 try catch，统一进行处理。

4、几乎不会，也就是程序没有异常时，try catch 加和不加性能几乎一样，只有在程序有异常需要捕获时才会影响性能。

原因在于，处理异常的 catch 语句在 class 文件中是用异常表实现的。异常表有四个字段，分别是 From, To, Target 和 Type。From 和 To 分别对应 try 块对应的行号，如果其中有异常抛出，会跳转到 Target 对应的行号，也就是 catch 语句对应的位置，而这个异常的类型记录在 Type 中。如果程序在 try 中没有异常抛出，最终会通过一条 goto 指令跳转到 try catch 块后的语句继续执行，这一条 goto 指令性能的消耗可以忽略不计。如果有异常，才会去查异常表，再跳转到对应的 catch 块位置去执行，这个过程可能会影响性能。

5、会的，无论 catch 块中有异常还是有返回语句，最终一定会在方法真正结束之前执行 finally。但是需要考虑一种特殊情况，就是如果 try 块中抛出了异常但没有被 catch 捕获，且此时 finally 中也抛出了异常，那么 finally 中的异常会覆盖掉 try 中的异常，成为这个方法最终抛出的异常。实践中需要注意一下这个异常覆盖问题。

hashcode()、equals()方法是Object类中的方法，Object类是所有类的父类，所以每个类都有这两个方法。
在Object中，equals()方法是通过比较两个对象的在堆中的地址（引用地址）来比较两个对象是否相同，hashcode()方法是用来计算对象的hash值，但是在原生的Object类中的hashcode是根据引用地址来映射的。
在实际应用的我们经常会对equals()和hashcode()方法进行重写，以达到我们判断两个对象的内容是否一致的效果。以我们的hashmap为例子，当我们在存入一个Object对象时，我们希望我们对象的内容一样时，我们就认定该对象是相同的，不能进行写入。此时如果我们使用相同的内容去new了像个对象，如果不进行重写的话，我们发现我们对比的就是两个对象的地址，我们new了两次那么两次的地址肯定是不一样的，会将两个对象放在不同的位置，达不到我们想要的结果。hashCode()用来定位要存放的位置，equal()用来判断是否相等，所以我们需要重写hashcode和equals，重写hashcode使得我们的hash值使用我们对象内容来映射，先找到对应的哈希表上是否有元素，如果有，然后重写我们的equals通过与该位置的对象的地址以及key、value值来进行比较两个对象是否相同，有任意的不同之处都证明我们不是相同的对象，可以插入，否则认为是相同的对象。

Java中抽象是值被abstract修饰的类或方法，如果一个类中有一个抽象方法，那么该类必须用abstract修饰，但是抽象类中可以不存在抽象方法，抽象类不能够进行实例化。普通类可以继承一个抽象类，那么这个类就是该抽象类的直接子类，子类可以调用该抽象类的非抽象方法，也可以重写该抽象类的所有方法。需要注意的是，一个普通类只能继承一个父类。
Java中的接口是用implement修饰，接口中只定义接口可以实现的方法而不给出具体的实现，继承了该接口的普通类需要实现该接口的所有的方法，接口可以说以被定义好的一种规范，所以实现了接口的普通类都需要遵守它。一个普通类可以实现多个接口，这个特点也弥补了单继承的缺点。

equals()和hashcode()都是Object类的方法，在没有重写的情况下，equals比较的是两个对象引用是否指向同一个对象，hashcode返回的是当前对象的地址经过hash函数映射得到的哈希值

一般我们想用HashMap存储对象时需要重写这两个方法，来保证集合中不出现重复Key，这里重复Key的定义是对象的属性不能完全相等，所以我们需要重写equals，来逐一比较两个对象的属性值，但是一定也要重写hashcode，因为hashmap是先通过调用hashcode得到一个哈希值，将该哈希值按数组长度取模得到一个哈希桶的位置，再通过equals方法依次比较哈希桶上元素的key，所以同时重写这两个方法，得以保证集合中不会出现重复key，如果只重写hashcode的情况下就会造成一个哈希桶上出现相同key的元素，如果只重写equals的情况下就会造成相同元素的key出现在不同哈希桶的位置上

对于hashcode方法最简单的重写方式就是依次调用对象中每一个属性的hashcode并相加。

抽象类是自下而上的，也就是将一系列具有相同属性和方法的类抽离出来的类，抽象类是不可以被实例化的，也就意味着它只是一个抽象的概念，普通类通过继承抽象类来具体化这个抽象类，使用抽象类可以让代码更加健壮可拓展性更强

而接口是自上而下的，通过定义一系列的行为也可以说一系列的规范，实现接口的类必须去遵守这些规范/行为。

平台无关指的是对于不同的操作系统，都可以用一种统一的格式执行代码，也就是一次编译，到处运行

我们编写的.java源程序只需要编译成.class字节码文件，之后让JVM去执行字节码文件，JVM为我们屏蔽了操作系统的差异性，所以只需要针对不同的操作系统实现对应的JVM就可以执行我们的java代码，在java开发者看来，java代码只是在一台虚拟机器上运行的，感受不到操作系统的存在。而且由于JVM只执行字节码文件，所以像kotlin这样的语言，只要可以编译成字节码文件，也可以在JVM上运行，这是JVM的语言无关性

辅助栈

class MinStack {
    // 两个栈：主栈和辅助栈
    Stack<Integer> st1;
    Stack<Integer> st2;

    public MinStack() {
        st1 = new Stack<>();
        st2 = new Stack<>();
    }

    public void push(int val) {
        if (st1.empty()) {
            st1.push(val);
            st2.push(val);
        } else {
            st1.push(val);
            int min = st2.peek();
            min = min < val ? min : val;
            st2.push(min);  // 辅助栈只记录当前的最小值
        }
    }

    public void pop() {
        st1.pop();
        st2.pop();
    }

    public int top() {
        return st1.peek();
    }

    public int getMin() {
        return st2.peek();
    }
}

辅助栈 pro

class MinStack {
    Stack<Node> st;

    // 用一个 Node 同时存储 val 和当前的 min 值
    class Node {
        int val;
        int min;

        Node(int val, int min) {
            this.val = val;
            this.min = min;
        }
    }

    public MinStack() {
        st = new Stack<Node>();
    }

    public void push(int val) {
        if (st.empty()) {
            Node tmp = new Node(val, val);
            st.push(tmp);
        } else {
            Node pre = st.peek();
            int min = pre.min < val ? pre.min : val;
            Node tmp = new Node(val, min);
            st.push(tmp);
        }
    }

    public void pop() {
        st.pop();
    }

    public int top() {
        return st.peek().val;
    }

    public int getMin() {
        return st.peek().min;
    }
}

进阶：辅助常量

class MinStack {
    Stack<Integer> st;
    int min;

    public MinStack() {
        st = new Stack<>();
    }

    public void push(int val) {
        if (st.empty()) {
            min = val;
            st.push(0);
        } else {
            int diff = val - min;  // 可能会发生溢出
            if (diff < 0) {   // 差值小于零，意味着当前 val 为最小，需要更新 min 值
                min = val;
            } 
            st.push(diff);
        }
    }

    public void pop() {
        int tmp = st.pop();
        if (tmp < 0) {   // 如果弹出了最小值，就要记得更新 min 值
            min = min - tmp;
        }
    }

    public int top() {
        return st.peek() < 0 ? min : st.peek() + min;
    }

    public int getMin() {
        return min;
    }
}

equals()方法是用来比较两个对象是否相等的。hashcode()是用来计算哈希码用来确定对象在哈希表中的位置的。比如你需要根据对象的内容来判断两个对象是否相等时，你就必须重写Object类的equals()方法，因为equals()方法Object类默认是根据对象的地址值是否相同判断两个对象是否相等。这时你就必须还要重写hashcode()方法，根据对象的内容计算哈希码，而不是根据对象的地址值计算哈希码。因为必须满足一个相等的对象的hashcode一定是相同的，但不相等的对象的hashcode可以相同，此时会产生哈希冲突。否则HashMap就不能正常使用。假设HashMap类的key重写了equals()方法，根据内容来比较两个对象是否相等，而没有重写hashcode()方法，默认使用Object类的hashcode()根据对象地址值计算哈希码。此时可能会出现一种情况：比如你put一个(key, value1)的键值对，后面又put一个(key, value2)键值对，然后你执行一个get(key)操作，取出来的值可能是value1而不是value2，为什么呢，因为这个key是第一个旧的key对象，你的key的hashcode是根据地址值计算的，而不是根据对象内容，两个key的内容虽然都是key，但地址值不一样，于是hashcode就不一样，所以(key, value1)和(key,value2)就位于不同的哈希槽上，于是HashMap中就出现两个内容相同的key。如果需要取出(key, value2)怎么办呢，你需要执行gey(key)（注意: key是第二个新的key对象，这样才能根据它的地址值计算出对应的哈希槽）。