Java基础

&与&&区别？

&和&&都是逻辑运算符，都是判断两边同时真则为真，否则为假；但是&&当第一个条件不成之后，后面的条件都不执行了，而&则还是继续执行，直到整个条件语句执行完为止。

使用 final 关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容 还是可以改变的。

静态变量和实例变量的区别？

在语法定义上的区别：

静态变量前要加 static 关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变 量才会被分配空间，才能使用这个实例变量。

静态变量不属于某个实例对象，而是属于类， 所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。

总之，实例变量必须创建对象后才可以通过这个对象 来使用，静态变量则可以直接使用类名来引用。

静态变量使用时,通过类名.名称,实例变量必须要初始化后才能使用。实例变量是实例化后才会分配空间,而静态变量当类加载时会分配空间。

是否可以从一个 static 方法内部发出对非 static 方法的调用？

不可以。因为非 static 方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对 象上进行方法调用，而 static 方法调用时不需要创建对象，可以直接调用。也就是说，当一 个 static 方法被调用时，可能还没有创建任何实例对象，如果从一个 static 方法中发出对非 static 方法的调用，那个非 static 方法是关联到哪个对象上的呢？这个逻辑无法成立，所以， 一个 static 方法内部发出对非 static 方法的调用。

非static方法可以访问static方法.

static方法不能访问非static方法

"=="和 equals 方法究竟有什么区别？

  ==如果判断值类型的话，判断内容是否相同。如果判断引用类型则是判断内存地址是否相同

Equals判断值内容是否相等

Integer 与 int 的区别？

Integer 是引用类型,默认值是null。而int是是值类型默认值是0

请说出作用域 public， private， protected，以及不写时的区别

这四个作用域的可见范围如下表所示。

说明：如果在修饰的元素上面没有写任何访问修饰符，则表示 friendly。

作用域 当前类 同一包（ package） 子孙类 其他包（ package）

public     √              √                                      √                 √

protected √            √                                      √                 ×

friendly     √             √                                      ×                ×

private      √              ×                                   ×                  ×

重载与重写区别？

重载是同一个类中，方法名称相同， 但是参数或个数不同。与返回值没有关系。

重写是在多个类中， 产生继承关系。父类与子类的方法方法必须相同。

abstract class和interface有什么区别?接口可以继承接口吗？接口可以继承抽象类吗，为什么？

1.abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。

3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。

4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

6.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

7.接口中的方法默认都是 public,abstract 类型的。接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。任何抽象类都是实际类Object的子类。

final, finally, finalize 的区别？

这三者的区别可以从两个方面来说

1、意思解释方面

（1）final是修饰符（关键字）

（2）finally是异常处理中的程序块

（3）finalize是方法名

2、功能方面

（1）如果一个类被声明为final的话，则此类不能被继承；

     如果一个变量声明为final的，则此类不能被改变，只能使用；

     如果一个方法被声明为final的，则此方法只能被使用，不能被重载

（2）在异常处理时，使用finally块来进行必要的清理工作，不管是否发生异常

（3）在垃圾回收器将内存中的对象进行清空之前，允许使用finalize()方法做清理工作

String、StringBuffer与StringBuilder的区别？

1.三者在执行速度方面的比较：StringBuilder >  StringBuffer  >  String

2.String <（StringBuffer，StringBuilder）的原因

String：字符串常量

StringBuffer：字符创变量

StringBuilder：字符创变量

从上面的名字可以看到，String是“字符创常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问  ，比如这段代码：

String s = "abcd";

s = s+1;

System.out.print(s);// result : abcd1

我们明明就是改变了String型的变量s的，为什么说是没有改变呢? 其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

3.一个特殊的例子：

1 String str = “This is only a” + “ simple” + “ test”;

3 StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：String str = “This is only a” + “ simple” + “test”;

其实就是：String str = “This is only a simple test”;

所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：String str2 = “This is only a”;

String str3 = “ simple”;

String str4 = “ test”;

String str1 = str2 +str3 + str4;

这时候JVM会规规矩矩的按照原来的方式去做。

4.StringBuilder与 StringBuffer

StringBuilder：线程非安全的

StringBuffer：线程安全的

当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用

StringBuilder而不用StringBuffer的，就是速度的原因。

对于三者使用的总结：

1.如果要操作少量的数据用 = String

2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

补充：Java中为什么StringBuilder比StringBuffer快？

首先我们看一下源码：

java.lang.StringBuilder

public StringBuilder append(String str) {

        super.append(str);

        return this;

    }

java.lang.StringBuffer

public synchronized StringBuffer append(String str) {

        super.append(str);

        return this;

    }

可以看到，StringBuffer类的append()方法，都被synchronized所修饰，这就是我们的主角。synchronized关键字是做什么的呢？在多线程中非常常见，根据用法不同，可以给方法、代码块或对象加锁。以此处为例，当多个线程访问加锁的方法时，每次只有一个线程获得锁，其他线程必须等待该线程释放锁（一般是执行完这个方法），再由下一个线程获得锁，才允许执行该方法。加锁会带来性能上的损耗（毕竟多执行了一些操作，还包括锁等待时的线程阻塞）。为什么StringBuffer要加锁？StringBuffer就是为了多线程而设计的，这样可以防止多个线程同时操作同一个对象，也就是线程安全。而如果使用多线程操作StringBuilder对象，则无法保证每次append进去的字符串保持原样（随线程数量和数据量增大，出现错乱的概率也越大，跟线程切换有关）。

综上所述，Stringbuilder要比Stringbuffer快。

所有的类都继承于object类，你用过的object类的直接子类有哪些，object类常用的方法有哪些？

1．clone方法

保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

2．getClass方法

final方法，获得运行时类型。

3．toString方法

该方法用得比较多，一般子类都有覆盖。

4．finalize方法

该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

5．equals方法

该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。

6.数组有没有length()这个方法? String有没有length()这个方法？

答：数组没有length()这个方法，有length的属性。String有有length()这个方法。

7．hashCode方法

该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。

8．wait方法

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生。

（1）其他线程调用了该对象的notify方法。

（2）其他线程调用了该对象的notifyAll方法。

（3）其他线程调用了interrupt中断该线程。

（4）时间间隔到了。

此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

9．notify方法

该方法唤醒在该对象上等待的某个线程。

10．notifyAll方法

该方法唤醒在该对象上等待的所有线程

反射的优缺点？

反射：就是正在运行动态读取这个类的完整信息。

优点：java的反射机制就是增加程序的灵活性、

缺点：缺点：（1）性能问题：使用反射基本上是一种解释操作，

用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和扩展性要求很高的系统框架上，普通程序不建议使用。

（2）使用反射会模糊程序内内部逻辑：程序员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。

那些地方用到了反射？

例如: jdbc、Java常用框架、jdk的动态代理、android的加载布局文件

Java基本数据类型

byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。

short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。

int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。

long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。

float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。

double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。

boolean：只有true和false两个取值。

char：16位，存储Unicode码，用单引号赋值。

原始数据类型和封装类的区别？

引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。Java中包含三种引用类型即为数组，类，接口, Java得三种引用类型，储存在引用类型变量中的值是该变量表示的值的地址”。最大的区别：值类型的变量存放在栈里；引用类型的数据存放在堆中。具体区别：

1、值类型继承自ValueType（注意：而System.ValueType又继承自System.Object）；而引用类型继承自System.Object。

3、值类型的内存不由GC（垃圾回收，Gabage Collection）控制，作用域结束时，值类型会自行释放，减少了托管堆的压力，因此具有性能上的优势。例如，通常struct比class更高效；而引用类型的内存回收，由GC来完成。

4、值类型是密封的（sealed），因此值类型不能作为其他任何类型的基类，但是可以单继承或者多继承接口；而引用类型一般都有继承性。

5、值类型不具有多态性；而引用类型有多态性。

6、值类型有两种状态：装箱和未装箱，运行库提供了所有值类型的已装箱形式；而引用类型通常只有一种形式：装箱。（装箱和取消装箱的概念是 C# 的类型系统的核心。它在“值类型”和“引用类型”之间的架起了一座桥梁，使得任何“值类型”的值都可以转换为 object 类型的值[装箱]，反过来转换也可以。其中任何类型的值最终都可以按对象处理。）

int是java提供的8种原始数据类型之一。

Java为每个原始类型提供了封装类，Integer是java为int提供的封装类（即Integer是一个java对象，而int只是一个基本数据类型）。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。 在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为了int类型，还需要在hbm映射

文件中设置其unsaved-value属性为0。 另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，

Integer中还定义了表示整数的最大值和最小值的常量。

    int 是基本类型。

    Integer是引用类型。。

    比如int a= 5；

    Integer b = 5

对于a你只能用来做计算。。比如加减乘除。。

b你可以用来做很多事情，因为他是一个对象，他有很多方法，你可以像使用String对象那样使用它。  java.lang.Integer是一个类.对它的操作要通过类的方法    int是JAVA缺省的8中基本数据类型之一.不是类的对象.int是基本数据类型，Integer是对int进行了封装的一个类。声明为int的变量不需要实例化，声明为Interger的变量需要实例化（因为类需要

实例化）   

  int是基本类型，Integer是包装类，也就是类。

  Integer   是比int   更高级的   数据类型   为什么java中使用int   而不像vb中那样使用Integer

  int是面向机器底层的数值类型，是Primitive类型的数据类型，而Integer是int的

Warpper类，是面向对象的即OOP的对象类型。int   一般只用在数值计算中，而

Integer是用在Java的其它要使用对象的地方，比如Map的Key与Value，List与Set的

Element若要保存数值信息都要把int包装成Integer对象使用。Java提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。   

    原始类型           封装类   

    boolean            Boolean   

    char                Character   

    byte                Byte   

    short               Short   

    int                  Integer   

    long                Long   

    float                Float   

    double             Double   

  引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为null，而原始类型实例变量的缺省值与它们的类型有关。

    int   一般做为数值参数就够了   

    integer   一般做类型转换的时候用的较多  

运行时异常和非运行时异常区别？

所谓的异常就是阻止当前程序或方法继续执行的问题。

java异常分为两种：运行时异常（RuntimeException）和非运行时异常（CheckedException）也叫检查式异常。

1.运行时异常是不需要捕获的，程序员可以不去处理，当异常出现时，虚拟机会处理。常见的运行时异常有空指针异常。

我们常见的5中运行时异常：

[java] view plain copy

ClassCastException(类转换异常)   

IndexOutOfBoundsException(数组越界)   

NullPointerException(空指针)   

ArrayStoreException(数据存储异常，操作数组时类型不一致)   

还有IO操作的BufferOverflowException异常   

具体可以参见java的API:http://docs.oracle.com/javase/7/docs/api/

2.非运行时异常就必须得捕获了，否则编译不过去，java编译器要求程序员必须对这

种异常进行catch,Java认为Checked异常都是可以被处理（修复）的异常，所以Java程

序必须显式处理Checked异常。 常见的非运行异常有io异常和sql异常。

[java] view plain copy

IOException、FileNotFoundExcetion 和SQLException  

finally是异常处理工作的一部分，表示总是执行。一般finally写的代码语句就是流的关闭。也就是做了一项清理，工作清理工作对于我们来说是必不可少的，因为如果一些消耗资源的操作，比如IO,JDBC。如果我们用完以后没有及时正确的关闭，那后果会很严重，这意味着内存泄露。（有人说过，对于资源的及时正确的清理是程序员的基本素质之一）

另外不得不说异常处理中的throws和throw的区别了。

1、throws出现在方法的声明中，表示该方法可能会抛出的异常，允许throws后面跟着

多个异常类型

2、throw出现在方法体中，用于抛出异常。当方法在执行过程中遇到异常情况时，将异常信息封装为异常对象，然后throw。

Throwable

Error 

VirtualMachineError

Exception

RunTimeException

NullPointerException

IOException

FileNotFoundException

请写出你最常见到的5个runtime exception。

ArithmeticException——由于除数为0引起的异常；

ArrayStoreException——由于数组存储空间不够引起的异常；

ClassCastException—一当把一个对象归为某个类，但实际上此对象并不是由这个类

创建的，也不是其子类创建的，则会引起异常；

IllegalMonitorStateException——监控器状态出错引起的异常；

NegativeArraySizeException—一数组长度是负数，则产生异常；

NullPointerException—一程序试图访问一个空的数组中的元素或访问空的对象中的

方法或变量时产生异常；

OutofMemoryException——用new语句创建对象时，如系统无法为其分配内存空 间则

产生异常；

SecurityException——由于访问了不应访问的指针，使安全性出问题而引起异常；

IndexOutOfBoundsExcention——由于数组下标越界或字符串访问越界引起异常；

IOException——由于文件未找到、未打开或者I/O操作不能进行而引起异常；

ClassNotFoundException——未找到指定名字的类或接口引起异常；

CloneNotSupportedException——一程序中的一个对象引用Object类的clone方法，但

此对象并没有连接Cloneable接口，从而引起异常；

InterruptedException—一当一个线程处于等待状态时，另一个线程中断此线程，从

而引起异常，有关线程的内容，将在下一章讲述；

NoSuchMethodException一所调用的方法未找到，引起异常；

Illega1AccessExcePtion—一试图访问一个非public方法；

StringIndexOutOfBoundsException——访问字符串序号越界，引起异常；

ArrayIdexOutOfBoundsException—一访问数组元素下标越界，引起异常；

NumberFormatException——字符的UTF代码数据格式有错引起异常；

IllegalThreadException—一线程调用某个方法而所处状态不适当，引起异常；

FileNotFoundException——未找到指定文件引起异常；

EOFException——未完成输入操作即遇文件结束引起异常。

简述一下面向对象的特征，并举例说明你对面向对象的理解？

面向对象相对于面向过程来说，它从现实世界中客观存在的事物（即对象）出发来构造软件系统，并根据这些事物的本质特点，把它们抽象地表示为系统中的基本构成单位，更能接近现实事物本来的特性和面貌。

面向对象优点：

    1.一切皆对象，相对于面向过程编程而言提高了代码的可重用性；

    2.面向对象的三个重要特征：封装、继承、多态，提高了系统的灵活性与健壮性；

    3.面向对象的中的属性和方法的可访问性提高了程序的安全性，数据调取的多样性.

正则表达式的用法？

江湖传说里, 程序员的正则表达式和医生的处方, 道士的鬼符齐名, 曰: 普通人看不

懂的三件神器. 这个传说至少向我们透露了两点信息: 一是正则表达式很牛, 能和医

生的处方, 道士的鬼符齐名, 并被大家提起, 可见其江湖地位. 二是正则表达式很难,

这也从侧面说明了, 如果你可以熟练的掌握并应用它, 在装逼的路上, 你将如日中天

(别问我中天是谁……) !“如果罗列计算机软件领域的伟大发明, 我相信绝对不会超过二十项, 在这个名单当中, 当然应该包括分组交换网络, Web, Lisp, 哈希算法, UNIX, 编译技术, 关系模型, 面向对象, XML这些大名鼎鼎的家伙, 而正则表达式也绝对不应该被漏掉.? 对很多实际工作而言, 正则表达式简直是灵丹妙药, 能够成百倍的提高开发效率和程序质量, 正则表达式在生物信息学和人类基因图谱的研究中所发挥的关键作用, 更是被传为佳话. CSDN的创始人蒋涛先生在早年开发专业软件产品时, 就曾经体验过这一工具的巨大威力, 并且一直印象深刻.”

Java 语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别代表什么意义？finally代码是在return之后还是之前执行？

try块表示程序正常的业务执行代码。如果程序在执行try块的代码时出现了“非预期

”情况，JVM将会生成一个异常对象，这个异常对象将会被后面相应的catch块捕获。

catch块表示一个异常捕获块。当程序执行try块引发异常时，这个异常对象将会被后

面相应的catch块捕获。throw用于手动地抛出异常对象。throw后面需要一个异常对象。throws用于在方法签名中声明抛出一个或多个异常类，throws关键字后可以紧跟一个或多个异常类。finally块代表异常处理流程中总会执行的代码块。对于一个完整的异常处理流程而言，try块是必须的，try块后可以紧跟一个或多个catch块，最后还可以带一个finally块。try块中可以抛出异常。

若finally语句在try和catch语句中的return执行后、返回前执行；

若finally语句中没有return，则其执行结果不影响try和catch中已确定的返回值；

若finally语句中有return，则其执行后的结果会直接返回。

构造器（constructor）是否可被重写（override）？ 构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

Constructor不能被继承，所以Constructor也就不能被override。每一个类必须有自己的构造函数，负责构造自己这部分的构造。子类不会覆盖父类的构造函数，相反必须负责在一开始调用父类的构造函数。

一、构造器是干什么用的？（what）构造器是用来生成一个类的实例是用来初始化这个实例用的

二、构造器如何工作？（how）

Java在构造实例时的顺序是这样的：

1、分配对象空间，并将对象中成员初始化为0或者空，java不允许用户操纵一个不定值的对象。 　　

2、执行属性值的显式初始化 　　

3、执行构造器 　　

4 、将变量关联到堆中的对象上

而执行构造器的步骤有可以分为以下几步：

1、Bind构造器的参数

2、如果显式的调用了this，那就递归调用this构造器然后跳到步骤5

3、递归调用显式或者隐式的父类构造器，除了Object以外，因为它没有父类

4、执行显式的实例变量初始化（也就是上边的流程中的第二步，调用返回以后执行，

   这个步骤相当于在父构造器执行后隐含执行的，看样子像一个特殊处理）

三、构造器不可被orerride（why）

其实你只需要记住一句话：构造器不是方法，那么用来修饰方法特性的所有修饰符都不能用来修饰构造器（并不等与构造器具备这些特性，虽然不能用static修饰构造器，但它却有静态特性）构造器只能用 public private protected这三个权限修饰符，且不能有返回语句。

是否可以继承String类？ String类为什么是final的？

不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。

public final class String implements java.io.Serializable, Comparable<String>, CharSequence

首先，先得清楚 final 这个关键字。

final的出现就是为了为了不想改变，而不想改变的理由有两点：设计(安全)或者效率。

final 修饰的类是不被能继承的，所以 final 修饰的类是不能被篡改的。 了解了这一点，我们再看看问题：

1、从设计安全)上讲，

1)、确保它们不会在子类中改变语义。String类是final类，这意味着不允许任何人定义String的子类。换言之，如果有一个String的引用，它引用的一定是一个String对象，而不可能是其他类的对象。

2)、String 一旦被创建是不能被修改的，因为 java 设计者将 String 为可以共享的。

2、从效率上讲：

1)、设计成final，JVM才不用对相关方法在虚函数表中查询，而直接定位到String类的相关方法上，提高了执行效率。

2)、Java设计者认为共享带来的效率更高。

总而言之，就是要保证 java.lang.String 引用的对象一定是 java.lang.String的对象，而不是引用它的子孙类，这样才能保证它的效率和安全。

Java 中的final关键字有哪些用法？

final关键字是我们经常使用的关键字之一，它的用法有很多，但是并不是每一种用法都值得我们去广泛使用。它的主要用法有以下四种：

用来修饰数据，包括成员变量和局部变量，该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲，我们必须在声明时或者构造方法中对它赋值；

用来修饰方法参数，表示在变量的生存期中它的值不能被改变；

修饰方法，表示该方法无法被重写；

修饰类，表示该类无法被继承。

上面的四种方法中，第三种和第四种方法需要谨慎使用，因为在大多数情况下，如果是仅仅为了一点设计上的考虑，我们并不需要使用final来修饰方法和类。

关于final的重要知识点

final关键字可以用于成员变量、本地变量、方法以及类。

final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。

你不能够对final变量再次赋值。

本地变量必须在声明时赋值。

在匿名类中所有变量都必须是final变量。

final方法不能被重写。

final类不能被继承。

final关键字不同于finally关键字，后者用于异常处理。

final关键字容易与finalize()方法搞混，后者是在Object类中定义的方法，是在垃圾回收之前被JVM调用的方法。

接口中声明的所有变量本身是final的。

final和abstract这两个关键字是反相关的，final类就不可能是abstract的。

final方法在编译阶段绑定，称为静态绑定(static binding)。

没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。

将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。

按照Java代码惯例，final变量就是常量，而且通常常量名要大写：

如何通过反射创建对象？

有两种方式：

1.使用Class对象的newInstance()方法来创建该Class对象对应类的实例，这种方式要求该Class对象的对应类有默认构造器，而执行newInstance()方法时实际上是利用默认构造器来创建该类的实例。

2.先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例。

Java 8的新特性？

Lambda 表达式 ? Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中。方法引用 ? 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。默认方法 ? 默认方法就是一个在接口里面有了一个实现的方法。新工具 ? 新的编译工具，如：Nashorn引擎 jjs、 类依赖分析器jdeps。Stream API ?新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。Date Time API ? 加强对日期与时间的处理。Optional 类 ? Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。Nashorn, JavaScript 引擎 ? Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。

Java数组和链表的两种结构的操作效率？

数组：

数组就像一个班级一样，一旦分完班，一个班多少人，每个人的学号啥的都是确定的啦，根据学号，喊一个学号就会有个人中，这个学号就是下标，根据下标找人就是快。单个之间关系不大

链表：

链表就像一个铁链，一环扣一环，不能跳过一个，直接去找下一个，必须挨个找，根据节点的next的指向，查找，要查找就得一个个查。

(1) 从逻辑结构角度来看

a, 数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。

b,链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）

(2)从内存存储角度来看

a,(静态)数组从栈中分配空间(这个有待确定，毕竟是Java的数组), 对于程序员方便快速,但自由度小。

b, 链表从堆中分配空间, 自由度大但申请管理比较麻烦.

数组和链表的区别整理如下：

数组静态分配内存，链表动态分配内存；

数组在内存中连续，链表不连续；

数组元素在栈区，链表元素在堆区；

数组利用下标定位，时间复杂度为O(1)，链表定位元素时间复杂度O(n)；

数组插入或删除元素的时间复杂度O(n)，链表的时间复杂度O(1)。

List<Object>强制转换为List<String>？

List<Object> object是不允许直接转成 List<String> 类型的

转换方法：List<String> strs = (List<String>)(List)object

Java中的队列都有哪些，有什么区别？

阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从队列中移除一个或者多个元素，或者完全清空队列.

1.ArrayDeque, （数组双端队列）

2.PriorityQueue, （优先级队列）

3.ConcurrentLinkedQueue, （基于链表的并发队列）

4.DelayQueue, （延期阻塞队列）（阻塞队列实现了BlockingQueue接口）

5.ArrayBlockingQueue, （基于数组的并发阻塞队列）

6.LinkedBlockingQueue, （基于链表的FIFO阻塞队列）

7.LinkedBlockingDeque, （基于链表的FIFO双端阻塞队列）

8.PriorityBlockingQueue, （带优先级的无界阻塞队列）

9.SynchronousQueue （并发同步阻塞队列）

阻塞队列和生产者-消费者模式阻塞队列（Blocking queue）提供了可阻塞的put和take方法，它们与可定时的offer和poll是等价的。如果Queue已经满了，put方法会被阻塞直到有空间可用；如果Queue是空的，那么take方法会被阻塞，直到有元素可用。Queue的长度可以有限，也可以无限；无限的Queue永远不会充满，所以它的put方法永远不会阻塞。阻塞队列支持生产者-消费者设计模式。一个生产者-消费者设计分离了“生产产品”和“消费产品”。该模式不会发现一个工作便立即处理，而是把工作置于一个任务（“to do”）清单中，以备后期处理。生产者-消费者模式简化了开发，因为它解除了生产者和消费者之间相互依赖的代码。生产者和消费者以不同的或者变化的速度生产和消费数据，生产者-消费者模式将这些活动解耦，因而简化了工作负荷的管理。生产者-消费者设计是围绕阻塞队列展开的，生产者把数据放入队列，并使数据可用，当消费者为适当的行为做准备时会从队列中获取数据。生产者不需要知道消费者的省份或者数量，甚至根本没有消费者—它们只负责把数据放入队列。类似地，消费者也不需要知道生产者是谁，以及是谁给它们安排的工作。BlockingQueue可以使用任意数量的生产者和消费者，从而简化了生产者-消费者设计的实现。最常见的生产者-消费者设计是将线程池与工作队列相结合。阻塞队列简化了消费者的编码，因为take会保持阻塞直到可用数据出现。如果生产者不能足够快地产生工作，让消费者忙碌起来，那么消费者只能一直等待，直到有工作可做。同时，put方法的阻塞特性也大大地简化了生产者的编码；如果使用一个有界队列，那么当队列充满的时候，生产者就会阻塞，暂不能生成更多的工作，从而给消费者时间来赶进进度。有界队列是强大的资源管理工具，用来建立可靠的应用程序：它们遏制那些可以产生过多工作量、具有威胁的活动，从而让你的程序在面对超负荷工作时更加健壮。虽然生产者-消费者模式可以把生产者和消费者的代码相互解耦合，但是它们的行为还是间接地通过共享队列耦合在一起了

类库中包含一些BlockingQueue的实现，其中LinkedBlockingQueueArrayBlockingQueue是FIFO队列，与 LinkedList和ArrayList相似，但是却拥有比同步List更好的并发性能。PriorityBlockingQueue是一个按优先级顺序排序的队列，当你不希望按照FIFO的属性处理元素时，这个PriorityBolckingQueue是非常有用的。正如其他排序的容器一样，PriorityBlockingQueue可以比较元素本身的自然顺序（如果它们实现了Comparable），也可以使用一个 Comparator进行排序。最后一个BlockingQueue的实现是SynchronousQueue，它根本上不是一个真正的队列，因为它不会为队列元素维护任何存储空间。不过，它维护一个排队的线程清单，这些线程等待把元素加入（enqueue）队列或者移出（dequeue）队列。因为SynchronousQueue没有存储能力，所以除非另一个线程已经准备好参与移交工作，否则put和take会一直阻止。SynchronousQueue这类队列只有在消费者充足的时候比较合适，它们总能为下一个任务作好准备。非阻塞算法基于锁的算法会带来一些活跃度失败的风险。如果线程在持有锁的时候因为阻塞I/O，页面错误，或其他原因发生延迟，很可能所有的线程都不能前进了。一个线程的失败或挂起不应该影响其他线程的失败或挂起，这样的算法成为非阻塞（nonblocking）算法；如果算法的每一个步骤中都有一些线程能够继续执行，那么这样的算法称为锁自由（lock-free）算法。在线程间使用CAS进行协调，这样的算法如果能构建正确的话，它既是非阻塞的，又是锁自由的。非竞争的CAS总是能够成功，如果多个线程以一个CAS竞争，总会有一个胜出并前进。非阻塞算法堆死锁和优先级倒置有“免疫性”（但它们可能会出现饥饿和活锁，因为它们允许重进入）。非阻塞算法通过使用低层次的并发原语，比如比较交换，取代了锁。原子变量类向用户提供了这些底层级原语，也能够当做“更佳的volatile变量”使用，同时提供了整数类和对象引用的原子化更新操作。

hashCode() 与 equals() 生成算法、方法怎么重写？

public class Cat   

{  

    private String name;  

    private String birthday;  

    public Cat()  

    {  

    }  

    public void setName(String name)  

    {  

        this.name = name;  

    }  

    public String getName()  

    {  

        return name;  

    }  

    public void setBirthday(String birthday)  

    {  

        this.birthday = birthday;  

    }  

    public String getBirthday()  

    {  

        return birthday;  

    }

       //重写equals方法  

    public boolean equals(Object other)  

    {  

        if(this == other)  

        {  

            //如果引用地址相同，即引用的是同一个对象，就返回true  

            return true;  

        }  

            //如果other不是Cat类的实例，返回false  

        if(!(other instanceOf Cat))  

        {  

            return false;  

        }  

        final Cat cat = (Cat)other;  

            //name值不同，返回false  

        if(!getName().equals(cat.getName())  

            return false;  

            //birthday值不同，返回false  

        if(!getBirthday().equals(cat.getBirthday()))  

            return false;  

        return true;  

    }  

       //重写hashCode()方法  

    public int hashCode()  

    {  

        int result = getName().hashCode();  

        result = 29 * result + getBirthday().hashCode();  

        return result;  

    }  

}  

   重写父类方法的原则：可以重写方法的实现内容，成员的存取权限（只能扩大，不能缩小），或是成员的返回值类型（但此时子类的返回值类型必须是父类返回值类型的子类型）。

String 编码UTF-8 和GBK的区别?

字符均使用双字节来表示，只不过为区分中文，将其最高位都定成1。至于UTF－8编码则是用以解决国际上字符的一种多字节编码，它对英文使用8位（即一个字节），中文使用24位（三个字节）来编码。对于英文字符较多的论坛则用UTF－8节省空间。GBK包含全部中文字符；UTF-8则包含全世界所有国家需要用到的字符。GBK是在国家标准GB2312基础上扩容后兼容GB2312的标准（好像还不是国家标准）UTF-8编码的文字可以在各国各种支持UTF8字符集的浏览器上显示。比如，如果是UTF8编码，在外国人的英文IE上也能显示中文，而无需他们下载IE的中文语言支持包。 所以，对于英文比较多的论坛 ，使用GBK则每个字符占用2个字节，而使用UTF－8英文却只占一个字节。UTF8是国际编码，它的通用性比较好，外国人也可以浏览论坛，GBK是国家编码，通用性比UTF8差，不过UTF8占用的数据库比GBK大~。