equals和==有什么区别
"=="是是不是指向同一个内存空间。
"equals"是判断所指向的内存空间的值是不是相同。
"equals"是方法。
"=="是运算符合。
"=="比"equals"运行速度快，因为"=="只是比较引用。
权限修饰符
抽象类和接口区别
- 定义和实现功能的限制不同。在接口中只允许定义，不允许对方法进行实现，并且接口中定义的属性不可改变；在抽象类中可以有一般方法的实现，也可以有抽象方法，可以定义变量。
- 一个类只能继承一个父类，但是一个类可以实现多个接口
修饰的关键字有区别。在接口中，所有方法都只能用public，abstract这两个关键字来修饰，所有定义的成员变量为public，static，final。而在抽象类中，可以有自己的成员变量和方法，也可以有非抽象的成员方法；而且，在抽象类中，抽象类的成员变量默认为default，当然也可以自行定义为public，protected，private，这些成员变量在子类中可以重新被定义也可以重新被赋值；但是抽象类中的抽象方法（方法前有abstract修饰）不能用private，static，synchronized和native等访问修饰符来修饰。 - 应用的功能场景不同。接口被用于实现比较常用的功能，便于日后维护或者添加删除方法，而抽象类更倾向于公共类的角色，不适用于日后重对里面的代码进行修改。
深拷贝和浅拷贝
浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。
&和&& （|和||同理）
1．运算符性质不同。
&是一个位运算符。
&&是一个逻辑运算符。
2．作用不同。
&是将两个二进制的数逐位相与，结果是相遇之后的结果。
&&就是判断两个表达式的真假性，只有两个表达式同时为真才为真，有一个为假则为假，具有短路性质。
线程产生死锁的四个必备条件及解决方法
产生死锁的四个必要条件
（1） 互斥条件：该资源任意一个时刻只由一个线程占用。
（2）请求与保持条件：一个进程因请求某资源而堵塞时，对已获得的资源保持不放。
（3）不剥夺条件：线程已获得的资源在未使用完之前不能被其他线程强行掠夺，只有自己使用完之后才能释放资源。
（4）循环等待条件：**若干进程之间形成的一种头尾相接的循环等待资源关系。
解决方法
（1）破坏请求与保持条件：一次性申请所有需要用到的资源。
（2）破坏不剥夺条件：占用部分资源的线程进一步申请不到其他的资源时，可以主动释放它占有的资源。
（3）破坏循环等待条件：按某种序申请资源，释放资源则反序释放，破坏循环等待条件。
强软弱虚引用
1，强引用
强引用是使用最多的引用，如果一个对象具有强引用，那么在该对象时不会被gc所回收的。
Object object = new Object(); //强引用
当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。如果不使用时，要通过如下方式来弱化引用，如下：
object = null //将该对象弱化，这样一来gc才能够成功回收该数据
在一个方法的内部有一个强引用，这个引用保存在栈中，而真正的引用内容（Object）保存在堆中。当这个方法运行完成后就会退出方法栈，则引用内容的引用不存在，这个Object会被回收。
但是如果这个object是全局的变量时，就需要在不用这个对象时赋值为null，因为强引用不会被垃圾回收。
2、软引用（SoftReference）
如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。
String str=new String(“abc”); // 强引用
SoftReference softRef=new SoftReference(str); // 软引用
3、弱引用（WeakReference）
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
String str=new String(“abc”);
WeakReference abcWeakRef = new WeakReference(str);
str=null
当垃圾回收器进行扫描回收时等价于：
str = null;
System.gc();
如果这个对象是偶尔的使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，那么你应该用 WeakReference 来记住此对象。
下面的代码会让str再次变为一个强引用：
String abc = abcWeakRef.get();
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
当你想引用一个对象，但是这个对象有自己的生命周期，你不想介入这个对象的生命周期，这时候你就是用弱引用。
package reference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.LinkedList;
public class ReferenceTest {
private static ReferenceQueue<VeryBig> rq = new ReferenceQueue<VeryBig>();
public static void checkQueue() {
Reference<? extends VeryBig> ref = null;
while ((ref = rq.poll()) != null) {
if (ref != null) {
System.out.println("In queue: "
+ ((VeryBigWeakReference) (ref)).id);
}
}
}
public static void main(String args[]) {
int size = 3;
LinkedList<WeakReference<VeryBig>> weakList = new LinkedList<WeakReference<VeryBig>>();
for (int i = 0; i < size; i++) {
weakList.add(new VeryBigWeakReference(new VeryBig("Weak " + i), rq));
System.out.println("Just created weak: " + weakList.getLast());
}
System.gc();
try { // 下面休息几分钟，让上面的垃圾回收线程运行完成
Thread.currentThread().sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
checkQueue();
}
}
class VeryBig {
public String id;
// 占用空间,让线程进行回收
byte[] b = new byte[2 * 1024];
public VeryBig(String id) {
this.id = id;
}
protected void finalize() {
System.out.println("Finalizing VeryBig " + id);
}
}
class VeryBigWeakReference extends WeakReference<VeryBig> {
public String id;
public VeryBigWeakReference(VeryBig big, ReferenceQueue<VeryBig> rq) {
super(big, rq);
this.id = big.id;
}
protected void finalize() {
System.out.println("Finalizing VeryBigWeakReference " + id);
}
}
结果为
Just created weak: reference.VeryBigWeakReference@570f80a9
Just created weak: reference.VeryBigWeakReference@3ac803e6
Just created weak: reference.VeryBigWeakReference@21780f30
Finalizing VeryBig Weak 0
Finalizing VeryBig Weak 2
Finalizing VeryBig Weak 1
In queue: Weak 0
In queue: Weak 1
In queue: Weak 2
4、虚引用（PhantomReference）
“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。
Java4种引用的级别由高到低依次为：
强引用 > 软引用 > 弱引用 > 虚引用
TCP 和 UDP
1、TCP 面向连接（如打电话要先拨号建立连接）; UDP 是无连接的，即发送数据之前不需要建立连接。
2、TCP 提供可靠的服务。也就是说，通过 TCP 连接传送的数据，无差错，不丢失，不重复，且按序到达；UDP 尽最大努力交付，即不保证可靠交付。
3、TCP 面向字节流，实际上是 TCP 把数据看成一连串无结构的字节流；UDP 是面向报文的。UDP 没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）
4、每一条 TCP 连接只能是点到点的；UDP支持一对一，一对多，多对一和多对多的交互通信。
5、TCP 首部开销 20 字节；UDP 的首部开销小，只有 8 个字节。
6、TCP 的逻辑通信信道是全双工的可靠信道，UDP 则是不可靠信道。
单例模式的实现有多种方式，如下所示：
1、懒汉式，线程不安全
是否 Lazy 初始化：是
是否多线程安全：否
实现难度：易
描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。
实例
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
接下来介绍的几种实现方式都支持多线程，但是在性能上有所差异。
2、懒汉式，线程安全
是否 Lazy 初始化：是
是否多线程安全：是
实现难度：易
描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。
实例
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
3、饿汉式
是否 Lazy 初始化：否
是否多线程安全：是
实现难度：易
描述：这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。
实例
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
4、双检锁/双重校验锁（DCL，即 double-checked locking）
JDK 版本：JDK1.5 起
是否 Lazy 初始化：是
是否多线程安全：是
实现难度：较复杂
描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
getInstance() 的性能对应用程序很关键。
实例
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
