面试题库java

发表于 | 分类于 | | 本文总阅读量 次

  1. 数组实现队列 http://blog.csdn.net/qq_25722767/article/details/52234509

  2. GC 的流程
    https://www.cnblogs.com/little-YTMM/p/5613642.html https://www.cnblogs.com/zhguang/p/3257367.html

  3. Java 软引用和弱引用的区别
    强引用（StrongReference）：只要某个对象有强引用与之关联，JVM必定不会回收这个对象，即使在内存不足的情况下，JVM宁愿抛出OutOfMemory错误也不会回收这种对象 软引用（SoftReference）：只有在内存不足的时候JVM才会回收该对象 弱引用（WeakReference）：当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象 虚引用（PhantomReference）：垃圾回收时回收，虚引用并不会决定对象的生命周期，无法通过引用取到对象值

  4. Java 中 this 编译时的原理 this调用本类中的属性，也就是类中的成员变量； this调用本类中的其他方法； this调用本类中的其他构造方法，调用时要放在构造方法的首行。

  5. final 变量用反射修改 public static void modify(Object object, String fieldName, Object newFieldValue) throws Exception {

    Field field = object.getClass().getDeclaredField(fieldName);

Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true); //Field 的 modifiers 是私有的
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);

if(!field.isAccessible()) {
field.setAccessible(true);
}

field.set(object, newFieldValue);

    }

    class Person {

    public final String firstName = "Mike";
public final String lastName = new String("Jordan"); //可被有效修改
public final float age = 50.5f;
public final Float height = 1.99f; //可被有效修改
public final Address address = new Address("aaa", "bbb"); //可被有效修改

public final String city; //可被有效修改

public Person(String city) {
this.city = city;
}

    }

  6. HashMap的内部结构，给定一个key，如何找到对应的value
    https://www.cnblogs.com/shipengzhi/articles/2087505.html

  7. volatile https://www.cnblogs.com/tangyanbo/p/6538488.html

  8. Java线程池有什么作用 在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 第三：提高线程的可管理性。 常用线程池：ExecutorService 是主要的实现类，其中常用的有 : Executors.newSingleThreadPool() 创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。 Executors.newFixedThreadPool() 创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。 Executors.newcachedTheadPool() 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。 Executors.newScheduledThreadPool() 创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。 https://www.jianshu.com/p/ade771d2c9c0 https://www.cnblogs.com/ruiati/p/6134131.html

  9. Java 动态代理 https://www.cnblogs.com/xiaoluo501395377/p/3383130.html

  10. 求 n 的 m 次幂 http://blog.csdn.net/derrantcm/article/details/47098373

  11. java 集合
    https://www.cnblogs.com/lwlxqlccc/p/6121307.html

  12. String 的 spit 实现 http://fangguanhong.iteye.com/blog/2069993

  13. Http和Https的区别 https://www.jianshu.com/p/37654eb66b58

  14. java线程池—ThreadPoolExecutor https://www.jianshu.com/p/ade771d2c9c0

  15. 冒泡排序 http://blog.csdn.net/u010853261/article/details/54891710

  16. 排序算法 http://blog.csdn.net/pzhtpf/article/details/7560294

  17. 抽象类和接口的区别 接口是对动作的抽象，而抽象类是对根源的抽象。 接口和抽象类都是继承树的上层，他们的共同点如下：1) 都是上层的抽象层。2) 都不能被实例化3) 都能包含抽象的方法，这些抽象的方法用于描述类具备的功能，但是不比提供具体的实现。他们的区别如下：1) 在抽象类中可以写非抽象的方法，从而避免在子类中重复书写他们，这样可以提高代码的复用性，这是抽象类的优势；接口中只能有抽象的方法。2) 一个类只能继承一个直接父类，这个父类可以是具体的类也可是抽象类；但是一个类可以实现多个接口。Java语言中类的继承是单继承原因是：当子类重写父类方法的时候，或者隐藏父类的成员变量以及静态方法的时候，JVM使用不同的绑定规则。如果一个类有多个直接的父类，那么会使绑定规则变得更复杂。为了简化软件的体系结构和绑定机制，java语言禁止多继承。接口可以多继承，是因为接口中只有抽象方法，没有静态方法和非常量的属性，只有接口的实现类才会重写接口中方法。因此一个类有多个接口也不会增加JVM的绑定机制和复杂度。

  18. java基本数据类型 8位：Byte（字节型）
    16位：short（短整型）、char（字符型）
    32位：int（整型）、float（单精度型/浮点型）
    64位：long（长整型）、double（双精度型）
    最后一个：boolean(布尔类型）

  19. Java堆的实现、排序 http://blog.csdn.net/idealemail/article/details/51382837

  20. 数组中重复数字 http://blog.csdn.net/zjkc050818/article/details/72800175

  21. 字符串中判断另一个字符串是否存在

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    static int indexOf(String source,
                       String target,
                       int fromIndex) {
        if (fromIndex >= source.count) {
            return (target.count == 0 ? source.count : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        if (target.count == 0) {
            return fromIndex;
        }

        char first = target.charAt(0);
        int max = (source.count - target.count);

        for (int i = fromIndex; i <= max; i++) {
            /* Look for first character. */
            if (source.charAt(i)!= first) {
                while (++i <= max && source.charAt(i) != first);
            }

            /* Found first character, now look at the rest of v2 */
            if (i <= max) {
                int j = i + 1;
                int end = j + target.count - 1;
                for (int k = 1; j < end && source.charAt(j)
                         == target.charAt(k); j++, k++);

                if (j == end) {
                    /* Found whole string. */
                    return i;
                }
            }
        }
        return -1;
    }

  22. ThreadLocal 使用及原理
    https://www.cnblogs.com/coshaho/p/5127135.html

  23. Java 泛型 https://www.cnblogs.com/demingblog/p/5495610.html

  24. Java 内部类 http://blog.csdn.net/roamer314/article/details/48598633

  25. Java ConcurrentHashMap的原理
    https://www.cnblogs.com/chengxiao/p/6842045.html

  26. 线程的几种状态
    http://blog.csdn.net/sinat_36042530/article/details/52565296 https://www.cnblogs.com/wxd0108/p/5479442.html

  27. Java 双亲委派机制
    https://www.cnblogs.com/wxd0108/p/6681618.html

  28. Java 运算符 https://jingyan.baidu.com/article/1612d5008ff5b7e20f1eee4c.html

坚持原创技术分享，您的支持将鼓励我继续创作！