java面试题

1.面向对象的三大基本特性：
封装：也就是把客观事物封装成抽象的类（向上抽象），并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏（访问权限）。
继承：是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
多态：是指父类的引用指向子类的对象（向上转型），需要子类的特有功能时就向下转型。
2.多态的两种表现形式
重载：是发生在同一类中，具有相同的方法名，参数的个数，类型，顺序不同
重写：是发生在两个类中（父类和子类），具有相同的方法名，参数的个数，参数，类型相同
3.常见排序算法

• 冒泡排序

   /**
     * 比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置
     *
     * @param arr
     * @return
     */
    private int[] bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }

• 选择排序

   /**
     * 遍历整个序列，将最小的数放在最前面
     *
     * @param arr
     * @return
     */
    private int[] selectionSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int temp = arr[i];
            int tempPosition = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < temp) {
                    temp = arr[j];
                    tempPosition = j;
                }
            }
            arr[tempPosition] = arr[i];
            arr[i] = temp;
        }
        return arr;
    }

• 插入排序

   /**
     * 将第一个数和第二个数排序，然后构成一个有序序列将第三个数插入进去，构成一个新的有序序列。对第四个数、第五个数……直到最后一个数，重复第二步。
     *
     * @param arr
     * @return
     */
    private int[] insertSort(int[] arr) {
        int temp;
        for (int i = 1; i < arr.length; i++) {
            temp = arr[i];
            int j = i - 1;
            while (j < 0 && arr[j] > temp) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = temp;
        }
        return arr;
    }

4.String StringBuffer StringBuilder
这三个类之间的区别主要是在两个方面，即运行速度和线程安全这两方面。运行速度快慢为：StringBuilder > StringBuffer > String，因为String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。 在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

• String：适用于少量的字符串操作的情况
• StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
• StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

5.List Set Map
List 提供了一个有序且有索引的容器，它允许重复值的出现。Set 提供了一个无序的唯一对象的容器，也就是说，Set 不允许重复值，而 Map 提供的则是一个基于键值对以及哈希的数据结构。

Java 中 List 接口最流行的几个实现类是 ArrayList、LinkedList 和 Vector。
Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。
Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。

如果你经常会使用索引来对容器中的元素进行访问，那么 List 是你的正确的选择。如果你已经知道索引了的话，那么 List 的实现类比如 ArrayList 可以提供更快速的访问。
如果你想容器中的元素能够按照它们插入的次序进行有序存储，那么还是 List，因为 List 是一个有序容器，它按照插入顺序进行存储。

如果你想保证插入元素的唯一性，也就是你不想有重复值的出现，那么可以选择一个 Set 的实现类，比如 HashSet、LinkedHashSet 或者 TreeSet。所有 Set 的实现类都遵循了统一约束比如唯一性，而且还提供了额外的特性比如 TreeSet 还是一个 SortedSet，所有存储于 TreeSet 中的元素可以使用 Java 里的 Comparator 或者 Comparable 进行排序。LinkedHashSet 也按照元素的插入顺序对它们进行存储。

如果你以键和值的形式进行数据存储那么 Map 是你正确的选择。你可以根据你的后续需要从 Hashtable、HashMap、TreeMap 中进行选择。

6.抽象类和接口的区别

• 一个类只能继承一个抽象类，而一个类可以实现多个接口
• 抽象类中可以含有抽象方法和非抽象的方法，而接口中都是抽象的方法
• 抽象类中可以有各种类型的变量和方法而接口中的成员变量只能是public static final类型的
• 抽象类中可以有静态代码块和静态方法，接口中不能有静态代码块和静态方法

7.java四种引用类型（怎样理解gc垃圾回收机制）

• 强引用（必不可少） 垃圾回收器绝对不会回收它。如Object obj = new Object(); obj便是内存不足时，java虚拟机宁愿抛出OutofMemorryError错误导致程序崩溃异常终止，也 不会回收强引用的对象。
• 软引用（可有可无）如果内存空间足够，垃圾回收就不会回收它，如果内存空间不足了，就会回收这些对象的内存
• 弱引用（可有可无）垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存，当发生GC的时候，弱引用的对象总是被回收
• 虚引用 当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前把这个虚引用加入到与之前关联的引用队列中。与弱引用不同点就是虚引用必须和引用队列联合使用。

8.单例种类和各自优缺点

饿汉式单例类，在类初始化时，已经自行实例化
此类加载时就初始化，单例对象较大时会影响系统加载速度
public class Singleton {
    private Singleton() {}

    private static final Singleton singleton = new Singleton();

    public static Singleton getInstance() {
        return singleton;
    }
}

懒汉式单例类,只有访问到单例对象的时候才去检查和实例化单例对象
多线程访问需要加同步锁影响访问效率
public class Singleton {
    private Singleton() {}

    private static Singleton singleton = null;

    public synchronized static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

登记式单例类,使用静态内部类作为Singleton容器
特点：能延迟加载，又能保证线程安全 原理是直接用classLoader(jvm类加载机制) 进行异步加锁的问题，并减少了内存消耗保证了初始化instance时只有一个线程，所以是线程安全的
public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static Singleton singleton = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.singleton;
    }
}