八股文第二天

时间: 2022年7月21日

一些简单的我就直接放答案了，不分析了

---

第一题：String，StingBuff,StringBuilder区别

String是字符串常量
StringBuffer是字符串变量(线程安全)
StringBuilder 字符串变量（非线程安全)

String 中的 String 类中使用 final 关键字修饰字符数组来保存字符串，private final char value[] ，String 对象是不可变的，也就可以理解为常量，线程安全。

AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了 一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。
StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。

StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

小结：
（1）如果要操作少量的数据用 String；
（2）多线程操作字符串缓冲区下操作大量数据用 StringBuffer；
（3）单线程操作字符串缓冲区下操作大量数据用 StringBuilder。

第二题：接口和抽象类的区别是什么？（必会）

实现：抽象类的子类使用 extends 来继承，接口必须使用 implements 来实现接口。

构造函数：抽象类可以有构造函数；接口不能有。

main 方法：抽象类可以有 main 方法，并且我们能运行它；接口不能有 main 方 法。

实现数量：类可以实现很多个接口；但是只能继承一个抽象类。
访问修饰符：接口中的方法默认使用 public 修饰；抽象类中的方法可以是任意访问修饰符。

第三题：string 常用的方法有哪些？

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的
byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

第四题：什么是单例模式？有几种？（必会）

单例模式：某个类的实例在 多线程环境下只会被创建一次出来。
单例模式有饿汉式单例模式、懒汉式单例模式和双检锁单例模式，枚举。

//饿汉式：线程不安全，一开始就初始化。
//	特点： 占用内存，节约获取时间,只要用到了这个类，就创建了对象
package day16;

//这个类只能创建一个对象
public class Person {
    //把构造方法私有化
    private Person(){

    }
    //创建一个对象
    private static Person p = new Person();

    //创建方法返回对象
    public static Person getInstance(){
        return p;
    }

    public static void main(String[] args) {

        //调用方法
        Person p1 = Person.getInstance();
        Person p2 = Person.getInstance();
        Person p3 = Person.getInstance();

        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
/*
day16.Person1@776ec8df
day16.Person1@776ec8df
day16.Person1@776ec8df
*/
    }
}

//懒汉式：线程安全，延迟初始化。
//​不提前创建对象，调用获取方法的时候才创建。
​//特点：不多占用内存，浪费获取时间
package day16;
public class Person1 {
    //构造方法私有化
    private Person1(){
    }

    //创建对象
    private static Person1 p ;

    //定义方法返回对象
    public static synchronized Person1 getInstance(){
        if(p == null){
            p = new Person1();
        }

        return p;
    }
    public static void main(String[] args) {
        //获取对象
        Person1 p1 = Person1.getInstance();
        Person1 p2 = Person1.getInstance();
        Person1 p3 = Person1.getInstance();
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
        /*
day16.Person1@776ec8df
day16.Person1@776ec8df
day16.Person1@776ec8df
*/
    }
}

//双检锁：线程安全，延迟初始化。
//安全且在多线程情况下能保持高性能
package day16;

public class Person2 {
    private volatile static Person2 person2;
    private Person2(){}
    
    public static Person2 getPerson2(){
        if (person2 == null){
            synchronized (Person2.class){
                if (person2 ==null){
                    person2=new Person2();
                }
            }
        }
        return person2;
    }

    public static void main(String[] args) {
        Person2 p1 = Person2.getPerson2();
        Person2 p2 = Person2.getPerson2();
        System.out.println("p1 = " + p1);
        System.out.println("p2 = " + p2);
    }
}

//枚举
//多线程安全：是
//它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化
public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}