java 基础篇

1、java语言的三种技术架构

J2EE：企业版。是为开发企业环境下的应用程序提供的一套解决方案。

该技术体系中包含的技术如Servlet、Jsp等，主要针对于Web应用程序开发。

J2SE：标准版。是为开发普通桌面和商务应用程序提供的解决方案。

该技术体系是其他两者的基础，可以完成一些桌面应用程序的开发。比如Java版的扫雷。

J2ME：小型版。是为开发电子消费产品和嵌入式设备提供的解决方案。

该技术体系主要应用于小型电子消费类产品，如手机中的应用程序等。

2、JVM、JRE和JDK的区别？

JVM(Java Virtual Machine)：java虚拟机，用于保证java的跨平台的特性。

java语言是跨平台，jvm不是跨平台的。

JRE(Java Runtime Environment)：java的运行环境,包括jvm+java的核心类库。

JDK(Java Development Kit)：java的开发工具,包括jre+开发工具

3、java的跨平台性：

通过Java语言编写的应用程序在不同的系统平台上都可以运行。

跨平台的原因：只要在需要运行java应用程序的操作系统上，先安装一个Java虚拟机(JVM Java Virtual Machine)即可。由JVM来负责Java程序在该系统中的运行。

4、环境变量path和classpath的作用是什么？

(1) path是配置Windows可执行文件的搜索路径，即扩展名为.exe的程序文件所在的目录，用于指定DOS窗口命令的路径。

(2) Classpath是配置class文件所在的目录，用于指定类搜索路径，JVM就是通过它来寻找该类的class类文件的。

5、Java的访问控制符作用范围？

Public 公共的，所有类均可以访问。

Protected 受保护的，当前包和不同包子类可以访问。

Default 默认访问类型，当前包下可以访问。

Private 私有的，只有本类可以访问。

4、&和&&的区别?

（1）&&会出现短路，如果可以通过第一个表达式判断出整个表达式的结果，则不继续后面表达式的运算；只能操作boolean类型数据；

（2）&不会出现短路，将整个表达式都运算。既可以操作boolean数据还可以操作数。

5、标示符命名规则？

由数字(0-9)，大小写英文字母，以及_和$组成。

不能以数字开头。不能使用关键字来自定义命名。

6、数据类型？

(1)基本数据类型(4类8种)：

整数类型：byte(1)、short(2)、int(4)、long(8)

浮点数类型：float(4)、double(8)

字符类型：char(2)

布尔类型：boolean(ture false)(4)

(2)引用数据类型： 类、接口、数组

自动装箱：new Integer(6);底层调用Integer.valueOf(6)

自动拆箱：int i = new Integer(6);，底层调用i.intValue();方法实现。

7、类型转换

精度从高到低 double float long int short(char) byte 

(1)自动类型转换 将一个低精度---à高精度 

(2)强制类型转换 将一个高精度---à低精度(精度会下降)

8、常见的数据结构有？ 数组，栈，队列，链表，树，图，堆

9、一个java类中包含那些内容？ 属性、方法、内部类、构造方法、代码块。

10、那针对浮点型数据运算出现的误差的问题，你怎么解决？

使用Bigdecimal类进行浮点型数据的运算

11、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。

12、在JAVA中如何跳出当前的多重嵌套循环？

在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break 语句，即可跳出外层循环。

使用标签和break，并且应在所在循环的外层循环之前定义标签：

13、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?

在idk 1.7之前，switch只能支持byte, short, char, int或者其对应的封装类以及Enum类型。从idk 1.7之后switch开始支持String。switch中的参数不支持其他类型，例如long类型

14、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

对于short s1 = 1; s1 = s1 + 1; 由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。

对于short s1 = 1; s1 += 1;由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。

14、`(1<3)?"a":"b")+3+4`和`(1<3)?"a":"b")+(3+4)`区别

System.out.println(((1<3)?"a":"b")+3+4);  System.out.println(((1<3)?"a":"b")+(3+4));

控制台: a34   a7

15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 12 ，-11

16、char型变量中能不能存贮一个中文汉字?为什么?

char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

17、char和varchar区别

都是用来存储字符串的，它们保存方式不一样，char有固定的长度，而varchar属于可变长的字符类型。

18、char和byte的区别，各几个字节

    char类型是字符型 16个位 两个字节 没有符号位 16个位全部都是数值位，所以取值范围0到2的16次方-1

byte类型是整数类型当中的一种 8个位 一个字节 其中1个符号位 15个数值位，所以取值范围-2的15次方到+2的15次方-1

1. 基础类型和包装类的区别？

1.声明方式不同：基本类型不使用new关键字，而包装类型需要使用new关键字。

2.存储方式及位置不同：基本类型是直接将变量值存储在栈中，而包装类型是将对象放在堆中，然后通过引用来使用；

3.初始值不同：基本类型的初始值如int为0，boolean为false，而包装类型的初始值为null；

4.使用方式不同：基本类型直接赋值直接使用就好，而包装类型在集合如Collection、Map时会使用到。

19、用最有效率的方法算出2乘以8等於几?   2 << 3，

因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2 << 3。

19、foreach与正常for循环效率对比

对于for循环就是调用get(i)取得元素，而对于foreach是通过iterator实现的遍历，

对于数组来说，for和foreach循环效率差不多，对于链表来说，for循环效率明显比foreach低。

对于ArrayList来说，它是通过一个数组实现的，可以随机存取；但是LinkedList是通过链表实现的，for循环时要获取第i个元素必须从头开始遍历，而iterator遍历就是从头开始遍历，遍历完只需要一次，所以for循环需要的时间远远超过for循环。 

20、数组实例化有几种方式？

静态实例化：创建数组的时候已经指定数组中的元素, int[] a=new int[]{1,3,3}

动态实例化：实例化数组的时候只指定了数组程度，数组中所有元素都是数组类型默认值

20、数组在内存中如何分配

1、简单的值类型的数组，每个数组成员是一个引用（指针），引用到栈上的空间（因为值类型变量的内存分配在栈上）

2、引用类型，类类型的数组，每个数组成员仍是一个引用（指针），引用到堆上的空间（因为类的实例的内存分配在堆上）

21、java中是值传递引用传递？

值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。

引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身，当在一个方法操作参数的时候，其实操作的是引用所指向的对象。

一般认为,java内的传递都是值传递，java中实例对象的传递是引用传递 。

传引用是指传递的是地址而不是值本身，传值则是传递值的一份拷贝。

22、假设把实例化的数组的变量当成方法参数，当方法执行的时候改变了数组内的元素，那么在方法外，数组元素有发生改变吗？

改变了，因为传递是对象的引用，操作的是引用所指向的对象

23、实例化数组后，能不能改变数组长度呢？

不能，数组一旦实例化，它的长度就是固定的

24、假设数组内有5个元素，如果对数组进行反序，该如何做？

创建一个新数组，从后到前循环遍历每个元素，将取出的元素依次顺序放入新数组中

25、java创建对象的几种方式？

1).采用new   2).通过反射   3).采用clone   4).通过序列化机制

前2者都需要显式地调用构造方法。造成耦合性最高的恰好是第一种，因此你发现无论什么框架，只要涉及到解耦必先减少new的使用。

26、变量有什么用？为什么要定义变量？什么时候用？

变量的作用：用来存储数据。

为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用

26、成员变量和局部变量的区别(重点)

(1)作用域

成员变量：针对整个类有效。

局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)

(2)存储位置

成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。

局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。

当方法调用完，或者语句结束后，就自动释放。

(3)初始值

成员变量：有默认初始值。

局部变量：没有默认初始值，使用前必须赋值。

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

语法定义上：静态变量前要加static关键字，而实例变量前则不加。

程序运行时：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

28、全局变量和局部变量哪个能被覆盖

Java当中不允许定义全局变量。Java当中不存在全局变量的概念，只有类体当中的成员变量(实例变量)和方法体当中的局部变量。覆盖是只有方法才存在的。子类继承得到父类方法后对其进行重新实现叫做方法覆盖.属性根本不存在覆盖。

29、静态方法和实例方法的区别主要体现在两个方面：

在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有使用"对象名.方法名"。

调用静态方法可以无需创建对象。静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

30、面向对象特点？封装继承和多态

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式。私有是封装的一种体现。用private关键字修饰。

继承: 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。用关键字extends

多态: 一个对象在程序不同运行时刻代表的多种状态，父类或者接口的引用指向子类对象。封装和继承是为多态做准备的。多态实现的机制是重写和重载。

多态前提：A:存在继承或者实现关系B:有方法的重写C:父类(接口)引用指向子类(实现)对象

实现多态的技术为动态绑定。在执行期间判断所引用对象的实际类型，根据实际类型调用其相应方法。多态允许不同类的对象对同一消息做出响应，即同一消息可以根据发送对象不同采用多种不同的行为方式。（发送消息就是方法调用）。

多态作用：消除了类型之间的耦合关系。

31、虚拟机是如何实现多态的

动态绑定技术(dynamic binding)，执行期间判断所引用对象的实际类型,根据实际类型调用对应的方法.

32、重写和重载区别？

重载：在同一类中。方法名相同，参数列表不同。重载可以改变返回类型。是一个类中多态性的体现。

重写：在不同类中(子父类中)。是父类和子类之间多态性体现。重写时访问控制权限不能更加严格，抛出异常（非运行时异常）种类不能更加规范。

33、接口和抽象类的区别

1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；

2）抽象类中成员变量可以是各种类型的，而接口中成员变量只能是public static final类型；

3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；

4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。

5）抽象类中定义的是继承体系中的共性功能。接口中定义的是继承体系中的扩展功能。

6）抽象类被继承是"is a"关系:xx是yy的一种。接口被实现是"like a"关系:xx像yy的一种。

7）抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。

34、类和接口的区别？

1. 接口类似于类，但接口的成员都没有执行方式，它只是方法、属性、事件和索引的集合。类除了这四种成员外还有别的成员（如字段）。
2. 不能实例化一个接口，接口只包括成员的签名；类可以实例化（abstract类除外）。
3. 接口没有构造方法，类有构造方法。
4. 接口不能进行运算符的重载，类可以有运算符的重载。
5. 接口的成员没有任何修饰符，其成员是公共的。类的成员可以有修饰符（如静态）。
6. 派生于接口的类必须实现接口中所有成员的执行方式，而从类派生则不然。

34、接口有什么用

1、通过接口可以实现不相关类的相同行为，而不需要了解对象所对应的类。

2、通过接口可以指明多个类需要实现的方法。

3、通过接口可以了解对象的交互界面，而不需了解对象所对应的类。

另：Java是单继承，接口可以使其实现多继承的功能。

35、多态中对象调用成员的特点？

Fu f = new Zi();

A:成员变量   编译看左边，运行看左边

B:成员方法    编译看左边，运行看右边

C:静态方法   编译看左边，运行看左边

36、构造器Constructor是否可被override?

构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

37、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)? 抽象类中是否可以有静态的main方法？

接口可以继承接口，接口间继承用extends。抽象类可以实现(implements)接口，但接口不能实现抽象类，抽象类间也可以用extends。抽象类可以继承实体类，但前提是必须有无参的构造方法。抽象类中可以有静态的main方法。

抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。

38、构造方法能不能重载？能不能重写？可以重载，必须重写

39、如果父类只有有参构造方法，那么子类必须要重写父类的构造方法吗？

必须重写

40、创建一个子类对象的时候，那么父类的构造方法会执行吗？

会执行。当创建一个子类对象，调用子类构造方法的时候，子类构造方法会默认调用父类的构造方法。

41、写clone()方法时，通常都有一行代码，是什么？

clone 有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

42、内部类可以引用它的包含类的成员吗？有没有什么限制？

完全可以。如果不是静态内部类，那没有什么限制！

如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，

43、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

可以继承其他类或实现其他接口。不仅是可以，而是必须!

44、如果main方法被声明为private会怎样？

能正常编译，但运行的时候会提示”main方法不是public的”。

45、如果去掉了main方法的static修饰符会怎样？

程序能正常编译。运行时会抛NoSuchMethodError异常。

46、为什么Java里没有全局变量?

全局变量是全局可见的，Java不支持全局可见的变量，因为：全局变量破坏了引用透明性原则。全局变量导致了命名空间的冲突。

49、父类的静态方法能否被子类重写  不能

子类继承父类后，有相同的静态方法和非静态，这是非静态方法覆盖父类中的方法(即方法重写)，父类的该静态方法被隐藏(如果对象是父类则调用该隐藏的方法)；

另外子类可继承父类的静态与非静态方法，至于方法重载我觉得它其中一要素就是在同一类中，不能说父类中的什么方法与子类里的什么方法是方法重载的体现。

50、如何把一段逗号分割的字符串转换成一个数组?

1.用正则表达式，代码大概为：String [] result = orgStr.split(“,”);

2.用StingTokenizer ,代码为：StringTokenizer  tokener = StringTokenizer(orgStr,”,”);

51、数组有没有length()这个方法? String有没有length()这个方法？

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

52、什么是不可变对象

不可变对象指对象一旦被创建，状态就不能再改变。

任何修改都会创建一个新的对象，如 String、Integer及其它包装类。

53、能否创建一个包含可变对象的不可变对象?

当然可以创建一个包含可变对象的不可变对象的，你只需要谨慎一点，不要共享可变对象的引用就可以了，如果需要变化时，就返回原对象的一个拷贝。

最常见的例子就是对象中包含一个日期对象的引用.

54、String对象的intern()方法

intern()方法会首先从常量池中查找是否存在该常量值，如果常量池中不存在则现在常量池中创建，如果已经存在则直接返回。

55、Object类中有哪些方法？列举3个以上。

toString()，equals，hashCode，getClass，finalize，clone, wait()，notify，notifyAll

56、String类中方法有？

和长度有关的方法  int length() 得到一个字符串的字符个数

和数组有关的方法

byte[] getBytes() 将一个字符串转换成字节数组

char[] toCharArray() 将一个字符串转换成字符数组

String[] split(String) 将一个字符串按照指定内容劈开

和判断有关的方法

boolean equals(String) 判断两个字符串的内容是否一模一样

boolean equalsIgnoreCase(String) 忽略大小写的比较两个字符串的内容是否一模一样 boolean contains(String) 判断一个字符串里面是否包含指定的内容

Boolean startsWith(String) 判断一个字符串是否以指定的内容开头

boolean endsWith(String) 判断一个字符串是否以指定的内容结尾

compareTo(String) 对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。
compareToIgnore(String) 与compareTo方法相似，但忽略大小写。

和改变内容有关的方法

String toUpperCase() 将一个字符串全部转换成大写

String toLowerCase() 将一个字符串全部转换成小写

String replace(String,String) 将某个内容全部替换成指定内容

String replaceAll(String,String) 将某个内容全部替换成指定内容，支持正则

String repalceFirst(String,String) 将第一次出现的某个内容替换成指定的内容

String substring(int) 从指定下标开始一直截取到字符串的最后

String substring(int,int) 从下标x截取到下标y-1对应的元素

String trim() 去除一个字符串的前后空格

和位置有关的方法

char charAt(int) 得到指定下标位置对应的字符

int indexOf(String) 得到指定内容第一次出现的下标

int lastIndexOf(String) 得到指定内容最后一次出现的下标

字符串连接 concat(String) 连接到当前字符串的后面，效果等价于"+"

字符串与基本类型的转换

static short parseInt(String)   parseLong(String)   parseFloat(String)

parseDouble(String s) parseByte(String)  parseShort(String)

基本类型转换为字符串类型

static String  valueOf(boolean b)   valueOf(char c)   valueOf(int i)
valueOf(long l)    valueOf(float f)   valueOf(double d)

57、怎样将 GB2312 编码的字符串转换为 ISO-8859-1 编码的字符串？

1. String s1 = "你好";
2. String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");

58、能不能自己写个类，也叫java.lang.String？

public class String {

    public static void main(String[] args) {

        System.out.println("string");

    }

}

可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。由于在tomcat的web应用程序中，都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类，然后才委托上级的类加载器加载，如果我们在tomcat的web应用程序中写一个java.lang.String，这时候Servlet程序加载的就是我们自己写的java.lang.String，但是这么干就会出很多潜在的问题，原来所有用了java.lang.String类的都将出现问题。 

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

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

60、说出一些常用的类，包，接口，请各举5个

常用的类：BufferedReader,BufferedWriter,FileReader,FileWirter,String,Integer,java.util.Date,System,Class,List,HashMap

常用的包：java.lang，java.io，java.util，java.sql，javax.servlet，org.apache.strtuts.action，org.hibernate

常用的接口：Remote,List,Map,Document,NodeList,Servlet,HttpServletRequest,HttpServletResponse,Transaction(Hibernate),Session(Hibernate),HttpSession

61、final,finally,finalize区别。

final是最终的意思。它可以用于修饰类，成员变量，成员方法。
它修饰的类不能被继承，它修饰的变量时常量，它修饰的方法不能被重写。

finally:是异常处理里面的关键字。
它其中的代码永远被执行。特殊情况：在执行它之前jvm退出。System.exit(0);

finalize:是Object类中的一个方法。
它是于垃圾回收器调用的方式。

62、final有哪些用法？

1).被final修饰的类不可以被继承

2).被final修饰的方法不可以被重写

3).被final修饰的变量不可以被改变。

如果修饰的引用，那么表示引用不可变，引用指向的内容可变。

4).被final修饰的方法，JVM会尝试将其内联，以提高运行效率 。

5).被final修饰的常量，在编译阶段会存入常量池中。

当前回答出编译器对final域要遵守的两个重排序规则更好:

1).在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。

2).初次读一个包含final域的对象的引用，与随后初次读这个final域，这两个操作之间不能重排序。

63、String、StringBuffer、StringBuilder 的区别是什么？

1、String：底层使用一个不可变的字符数组private final char value[];它内容不可变。适用于少量的字符串操作的情况

stringBuffer和StringBuilder都继承了AbstractStringBuilder底层使用的是可变字符数组：char[] value;内容是可变的

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

StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

2、运行速度，或者说是执行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String。

3、StringBuilder是线程不安全的，效率较高；而StringBuffer是线程安全的，效率较低。通过他们的append()方法来看，StringBuffer是有同步锁，而StringBuilder没有：

 

d. 1.字符串的底层都是基于char类型的数组实现的

2.当在字符串后面不断的追加新内容的时候，使用StringBuffer效率高，因为对于StringBuffer的对象来说底层开辟的数组对象会预留16块空间，当我们不断的在字符串的后面追加新的内容，他是在缓冲区里面追加，当缓冲区满了那么才开辟一个新的数组对象，然后再预留当前数组空间大小一半的空间当作缓冲区.

  3.对于一个String类型的对象来说，没有缓冲区的概念，当前字符串有多少个字符，底层数组就开辟多大空间，如果我们想在String类型的后面不断的追加新的内容的话，底层其实不断的在创建新的数组对象，相对来说创建数组的频率会高很多，效率较低。因为每次开辟新数组之后都需要复制老元素 改变引用指向 然后将来还要回收旧的数组...

64、判断两个对象是否相同，能使用equlas比较吗？

不能。Equlas大多用来做字符串比较，要判断基本数据类型或者对象类型，需要使用==

65、==与equals有什么区别？

==可以判断基本数据类型值是否相等，也可以判断两个对象指向的内存地址是否相同，也就是说判断两个对象是否是同一个对象，Equals通常用来做字符串比较。

==是运算符，用于比较两个值是否相等，而equals是Object类的方法，用于比较两个对象是否相等。默认Object类的equals方法是比较两个对象的内存地址，此时和==的结果一样，如果需要比较对象内容，需要重写equal方法。

66、equals()和hashcode()的区别

hashCode()是Object类的一个方法，返回一个哈希值。

如果两个对象根据equals()方法比较相等，那么调用这两个对象中任意一个对象的hashCode()方法必须产生相同的哈希值。

如果两个对象根据equals()方法比较不相等，那么产生的哈希值不一定相等(碰撞的情况下还是会相等的)。

67、String 为什么是不可变的？

String 不可变是因为在 JDK 中 String 类被声明为一个 final 类，且类内部的 value 字节数组也是 final 的，只有当字符串是不可变时字符串池才有可能实现，字符串池的实现可以在运行时节约很多 heap 空间，因为不同的字符串变量都指向池中的同一个字符串；如果字符串是可变的则会引起很严重的安全问题，譬如数据库的用户名密码都是以字符串的形式传入来获得数据库的连接，或者在 socket 编程中主机名和端口都是以字符串的形式传入，

1. 因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子改变字符串指向的对象的值造成安全漏洞；
2. 因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享，这样便不用因为线程安全问题而使用同步，字符串自己便是线程安全的；
3. 因为字符串是不可变的所以在它创建的时候 hashcode 就被缓存了，不变性也保证了 hash 码的唯一性，不需要重新计算，这就使得字符串很适合作为 Map 的键，字符串的处理速度要快过其它的键对象，这就是 HashMap 中的键往往都使用字符串的原因。

String类是final类故不可以继承。

68、为什么针对安全保密高的信息，char[] 比 String 更好？

因为 String 是不可变的，一旦创建就不能更改，直到垃圾收集器将它回收才能消失，即使我们修改了原先的变量，实际上也是在内存中新建一个对象，原数据还是保留在内存中等待回收；而字符数组 char[] 中的元素是可以更改的，也就是说像密码等保密信息用完之后我们可以马上修改它的值而不留痕迹，从而相对于 String 有更好的安全性。

69、继承collection接口的：list,set,queue,sortedSet.

继承Map接口的：

HashMap:无序存放，Key不重复,

HashTable:无序存放，Key不重复,

TreeMap：按Key排序，Key可重复,

IdentityHashMap：弱引用Map集合,

70、ArrayList、LinkedList、List的区别?

List 是集合列表接口，ArrayList 和 LinkedList 都是 List 接口的实现类。

1、ArrayList是object类型出始容量为10的，基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的），支持随机访问。

因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。   

2、LinkedList双向循环链表的数据结构, 同时实现了双端队列 Deque 接口，地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势，不支持随机访问，使用下标访问一个元素。

ArrayList 的时间复杂度是 O(1)，而 LinkedList 是 O(n)。

适用场景分析：

当需要对数据进行对此访问的情况下选用ArrayList，

当需要对数据进行多次增加删除修改时采用LinkedList。

70、HashMap 和 Hashtable 的区别？

HashMap 继承自 AbstractMap，Hashtable 继承自 Dictionary 类，两者都实现了 Map 接口；

1、对于null的处理不同

     HashMap无论是主键还是值都能存放null，但是由于主键要求唯一，所以主键只能存放一个null，但是值能存放多个空。

     Hashtable无论是主键还是值都不能添加null，会触发空指针异常。

2、同步特性不同

    HashMap同一时间允许多个线程同时进行访问，线程不安全，效率相对较高，但是可能出现并发错误。

    Hashtable底层大量的使用了synchronized修饰方法，同一时间只允许一个线程对其操作，线程安全，效率相对较低，但是不会出现并发错误。

    从jdk5.0开始集合的工具类Collections当中出现了一个静态方法synchronizedMap方法可以将一个不安全的map变成线程安全的。

    在高并发的场景下推荐使用java.util.concurrent.ConcurrentHashMap 有更高的性能

3、底层实现的区别

    HashMap分组组数可以指定，默认分为16个小组，但是最终的分组组数一定是2的n次方数，在计算散列的时候，底层使用&(分组组数-1)  [按位与运算]

    Hashtable分组组数可以随意指定，默认分11组，可以随意指定分组模分组组数

4、出现的版本不同   HashMap jdk1.2     Hashtable jdk1.0

5、迭代器不同

HashMap迭代器(Iterator)是fail-fast迭代器，Hashtable的enumerator迭代器不是fail-fast

什么是fail-fast? 就是最快的时间能把错误抛出而不是让程序执行。

70、如何保证线程安全又效率高？

Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好。

ConcurrentHashMap将整个Map分为N个segment(类似HashTable)，可以提供相同的线程安全，但是效率提升N倍，默认N为16。

70、我们能否让HashMap同步？

HashMap可以通过下面的语句进行同步：Map m = Collections.synchronizeMap(hashMap);

70、Hashtable的size()方法中明明只有一条语句”return count”，为什么还要做同步？​

synchronize锁住整个Hashtable对象，避免在你取count的时候有其他线程修改这个Hashtable的count值。

71、List集合取交集、并集、去除重复数据等

取交集：listA.retainAll(listB);

取并集：1.listA.removeAll(listB);  2.listA.addAll(listB);

取差集：listA.removeAll(listB);

72、poll()方法和remove()方法区别?

poll() 和 remove() 都是从队列中取出一个元素，但是 poll() 在获取元素失败的时候会返回空，但是 remove() 失败的时候会抛出异常。

73、遍历list的时候为什么不能修改呢

使用for循环.增强for循环foreach、Iterator遍历集合时，不能对集合做添加和删除操作：

1.在遍历时往数组增加数据，会导致遍历不完整（因为增加了新成员长度变了），或者死循环（因为总是有新的进去）。

2.在遍历时删除数据，则会导致数组访问越界（因为长度缩短了，指针指向了一个已经标示为空的区域）否则会引发ConcurrentModificationException异常。

74、Arraylist 的动态扩容机制是如何自动增加的？简单说说你理解的流程？

当在 ArrayList 中增加一个对象时 Java 会去检查 Arraylist 以确保已存在的数组中有足够的容量来存储这个新对象（默认为 10，最大容量为 int 上限，减 8 是为了容错），如果没有足够容量就新建一个长度更长的数组（原来的1.5倍），旧的数组就会使用 Arrays.copyOf 方法被复制到新的数组中去，现有的数组引用指向了新的数组。

75、为什么ArrayList增加或删除操作相对来说效率比较低？为什么？

ArrayList 在小于扩容容量的情况下其实增加操作效率是非常高的，在涉及扩容的情况下添加操作效率确实低，删除操作需要移位拷贝，效率是低点。因为 ArrayList 中增加（扩容）或者是删除元素要调用 System.arrayCopy 这种效率很低的方法进行处理，所以如果遇到了数据量略大且需要频繁插入或删除的操作效率就比较低了，具体可查看 ArrayList 的 add 和 remove 方法实现，但是 ArrayList 频繁访问元素的效率是非常高的，因此遇到类似场景我们应该尽可能使用 LinkedList 进行替代效率会高一些。

76、简单说说 Array 和 ArrayList 的区别？

Array 可以包含基本类型和对象类型，ArrayList 只能包含对象类型；Array 的大小是固定的，ArrayList 的大小是动态变化的；ArrayList 提供了更多的方法和特性，譬如 addAll()、removeAll()、iterator() 等。

77、简单说说 Iterator 和 ListIterator 的区别？

• ListIterator 有 add() 方法，可以向 List 中添加对象，而 Iterator 不能。
• ListIterator 和 Iterator 都有 hasNext() 和 next() 方法，可以实现顺序向后遍历，但是 ListIterator 有 hasPrevious() 和 previous() 方法，可以实现逆向（顺序向前）遍历，Iterator 就不可以。
• ListIterator 可以定位当前的索引位置，通过 nextIndex() 和 previousIndex() 可以实现，Iterator 没有此功能。
• 都可实现删除对象，但是 ListIterator 可以实现对象的修改，通过 set() 方法可以实现，Iterator 仅能遍历，不能修改。
• ListIterator 是 Iterator 的子接口。

注意：容器类提供的迭代器都会在迭代中间进行结构性变化检测，如果容器发生了结构性变化，就会抛出 ConcurrentModificationException，所以不能在迭代中间直接调用容器类提供的 add、remove 方法，如需添加和删除，应调用迭代器的相关方法。

78、如何优雅的删除列表区间，譬如有一个 List 里面有 100 个元素，现在想删除 30 到 50 之间的元素，怎么写代码最优雅？    list.subList(30, 50).clear();

81、Collections.emptyList() 与 new ArrayList() 有什么区别？

相同点为都是 AbstractList 的子类，都可以序列化。

区别为 Collections.emptyList() 返回一个不可变的 List，而new ArrayList() 返回的 List 是可变的。只有当确实需要返回一个不可变空 List 时才使用 Collections.emptyList()，多次调用 Collections.emptyList() 只会返回同一个 List实例，而多次调用 new ArrayList() 每次都会返回新的实例。对于 emptySet() 和 emptyMap() 等类似方法有同样的结论适用。

82、ArrayList 与 LinkedList 使用普通 for 循环遍历谁快谁慢？为什么？

ArrayList 比 LinkedList 使用普通 for 循环遍历快，

ArrayList 的 get 方法只是通过数组下标从数组里面拿一个元素而已，所以 get 方法的时间复杂度是 O(1) 常数，和数组的大小没有关系，只要给定数组的位置就能定位到数据，而 Java 中 ArrayList 是基于数组实现的，数组是内存地址连续的空间，取值其实是地址的偏移，所以自然块的多。

LinkedList 是双向链表，所以 node 方法里面的 if 判断条件是在计算 index 在前一半还是后一半，然后决定是前序遍历还是后序遍历，这样二分法遍历查找会快很多，但是在 for 循环里面 LinkedList 在 get 任何一个位置元素时都会把前面的元素走一遍，随着 LinkedList 的容量越大这个遍历也就越大，所以其遍历的时间复杂度为 O(N/2)，N 为 LinkedList 的容量，所以自然效率就比较低了。

83、为什么说集合的不同列表应该选择不同的遍历方式，举例谈谈你的认识？

ArrayList是直接通过数组来进行存储，所以在使用下标的方式循环遍历的时候性能最好，通过下标可以直接取数据，速度最快，而且由于 ArrayList 是实现了 RandomAccess 接口（随机存取），这个接口是一个标记接口，表明了 ArrayList 集合的数据元素之间没有关联，位置间没有索引依赖。而如果对于 ArrayList 使用 for-each 或者迭代器进行遍历就没有 index 索引遍历效率高了，因为迭代器强制将 RandomAccess 的 ArrayList 建立了前后遍历关系，且在每次遍历过程中进行了一堆判断，所以相对来说对于 ArrayList 来说遍历使用普通 index 比迭代器要效率高些，但是差距不是十分明显。

LinkedList其为双向链表的实现存储，前后元素是通过链表索引建立关联的，无法直接取到对应的下标，因此在使用普通的 index 索引下标遍历时就需要计算对应的元素在哪，二分法决定头部还是尾部遍历，然后一步步的遍历找到元素，所以在遍历中每次都要从头查找元素位置，十分低效率。而迭代器的实现就是指向下一个元素，迭代器直接通过 LinkedList 的指针进行遍历，一次遍历就能找到每个合适的元素，所以 LinkedList 在使用迭代器遍历时效率最高。

总之就是对于不同数据结构实现的集合列表就应该选择不同的遍历方式，尤其是 LinkedList 一定不要使用普通索引下标方式遍历，其效率极低。

84、请使用 LinkedList 模拟一个堆栈或队列的数据结构？

首先堆栈是先进后出，队列是先进先出，LinkedList 不但实现了 List 接口还实现了 Deque 双端队列接口，接着给出实现如下。

1. public class Queue {
2.     private LinkedList link;
3.     public Queue() {
4.         link = new LinkedList();
5.     }
6.     public void push(Object obj) {
7.         link.addLast(obj);
8.     }
9.     public Object pop() {
10.         return link.removeFirst();  //队列
11.         //return link.removeLast(); //堆栈
12.     }
13.     public boolean isEmpty() {
14.         return link.isEmpty();
15.     }
16. }

85、谈谈你理解的 LinkedList 工作原理和实现？

LinkedList 是以双向链表实现，链表无容量限制（但是双向链表本身需要消耗额外的链表指针空间来操作），其内部主要成员为 first 和 last 两个 Node 节点，在每次修改列表时用来指引当前双向链表的首尾部位，所以 LinkedList 不仅仅实现了 List 接口，还实现了 Deque 双端队列接口（该接口是 Queue 队列的子接口），故 LinkedList 自动具备双端队列的特性，当我们使用下标方式调用列表的 get(index)、set(index, e) 方法时需要遍历链表将指针移动到位进行访问（会判断 index 是否大于链表长度的一半决定是首部遍历还是尾部遍历，访问的复杂度为 O(N/2)），无法像 ArrayList 那样进行随机访问。(如果i>数组大小的一半，会从末尾移起)，只有在链表两头的操作（譬如 add()、addFirst()、removeLast() 或用在 iterator() 上的 remove() 操作）才不需要进行遍历寻找定位。具体感兴趣可以去看下 LinkedList 的源码。

86、HashMap底层扩容机制

     每次扩容的时候分组组数会直接*2 也就是变成原本的2倍大小 例如默认16组那么扩容一次之后变成32组

     首先HashMap构造方法可以传入两个参数，分别是int类型的分组组数和float类型的加载因子

     而其扩容跟阈值有关 只是在不同的JDK版本当中HashMap的实现也有区别.    

     所谓阈值 = 分组组数*加载因子 = 这是HashMap达到扩容条件的最小临界值

     *：当然在不同的JDK7.0当中，即便达到或者超过阈值，如果新元素要去的小组不为空，也会暂时不扩容

     以默认的分组组数16和加载因子0.75F为例 也就是Map map = new HashMap<>();

     那么阈值就是12 也就是第13个元素添加的时候可能会导致扩容，那么底层将从分16组变成分32组 然后所有元素进行重新散列

     毫无疑问，重新散列会消耗时间，在使用HashMap的时候我们应该让分组组数*加载因子>总共要存放的键值对总量

     以避免添加过程当中触发扩容操作

87、怎么提高HashMap的效率

     考你分组组数和加载因子

     我们可以让HashMap底层开辟更多的分组，然后在元素总量不变的情况下，分组组数越多每一组元素个数自然越少，效率自然越高。

     HashMap构造方法是可以传参数来指定分组组数和加载因子(又名装填因子)的，

     这两者相乘得到阈值也就是达到扩容条件的最小临界值

     我们使用HashMap应该在知道元素总量的情况下保证分组组数*加载因子>元素总量 从而避免添加过程当中触发扩容操作影响效率

     另外在这个条件成立的前提下只需要

     分组组数越大，数据将被散列到越多个小组，查找效率越高

      加载因子越小，扩容会发生的越早，也就是在尽可能的保证效率

88、HashMap如何调整性能和空间的取舍?

    构造方法的两个参数:int 分组组数 , float 加载因子

    在加载因子不变的情况下 如果我们让分组组数变大

        则效率更高 -> 但是需要更多的空间

    在分组组数不变的情况下 如果让加载因子变大

        则更加节省空间 -> 但是效率更低

    *:我们在已经知道要存放的元素个数的前提下 应该让

        分组组数*加载因子 > 元素总量     避免添加过程当中触发扩容操作

88、HashMap结构

Node：链表节点，包含了key、value、hash、next指针四个元素。

table：Node类型的数组，里面的元素是链表，用于存放HashMap元素的实体（table数组的大小，缺省值为16）。

size：记录了放入HashMap的元素个数。

loadFactor：负载因子（缺省值为0.75）。

threshold：阈值，决定了HashMap何时扩容，以及扩容后的大小，一般等于table大小乘以loadFactor。

简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。

88、HashMap什么时候扩容

当向容器添加元素的时候，会判断当前容器（table数组）的元素个数，如果大于等于阈值，即当前数组的长度乘以加载因子（缺省值为0.75）的值的时候，就要自动扩容啦。

89、HashMap的实现原理

1 HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

2 HashMap的数据结构：在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

当我们往Hashmap中put元素时,首先根据key的hashcode重新计算hash值,根绝hash值得到这个元素在数组中的位置(下标),如果该数组在该位置上已经存放了其他元素,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放入链尾.如果数组中该位置没有元素,就直接将该元素放到数组的该位置上.

90、HashMap是如何工作的？

HashMap是一个针对数据结构的键值，每个键都会有相应的值，关键是识别这样的值。

HashMap 基于 hashing 原理，我们通过 put ()和 get ()方法储存和获取对象。当我们将键值对传递给 put ()方法时，它调用键对象的 hashCode ()方法来计算 hashcode，让后找到 bucket 位置来储存值对象。当获取对象时，通过键对象的 equals ()方法找到正确的键值对，然后返回值对象。HashMap 使用 LinkedList 来解决碰撞问题，当发生碰撞了，对象将会储存在 LinkedList 的下一个节点中。 HashMap 在每个 LinkedList 节点中储存键值对对象。

90、Hashmap如何同步?

当我们需要一个同步的HashMap时，有两种选择：

1、使用Collections.synchronizedMap（..）来同步HashMap。

2、使用ConcurrentHashMap的

这两个选项之间的首选是使用ConcurrentHashMap，这是因为我们不需要锁定整个对象，以及通过ConcurrentHashMap分区地图来获得锁。

90、说一下hashmap以及它是否线程安全

HashMap基于哈希表的 Map 接口的实现。HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。HashMap中hash数组的默认大小是16，而且一定是2的指数。Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式 。HashMap 实现 Iterator，支持fast-fail。

哈希表是由数组+链表组成的，它是通过把key值进行hash来定位对象的，这样可以提供比线性存储更好的性能。HashMap不是线程安全的。

 

91、List,Map,Set三个接口，存取元素时各有什么特点？

list：有序的 可重复的 访问：可以for循环，foreach循环，iterator迭代器 迭代。
set：无序的 不重复的 访问：可以foreach循环，iterator迭代器 迭代
map：存储的是一对一对的映射 ”key=value“，key值 是无序，不重复的。value值可重复

访问：可以map中key值转为为set存储，然后迭代这个set，用map.get(key)获取value，也可以 转换为entry对象 用迭代器迭代

92、什么是 Vector 和 Stack，各有什么特点？

Vector 是线程安全的动态数组，同 ArrayList 一样继承自 AbstractList 且实现了 List、RandomAccess、Cloneable、Serializable 接口，内部实现依然基于数组，Vector 与 ArrayList 基本是一致的，唯一不同的是 Vector 是线程安全的，会在可能出现线程安全的方法前面加上 synchronized 关键字，其和 ArrayList 类似，随机访问速度快，插入和移除性能较差（数组原因），支持 null 元素，有顺序，元素可以重复，线程安全。

Stack 是继承自 Vector 基于动态数组实现的线程安全栈，不过现在已经不推荐使用了，Stack 是并发安全的后进先出，实现了一些栈基本操作的方法（其实并不是只能后进先出，因为继承自 Vector，所以可以有很多操作，严格说不是一个栈）。

其共同点都是使用了方法锁（即 synchronized）来保证并发安全的。

92、简单说说 ArrayList 和 Vector 的区别？

ArrayList 在默认数组容量不够时默认扩展是 1.5 倍，Vector 在 capacityIncrement 大于 0 时扩容 capacityIncrement 大小，否则扩容为原始容量的 2 倍。具体感兴趣可以去看二者源码。

1、Vector的方法都是同步的，是线程安全的，而ArrayList的方法不是，由于线程的同步必然要影响性能。因此，ArrayList的性能比Vector好。 
2、当Vector或ArrayList中的元素超过它的初始大小时，Vector会将它的容量翻倍，而ArrayList只增加50%的大小。 ArrayList就有利于节约内存空间。

3、大多数情况不使用Vector，因为性能不好，但是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性。

4、Vector可以设置增长因子，而ArrayList不可以。

适用场景分析：

1、Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。

2、如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。

93、为什么现在都不提倡使用 Vector 了？

因为 Vector 实现并发安全的原理是在每个操作方法上加锁，这些锁并不是必须要的，在实际开发中一般都是通过锁一系列的操作来实现线程安全，也就是说将需要同步的资源放一起加锁来保证线程安全，如果多个 Thread 并发执行一个已经加锁的方法，但是在该方法中又有 Vector 的存在，Vector 本身实现中已经加锁了，双重锁会造成额外的开销，即 Vector 同 ArrayList 一样有 fail-fast 问题（即无法保证遍历安全），所以在遍历 Vector 操作时又得额外加锁保证安全，还不如直接用 ArrayList 加锁性能好，所以在 JDK 1.5 之后推荐使用 java.util.concurrent 包下的并发类。此外 Vector 是一个从 JDK1.0 就有的古老集合，那时候 Java 还没有提供系统的集合框架，所以在 Vector 里提供了一些方法名很长的方法（如 addElement(Object obj)，实际上这个方法和 add(Object obj) 没什么区别），从 JDK1.2 以后 Java 提供了集合框架，然后就将 Vector 改为实现 List 接口，从而导致 Vector 里有一些重复的方法。

97、如何把一个map做成线程安全的。

如果需要使 Map 线程安全，大致有这么四种方法：

1、使用 synchronized 关键字，代码如下

synchronized(anObject) {

　　value = map.get(key);

}

2、使用 JDK1.5提供的锁（java.util.concurrent.locks.Lock）。代码如下

   lock.lock();

   value = map.get(key);

   lock.unlock();

3、使用 JDK1.5 提供的读写锁（java.util.concurrent.locks.ReadWriteLock）。代码如下

   rwlock.readLock().lock();

   value = map.get(key);

   rwlock.readLock().unlock();

   这样两个读操作可以同时进行，理论上效率会比方法 2 高。

4、使用 JDK1.5 提供的 java.util.concurrent.ConcurrentHashMap 类。该类将 Map 的存储空间分为若干块，每块拥有自己的锁，大大减少了多个线程争夺同一个锁的情况。代码如下

    value = map.get(key); //同步机制内置在 get 方法中

比较：

 

   1、不同步确实最快，与预期一致。

   2、四种同步方式中，ConcurrentHashMap 是最快的，接近不同步的情况。

   3、synchronized 关键字非常慢，比使用锁慢了两个数量级。如果需自己实现同步，则使  用 JDK1.5 提供的锁机制，避免使用 synchronized 关键字。

98、不知道一个map集合的大小的情况下，怎么把它遍历出来（或者问Map是怎么取值的）

import java.util.*;

public class Test{

        public static void main(String[] args){

                 Map map = new HashMap();

                 Set