Java基础知识收集整理

1.面向对象都有哪些特性

　　继承、封装、多态性、抽象

2.Java中实现多态的机制是什么？

　　继承与接口

3.Java中异常分为哪些种类

　　3.1按照异常需要处理的时机分为编译时异常（CheckedException）和运行时异常（RuntimeException）。

　　3.2对于编译时异常的处理方法有两种：

（1）当前方法知道如何处理该异常，则用try…catch块来处理该异常。

（2）当前方法不知道如何处理，则在定义该方法时声明抛出该异常。

　　3.3运行时异常，如果显式声明或者捕获将会对程序的可读性和运行效率影响很大，所以由系统自动检测并将它们交给缺省的异常处理程序，当然如果有处理要求也可以显式捕获它们。

4.Java的数据类型

　　4.1Java的基本数据类型都有哪些，各占几个字节

　　　　Byte 1   char 2  short 2  int 4  float 4  double 8  long 8  boolean 1

　　4.2ing是基本数据类型吗？可以被继承吗？

　　　　String是引用类型，底层用char数组实现的。因为String是final类，在java中被final修饰的类不能被继承，因此String当然不可以被继承。

5.Java的IO

5.1.Java中有几种类型的流

字节流和字符流。字节流继承于InputStream和OutputStream，字符流继承于InputStreamReader和OutputStreamWriter。

5.2字节流如何转为字符流

字节输入流转字符输入流通过InputStreamReader实现，该类的构造函数可以传入InputStream对象。

字节输出流转字符输出流通过OutputSreamWriter实现，该类的构造函数可以传入OutputStream对象。

6.Java的集合

　　6.1ArrayList、HashSet、HashMap是线程安全的吗？如果不是想要的线程安全的集合怎么办？

　　　　每个方法都没有加锁，显然都是线程不安全的。

　　　　在集合中Vector和HashTable是线程安全的。

　　　　Collections工具类提供了相关的API，可以让上面3个不安全的集合变为安全，如下：

　　　　　　Collections.synchronizedCollection(c)

　　　　　　Collections.synchronizedList(list)

　　　　　　Collections.synchronizedMap(m)

　　　　　　Collections.synchronizedSet(s)

　　6.2并发集合和普通集合如何区别？

　　　　并发集合常见的有ConCurrentHashMap、ConcurrentLinkedQueue、ConcurrentLinkedDeque等。并发集合位于java.util.concurrent包下，是jdk1.5之后才有的，主要作者是Doug Lea(http://baike.baidu.com/view/3141057.http)完成的。

　　　　在java中有普通集合、同步（线程安全）的集合、并发集合。普通集合通常性能最高，但是不保证多线程的安全性和并发的可靠性。线程安全集合仅仅是给集合添加了synchronized同步锁，严重牺牲了性能，而且对并发的效率就更低了，并发集合则通过复杂的策略不仅保证了多线程的安全又提高的并发时的效率。

　　　　ConcurrentHashMap是线程安全的HashMap的实现，默认构造同样有initialCapacity和loadFactor属性，不过还多了一个concurrencyLevel属性，三属性默认值分别为16、0.75及16。其内部使用锁分段技术，维持着锁Segment的数组，在Segment数组中又存放着Entity[]数组，内部hash算法将数据较均匀分布在不同锁中。

　　　　Put操作：并没有在此方法上加上synchronized，首先对key.hashcode进行hash操作，得到key的hash值。Hash操作的算法和map不同，根据此hash值计算并获取其对应的数组中的Segment对象（继承自ReentrantLock），接着调用此Segment对象的put方法来完成当前操作。

ConcurrentHashMap基于concurrencyLevel划分出了多个Segment来对key-value进行存储，从而避免每次put操作都得锁住整个数组。在默认的情况下，最佳情况下可允许16个线程并发无阻塞的操作集合对象，尽可能地减少并发时的阻塞现象。

Get(key)

首先对key.hashCode进行hash操作，基于其值找到对应的Segment对象，调用其get方法完成当前操作。而Segment的get操作首先通过hash值和对象数组大小减1的值进行按位与操作来获取数组上对应位置的HashEntry。在这个步骤中，可能会因为对象数组大小的改变，以及数组上对应位置的HashEntry产生不一致性，那么ConcurrentHashMap是如何保证的？

对象数组大小的改变只有在put操作时有可能发生，由于HashEntry对象数组对应的变量是volatile类型的，因此可以保证如HashEntry对象数组大小发生改变，读操作可看到最新的对象数组大小。

在获取到了HashEntry对象后，怎么能保证它及其next属性构成的链表上的对象不会改变呢？这点ConcurrentHashMap采用了一个简单的方式，即HashEntry对象中的hash、key、next属性都是final的，这也就意味着没办法插入一个HashEntry对象到基于next属性构成的链表中间或末尾。这样就可以保证当获取到HashEntry对象后，其基于next属性构建的链表是不会发生变化的。

ConcurrentHashMap默认情况下采用将数据分为16个段进行存储，并且16个段分别持有各自不同的锁Segment，锁仅用于put和remove等改变集合对象的操作，基于volatile及HashEntry链表的不变性实现了读取的不加锁。这些方式使得ConcurrentHashMap能够保持极好的并发支持，尤其是对于读取比插入和删除频繁的Map而言，而它采用的这些方法也可谓是对于Java内存模型、并发机制深刻掌握的体现。

7.Java的多线程

　　7.1多线程的两种创建方式

　　　　Java.lang.Thread类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以可以继承java.lang.Thread类或者直接实现Runnable接口来重写run()方法实现线程。

　　7.2在java中wait和sleep方法的不同？

　　　　最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。

　　7.3synchronized和volatile关键字的作用

　　　　一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

　　　　（1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

　　　　（2）禁止进行指令重排序。

　　　　Volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；

　　　　Synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。

　　　　（1）volatile仅能使用在变量级别；synchronized则可以使用在变量、方法和类级别的。

　　　　（2）volatile仅能实现变量的修改可见性，并不能保证原子性；synchronized则可以保证变量的修改可见性和原子性。

　　　　（3）volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。

　　　　（4）volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化。

　　7.4什么是线程池，如何使用

　　　　线程池就是事先将多个线程对象放到一个容器中，当使用的时候就不用new线程而是直接去池中拿线程即可，节省了开辟子线程的时间，提高了代码的执行效率。

　　　　在JDK的java.util.concurrent.Executors中提供了生成多种线程池的静态方法：

　　　　　　ExecutorService newCanchedThreadPool = Excutors.newCachedThreadPool();

　　　　　　ExecutorService newFixedThreadPool = Excutors.newFixedThreadPool(4);

　　　　　　ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(4);

　　　　　　ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();

　　　　然后调用他们的execute方法即可。

　　7.5线程池的理解

　　　　说一下线程池如何用、线程池的好处、线程池的启动策略

　　　　合理利用线程池能够带来三个好处：

　　　　　　第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

　　　　　　第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

　　　　　　第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。

　　7.6线程池的启动策略

　　　　（1）线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。

　　　　（2）当调用execute()方法添加一个任务时，线程池会做如下判断：

　　　　a.如果正在执行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；

　　　　 b.如果正在执行的线程数量大于或等于corePoolSize，那么将这个任务放入队列；

　　　　c.如果这时候队列满了，而且正在执行的线程数量小于maximumPoolSize，那么还是要创建线程运行这个任务；

　　　　d.如果队列满了，而且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会抛出异常，告诉调用者“不能再接受任务了”。

　　（3）当一个线程完成任务时，它会从队列中取下一个任务来执行。

　　（4）当一个线程无事可做，超过一定的时间（keyAliveTime）时，线程池会判断，如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到coorPoolSize的大小。

　　7.7如何控制某个方法允许并发访问线程的大小？

　　　　可以使用Semaphore控制，就是信号，初始化n个信号，在线程中，运行semaphore.acquire()申请请求，这样最多只能有n个线程并发访问，多余n个线程时就排队等待。线程完成后释放信号，这样新的线程就可以使用了。

8.Java中的反射

　　8.1Java中反射的理解

　　　　Java中的反射首先是能够获取到Java中要反射类的字节码，获取字节码有三种方法，1.Class.forName(className)2.类名.Class3.this.getClass()。然后将字节码中的方法、变量、构造函数等映射成相应的Method、Filed、Contructor等类，这些类提供了丰富的方法可以被使用。

　　8.2动静态代理的区别，什么场景使用？

　　　　静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。

　　　　静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道。

　　　　动态代理是显示JDK里的InvocationHandler接口的invoke方法，但注意的是代理的是接口，也就是业务类必须要实现接口，通过Proxy里的newProxyInstance得到代理对象。

　　　　还有一种动态代理CGLIB，代理的是类，不需要业务类继承接口，通过派生的子类来实现代理。通过在运行时，动态修改字节码达到修改类的目的。

　　　　AOP编程就是基于动态代理实现的，比如著名的Spring框架、Hibernate框架等等都是动态代理的使用例子。

9.Java中的回收机制

　　9.1.Java垃圾回收机制和常见算法

　　　　Sun公司只定义了垃圾回收机制规则而不局限于其实现算法，因此不同厂商生产的虚拟机采用的算法也不尽相同。

　　　　GC（Garbage Collector）在回收对象前首先必须发现那些无用的对象，如何去发现定位这些无用的对象？通常的搜素算法如下：

　　　　　　（1）引用计数器算法（废弃）

　　　　　　引用计数器算法是给每个对象设置一个计数器，当有地方引用这个对象的时候，计数器+1，当引用失效的时候，计算器-1，当计数器为0的时候，JVM就认为对象不再被使用，是“垃圾”了。

　　　　　　引用计数器实现简单，效率高；但是不能解决循环引用问题（A对象引用B对象，B对象引用A对象，但是A，B对象已不再被任何其他对象引用），同时每次计数器的增加和减少都带来了很多额外的开销，所以在JDK1.1之后，这个算法就不再使用了。

　　　　　　（2）根搜索算法（使用）

　　　　　　　　　根搜素算法是通过一些“GC Roots”对象作为起点，从这些节点开始往下搜索，搜索通过的路径成为引用链（Reference Chain），当一个对象没有被GC Roots的引用链连接的时候，说明这个对象是不可用的。

　　　　GC Roots对象包括：

　　　　　　a.虚拟机栈（栈帧中的本地变量表）中的引用的对象。

　　　　　　b.方法区域中的类静态属性引用的对象。

　　　　　　c.方法区域中常量引用的对象。

　　　　　　d.本地方法栈中JNI（Native方法）的引用的对象。

　　　　通过上面的算法搜索到无用对象之后，就是回收过程，回收算法如下：

　　　　　　（1）标记-清除算法（Mark-Sweep）（DVM使用的算法）

　　　　　　　　标记-清除算法包括连个阶段：“标记”和“清除”。在标记阶段，确定所有要回收的对象，并做标记。清除阶段紧随标记阶段，将标记阶段确定不可用的对象清除。标记-清除算法是基础的收集算法，标记和清除阶段的效率不高，而且清楚后回产生大量的不连续空间，这样当程序需要分配大内存对象时，可能无法找到足够的连续空间。

　　　　　　（2）复制算法（Copying）

　　　　　　　　复制算法是把内存分成大小相等的两块，每次使用其中一块，当垃圾回收的时候，把存活的对象复制到另一块上，然后把这块内存整个清理掉。复制算法实现简单，运行效率高，但是由于每次只能使用其中的一半，造成内存的利用率不高。现在的JVM用复制方法收集新生代，由于新生代中大部分对象（98%）都是朝生夕死的，所以两块内存的比例不是1:1（大概是8:1）。

　　　　　　（3）标记-整理算法（Mark-Compact）

　　　　　　　　标记-整理算法和标记-清除算法一样，但是标记-整理算法不是把存活对象复制到另一块内存，而是把存活对象往内存的一端移动，然后直接回收边界以外的内存。标记-整理算法提高了内存的利用率，并且它适合在收集对象存活时间较长的老年代。

　　　　　　（4）分代收集（Generational Collection）

　　　　　　　　分代收集是根据对象的存活时间把内存分为新生代和老生代，根据各个代对象的存活特点，每个代采用不同的垃圾回收算法。新生代采用复制算法，老生代采用标记-整理算法。垃圾算法的实现涉及大量的程序细节，而且不同的虚拟机平台实现的方法也各不相同。

　　9.2.JVM的内存结构和内存分配

　　　　（1）java内存模型

　　　　　　Java虚拟机将其管辖的内存大致分三个逻辑部分：方法区（Method Area）、Java栈和Java堆。

　　　　　　a.方法区是静态分配的，编译器将变量绑定在某个存储位置上，而且这些绑定不会再运行时改变。常数池，源代码中的命名常量、String常量和static变量保存在方法区。

　　　　　　b.Java Stack是一个逻辑概念，特点是后进先出。一个栈的空间可能是连续的，也可能是不连续的。最典型的Stack应用是方法的调用，Java虚拟机每调用一次方法就创建一个方法帧（frame），退出该方法则对应的方法帧被弹出（pop）。栈中存储的数据也是运行时确定的。

　　　　　　c.Java堆分配（heap allocation）意味着以随意的顺序，在运行时进行存储空间分配和回收的内存管理模型。堆中存储的数据常常是大小、数量和生命期在编译时无法确定的。Java对象的内存总是在heap中分配。

　　　　（2）Java内存分配

　　　　　　a.基础数据类型直接在栈空间分配。

　　　　　　b.方法的形式参数，直接在栈空间分配，当方法调用完成后从栈空间回收。

　　　　　　c.引用数据类型，需要用new来创建，即在栈空间分配一个地址空间，又在堆空间分配对象的类变量。

　　　　　　d.方法的引用参数，在栈空间分配一个地址空间，并指向堆空间的对象区，当方法调用完后从栈空间回收。

　　　　　　e.局部变量new出来时，在栈空间和堆空间中分配空间，当局部变量生命周期结束后，栈空间立即被回收，堆空间区域等待GC回收。

　　　　　　f.方法调用时传入的实际参数，现在栈空间分配，在方法调用完成后从栈空间释放。

　　　　　　g.字符串常量在DATA区域分配，this在堆空间分配。

　　　　　　h.数组即在栈空间分配数组名称，又在堆空间分配数组实际的大小。

　　9.3.Java中引用类型都有哪些？

　　　　Java中对象的引用分为四种级别，这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

　　　　（1）强引用

　　　　　　如果一个对象被人拥有强引用，那么垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象阿里解决内存不足问题。

　　　　　　Java的对象是位于heap中的，heap中对象有强可及对象、软可及对象、弱可及对象、虚可及对象和不可到达对象。应用的强弱顺序是强、软、弱和虚。对于对象是属于哪种可及的对象，由他的最强的引用决定。

　　　　　　String abc = new String(“abc”);//强引用，abc为强可及

　　　　　　SoftReference<String> softRef = new SoftReference<String>(abc);//软引用

　　　　　　WeakReference<String> weakRef = new WeakReference<String>(abc);//弱引用

　　　　　　abc=null;//abc软可及

　　　　　　softRef.clear();//abc变成弱可及

　　　　（2）软引用

　　　　　　如果一个对象只具有软引用，那么如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

　　　　　　软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

　　　　　　软引用主要用于内存敏感的高速缓存。在jvm报告内存不足之前会清除所有的软引用，这样以来gc就有可能手机软可及的对象，可能解决内存吃紧问题，避免内存溢出。什么时候会被收集取决于gc的算法和gc运行时可用内存的大小。当gc决定要收集软引用时执行步骤如下：（以上面的softRef为例）

　　　　　　　　a.首先将softRef的referent(abc)设置为null，不再引用heap中的new String(“abc”)对象。

　　　　　　　　b.将heap中的new String(“abc”)对象设置为可结束的（finalizable）。

　　　　　　　　c.当heap中的new String(“abc”)对象的finalize()方法被运行而且该对象占用的内存被释放，softRef被添加到它的ReferenceQueue（如果有的话）中。

　　　　　　　　注意：对ReferenceQueue软引用和弱引用可有可无，但虚引用必须有。

　　　　　　被Soft Reference指到的对象，即使没有任何Direct Reference，也不会被清除。一直要到JVM内存不足且没有Direct Reference时才会清除，SoftReference是用来设计objct-cache之用的。如此一来SoftReference不但可以把对象cache起来，也不会造成内存不足的错误（OutOfMemoryError）。

　　　　（3）弱引用

　　　　　　如果一个对象只具有弱引用，那该类就是可有可无的对象，因为只要该对象被gc扫描到随时都会把它干掉。

　　　　　　弱引用和软引用的区别：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现只具有弱引用的对象。

　　　　　　弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象呗垃圾回收器回收，Java虚拟机就会把这个弱引用加到与之关联的引用队列中。

　　　　（4）虚引用

　　　　　　“虚引用”与其他集中引用不同，虚引用并不决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。

　　　　　　虚引用与软引用和弱引用的区别：虚引用必须和引用队列（ReferneceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还是虚引用，就会在回收对象的内存之前，把这个虚引用假如到与之关联的引用队列中。程序可以通过判断引用队列中是否加入了虚引用。来了解被引用的对象是否要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在引用的对象的内存被回收之前采用必要的行动。

　　　　　　建立虚引用之后通过get方法返回结果始终为null，通过源代码会发现，虚引用通常会把引用的对象写进referent，只是get方法返回结果为null。和gc交互的过程：a.不把referent设置为null，直接把heap中的new String(“abc”)对象设置为可结束的（finalizable）。b.与软引用和弱引用不同，先把PhantomReference对象添加到它的ReferencQueue中，然后在释放虚可及的对象。

10.Java的类加载器

　　10.1.Java的类加载器的种类都有哪些？

　　　　（1）根类加载器（Bootstrap）---C++写的，看不到源码

　　　　（2）扩展类加载器（Extension）---加载位置：jre\lib\ext中

　　　　（3）系统（应用）类加载器（System\App）---加载位置：classpath中

　　　　（4）自定义加载器（必须继承ClassLoader）

　　10.2.类什么时候被初始化？

　　　　（1）创建类的实例，也就是new一个对象。

　　　　（2）访问某个类或接口的静态变量，或者对该静态变量赋值。

　　　　（3）调用类的静态方法。

　　　　（4）反射。

　　　　（5）初始化一个类的子类。

　　　　（6）JVM启动时标明的启动类，即文件名和类名相同的那个类。

　　　　只有这6种情况才会导致类的初始化。

　　10.3.类的初始化步骤

　　　　（1）如果这个类还没有被加载和链接，那先进行加载和链接。

　　　　（2）假如这个类存在直接父类，并且这个类还没有被初始化（注意：在一个类加载器中，类智能初始化一次），那就初始化直接的父类（不适用于接口）。

　　　　（3）假如类中存在初始化语句（如static变量和static块），那就依次执行这些初始化语句。