java基础知识点整理

1.&和&&的区别？

&：逻辑与（and）,运算符两边的表达式均为true时，整个结果才为true。
&&：短路与，如果第一个表达式为false时，第二个表达式就不会计算了。

2.在java中如何跳出当前的多重循环？

在循环语句外前面定义一个标号，然后在里层循环体的代码中使用带有标号的break语句，即可跳出循环。
比如：
ok:
for (int i = 0; i < 10; i++) {
{
for (int j = 0; j < 10; j++) {
break ok;
}
}
}

3.最有效率的方法算出2X8等于几？

使用位运算，效率最高：2<<3,表示2向右移动了3位，就相当于2乘以2的3次方,结果：16。

4.”==”和equals方法究竟有什么区别？

== 表示两个变量的值是否相等，比较两个基本数据类型的数据或者引用变量，用==。
equals:用于比较两个独立对象的内容是否相同。字符串的比较也用equals。

5. Int和integer的区别？

Int是Java的8中基本数据类型之一，integer是int的封装类。Int类型的默认值为0，integer默认值为null，所以区别在于，integer能区分出null值和0的区别。

6.三个与取整有关的方法：

Math.ceil():表示向上取整；Math.ceil(11.3)=12;Math.ceil(-11.3)=-12。
Math.floor():表示向下取整；Math.floor(11.6)=12;Math.floor(-11.6)=-12。
Math.round():表示四舍五入；Math.round(11.5)=12;Math.round(-11.5)=-11;
Marh.round(11.3)=11;Math.round(-11.3)=–11;

7.重载和重写的区别？

重载（Overload）：函数名相同，参数不同。可以改变返回值类型，参数的个数和类型。
重写（Override）：和父类的的方法名称、参数完全相同。

8.面向对象的特征？

封装：将对象属性和方法的代码封装到一个模块中，也就是一个类中，保证软件内部具有优良的模块性的基础，实现“高内聚，低耦合”。
抽象：找出一些事物的相似和共性之处，然后归为一个类，该类只考虑事物的相似和共性之处。抽象包括行为抽象和状态抽象。
继承：在已经存在的类的基础上进行，将其定义的内容作为自己的内容，并可以加入新的内容或者修改原来的方法适合特殊的需要。
多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，就是多态，简单点说：就是用父类的引用指向子类的对象。目的：提高代码复用性，解决项目中紧耦合问题，提高可扩展性。
多态的机制：靠的是父类的或者接口的引用变量可以指向子类或者具体实现类的实例对象。

9.String和StringBuffuer、StringBuilder的区别？

String:字符串数值不可变，String不可变是因为在JDK中String类被声明为一个final类
StringBuffer：字符串可修改，可以动态构造字符数据。StringBuffer类是可以通过Append()来修改值。线程安全。
StringBuilder：线程不安全。

三者在执行速度方面的比较：StringBuilder > StringBuffer > String
对于三者使用的总结：
1.如果要操作少量的数据用 = String　　
2.单线程操作字符串缓冲区下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区下操作大量数据 = StringBuffer

11.sleep()和wait()有什么区别？

sleep是线程被调用时，占着cpu休眠，其他线程不能占用cpu，os认为该线程正在工作，不会让出系统资源，wait是进入等待池等待，让出系统资源，其他线程可以占用cpu。

sleep()和wait()方法的区别可从两个角度阐述：
1.cpu的抢占权；2.锁旗标是否释放
两者都会释放cpu的抢占权；
wait()方法执行完即可释放锁旗标，进入线程的等待队列；
sleep()执行完，不会释放，进入等待队列；

12. 同步和异步的区别？同步的实现方法？

同步:发送一个请求,等待返回,然后再发送下一个请求。实现：1. Synchronized修饰；2.wait和notify。
异步:发送一个请求,不等待返回,随时可以再发送下一个请求。

同步可以避免出现死锁,读脏数据的发生，一般共享某一资源的时候用，如果每个人都有修改权限，同时修改一个文件，有可能使一个人读取另一个人已经删除的内容，就会出错，同步就会按顺序来修改。

同步和异步最大的区别就在于，一个需要等待，一个不需要等待。

比如广播，就是一个异步例子。发起者不关心接收者的状态。不需要等待接收者的返回信息。

电话，就是一个同步例子。发起者需要等待接收者，接通电话后，通信才开始。需要等待接收者的返回信息。

13. 请对比synchronized与java.util.concurrent.locks.Lock的异同？

主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

14.String s =new String (“syz”);创建了几个String Object?

1.如果String常理池(常量缓冲区)中，已经创建"xyz"，则不会继续创建，此时只创建了一个对象new String(“xyz”)；
2.如果String常理池中，没有创建"xyz"，则会创建两个对象，一个对象的值是"xyz"，一个对象new String(“xyz”)。

15.作用域public、private、protected 以及不写时的区别？

private修饰的成员变量和函数只能在类本身和内部类中被访问。

protected 修饰的成员变量和函数能被类本身、子类及同一个包中的类访问。

public修饰的成员变量和函数可以被类、子类、同一个包中的类以及任意其他类访问。

默认情况（不写）下，属于一种包访问，即能被类本身以及同一个包中的类访问。

20.HashTable, HashMap，TreeMap区别？

1、HashTable线程同步，HashMap非线程同步。
2、HashTable不允许<键,值>有空值，HashMap允许<键,值>有空值。
3、HashTable使用Enumeration，HashMap使用Iterator。
4、HashTable中hash数组的默认大小是11，增加方式的old*2+1，HashMap中hash数组的默认大小是16，增长方式一定是2的指数倍。
5、TreeMap能够把它保存的记录根据键排序，默认是按升序排序。

21.List、Set和Map的区别？

List:是存储单列数据的集合，存储有顺序，允许重复。继承Collection接口。
Set: 是存储单列数据的集合。继承Collection接口。不允许重复。
Map:存储键和值这样的双列数据的集合，存储数据无顺序，键(key)不能重复，值(value)。可以重复。

22.什么时候用assert？

在调试程序时使用，对一个boolean表达式进行检查。为true，则程序正确，如果为false，系统则给出警告或者退出。

24.java创建对象的方式有哪些？

1.使用new关键字

2.使用反射机制创建对象：

(1)使用Class类的newInstance方法

(2)java.lang.reflect.Constructor类里也有一个newInstance方法可以创建对象。

3.使用clone方法：先实现Cloneable接口并实现其定义的clone方法

4.使用反序列化

25.java垃圾回收机制

GC是垃圾回收机制，是用来释放内存中的资源的。
垃圾回收可以有效的防止内存泄露，有效的使用空闲的内存。

26.error和exception有什么区别?

Error（错误）表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题。比如：内存资源不足等。对于这种错误，程序基本无能为力，除了退出运行外别无选择，它是由Java虚拟机抛出的。

Exception（违例）表示需要捕捉或者需要程序进行处理的异搜索常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。

Exception又分为运行时异常，受检查异常。

运行时异常，表示无法让程序恢复的异常，导致的原因通常是因为执行了错误的操作，建议终止程序，因此，编译器不检查这些异常。

受检查异常，是表示程序可以处理的异常，也即表示程序可以修复（由程序自己接受异常并且做出处理）， 所以称之为受检查异常。

27.Int如何去重复？

1.For循环
2.Set集合

28.JDBC使用步骤过程？

1、加载JDBC驱动程序：
2、提供JDBC连接的URL
3、创建数据库的连接
4、创建一个Statement
5、执行SQL语句
6、处理结果
7、关闭JDBC对象

29.运行时异常与一般异常有何异同？

Java提供了两类主要的异常:运行时异常runtime exception和一般异常checked exception。对于后者这种一般异常，JAVA要求程序员对其进行catch处理。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。
运行时异常我们可以不处理。这样的异常由虚拟机接管。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

30.抽象类和接口区别?

抽象类：用abstract修饰，抽象类不能创建实例对象。抽象方法必须在子类中实现，不能有抽象构造方法或者抽象静态方法。

接口：抽象类的一种特例，接口中的方法必须是抽象的。

两者的区别：

抽象类可以有构造方法，接口没有构造方法
抽象类可以有普通成员变量，接口没有普通成员变量。
抽象类可以有非抽象的普通方法，接口中的方法必须是抽象的。
抽象类中的抽象方法访问类型可以是public，protected，接口中抽闲方法必须是public类型的。
抽象类可以包含静态方法，接口中不能包含静态方法。
一个类可以实现多个接口，但是只能继承一个抽象类。
7.接口中基本数据类型的数据成员，都默认为static和final，抽象类则不是。

31.如何获取map集合中的数据？

// 方法一： for each + map.keySet();

Set<Integer> set = map.keySet();  
for (Integer key : set) {  
    System.out.println("key:" + key + ", value:" + map.get(key));  
}

// 方法二：while循环(Iterator + map.keySet()😉

Set<Integer> set = map.keySet();  
Iterator<Integer> it = set.iterator();  
while(it.hasNext()){  
    Integer key = it.next();  
    System.out.println("key:" + key + ", value:" + map.get(key));  
}

// 方法三：while循环(Iterator +Map.Entry<Key, Value>)

Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();  
while (it.hasNext()) {  
    Map.Entry<Integer, String> entry = it.next();  
    System.out.println("key:"+entry.getKey() + ", value:"+entry.getValue());  
}

// 方法四：for循环(Iterator + Map.Entry<Key, Value>)

for(Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator(); it.hasNext();){  
    Map.Entry<Integer, String> entry = it.next();  
    System.out.println("key:" + entry.getKey() + ", value:" +entry.getValue());  
}

// 方法五：for each + Map.Entry<Key, Value>

for(Map.Entry<Integer, String> entry : map.entrySet()){  
    System.out.println("key:" + entry.getKey() + ", value:" +entry.getValue());  
}

32.hashCode与equals的区别与联系？

一、equals方法的作用

1、默认情况（没有覆盖equals方法）下equals方法都是调用Object类的equals方法，而Object的equals方法主要用于判断对象的内存地址引用是不是同一个地址（是不是同一个对象）。

2 、要是类中覆盖了equals方法，那么就要根据具体的代码来确定equals方法的作用了，覆盖后一般都是通过对象的内容是否相等来判断对象是否相等。

二、Hashcode（）方法：

1、我们并没有覆盖equals方法只覆盖了hashCode方法，两个对象虽然hashCode一样，但在将stu1和stu2放入set集合时由于equals方法比较的两个对象是false，所以就没有在比较两个对象的hashcode值。

2、覆盖一下equals方法和hashCode方法，stu1和stu2通过equals方法比较相等，而且返回的hashCode值一样，所以放入set集合中时只放入了一个对象。

3、我们让两个对象equals方法比较相等，但hashCode值不相等试试，虽然stu1和stu2通过equals方法比较相等，但两个对象的hashcode的值并不相等，所以在将stu1和stu2放入set集合中时认为是两个不同的对象。

总结：

1、equals方法用于比较对象的内容是否相等（覆盖以后）

2、hashcode方法只有在集合中用到

3、当覆盖了equals方法时，比较对象是否相等将通过覆盖后的equals方法进行比较（判断对象的内容是否相等）。

4、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。

33.Java中什么是竞态条件?

当两个线程竞争同一资源时，如果对资源的访问顺序敏感，就称存在竞态条件。导致竞态条件发生的代码区称作临界区。在临界区中使用适当的同步就可以避免竞态条件。 界区实现方法有两种，一种是用synchronized，一种是用Lock显式锁实现。

34.线程死锁及解决办法

1)、让所有的线程按照同样的顺序获得一组锁。这种方法消除了 X 和 Y 的拥有者分别等待对方的资源的问题。
　2)、将多个锁组成一组并放到同一个锁下。前面Java线程死锁的例子中，可以创建一个银器对象的锁。于是在获得刀或叉之前都必须获得这个银器的锁。
　　3)、将那些不会阻塞的可获得资源用变量标志出来。当某个线程获得银器对象的锁时，就可以通过检查变量来判断是否整个银器集合中的对象锁都可获得。如果是，它就可以获得相关的锁，否则，就要释放掉银器这个锁并稍后再尝试。

35.ArrayList和LinkList的区别

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据，而查询和修改ArrayList占优势。

36.Socket和HTTP区别？

socket则是对TCP/IP协议的封装和应用(程序员层面上)， Socket本身并不是协议，而是一个调用接口(API)。也可以说，TPC/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。

38.多线程中thread的start（）和run()的区别？

1） start：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2） run：

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void。

39.final关键字的用法

一、final修饰类：
被final修饰的类，是不可以被继承的，这样做的目的可以保证该类不被修改，Java的一些核心的API都是final类，例如String、Integer、Math等。
二、final修饰方法：
子类不可以重写父类中被final修饰的方法。
三、final修饰实例变量(类的属性，定义在类内，但是在类内的方法之外)
final修饰实例变量时必须初始化，且不可再修改。//
四、final修饰局部变量(方法体内的变量)
final修饰局部变量时只能初始化(赋值)一次，但也可以不初始化。
五、final修饰方法参数
final修饰方法参数时，是在调用方法传递参数时候初始化的。

40.Vector,ArrayList, LinkedList的区别是什么？

1、Vector、ArrayList都是以类似数组的形式存储在内存中，LinkedList则以链表的形式进行存储。
2、List中的元素有序、允许有重复的元素，Set中的元素无序、不允许有重复元素。
3、Vector线程同步，ArrayList、LinkedList线程不同步。
4、LinkedList适合指定位置插入、删除操作，不适合查找；ArrayList、Vector适合查找，不适合指定位置的插入、删除操作。
5、ArrayList在元素填满容器时会自动扩充容器大小的50%，而Vector则是100%，因此ArrayList更节省空间。

41. Tomcat，Apache，JBoss的区别？

1、Apache是Http服务器，Tomcat是web服务器，JBoss是应用服务器。
2、Apache解析静态的html文件；Tomcat可解析jsp动态页面、也可充当servlet容器。

42. GET，POST区别？

基础知识：Http的请求格式如下。
主要包含三个信息：1、请求的类型（GET或POST），2、要访问的资源（如\res\img\a.jif），3、Http版本（http/1.1）

区别：
1、Get是从服务器端获取数据，Post则是向服务器端发送数据。
2、在客户端，Get方式通过URL提交数据，在URL地址栏可以看到请求消息，该消息被编码过；Post数据则是放在Html header内提交。
3、对于Get方式，服务器端用Request.QueryString获取变量的值；对用Post方式，服务器端用Request.Form获取提交的数据值。
4、Get方式提交的数据最多1024字节，而Post则没有限制。
5、Get方式提交的参数及参数值会在地址栏显示，不安全，而Post不会，比较安全。

43. Session, Cookie区别

1、Session由应用服务器维护的一个服务器端的存储空间；Cookie是客户端的存储空间，由浏览器维护。
2、用户可以通过浏览器设置决定是否保存Cookie，而不能决定是否保存Session，因为Session是由服务器端维护的。
3、Session中保存的是对象，Cookie中保存的是字符串。
4、Session和Cookie不能跨窗口使用，每打开一个浏览器系统会赋予一个SessionID，此时的SessionID不同，若要完成跨浏览器访问数据，可以使用 Application。
5、Session、Cookie都有失效时间，过期后会自动删除，减少系统开销。

44, Servlet的生命周期

大致分为4部：Servlet类加载–>实例化–>服务–>销毁
下图是Tomcat中Servlet时序图。

1、Web Client向Servlet容器(Tomcat)发出Http请求。
2、Servlet容器接收Client端的请求。
3、Servlet容器创建一个HttpRequest对象，将Client的请求信息封装到这个对象中。
4、Servlet创建一个HttpResponse对象。
5、Servlet调用HttpServlet对象的service方法，把HttpRequest对象和HttpResponse对象作为参数传递给HttpServlet对象中。
6、HttpServlet调用HttpRequest对象的方法，获取Http请求，并进行相应处理。
7、处理完成HttpServlet调用HttpResponse对象的方法，返回响应数据。
8、Servlet容器把HttpServlet的响应结果传回客户端。

其中的3个方法说明了Servlet的生命周期：
1、init()：负责初始化Servlet对象。
2、service()：负责响应客户端请求。
3、destroy()：当Servlet对象推出时，负责释放占用资源。

45, 反射讲一讲，主要是概念,都在哪需要反射机制，反射的性能，如何优化

反射机制的定义：
是在运行状态中，对于任意的一个类，都能够知道这个类的所有属性和方法，对任意一个对象都能够通过反射机制调用一个类的任意方法，这种动态获取类信息及动态调用类对象方法的功能称为java的反射机制。
反射的作用：
1、动态地创建类的实例，将类绑定到现有的对象中，或从现有的对象中获取类型。
2、应用程序需要在运行时从某个特定的程序集中载入一个特定的类

46, 线程同步，并发操作怎么控制

Java中可在方法名前加关键字syschronized来处理当有多个线程同时访问共享资源时候的问题。syschronized相当于一把锁，当有申请者申请该
资源时，如果该资源没有被占用，那么将资源交付给这个申请者使用，在此期间，其他申请者只能申请而不能使用该资源，当该资源被使用完成后将释放该资源上的锁，其他申请者可申请使用。
并发控制主要是为了多线程操作时带来的资源读写问题。如果不加以空间可能会出现死锁，读脏数据、不可重复读、丢失更新等异常。
并发操作可以通过加锁的方式进行控制，锁又可分为乐观锁和悲观锁。
悲观锁：
悲观锁并发模式假定系统中存在足够多的数据修改操作，以致于任何确定的读操作都可能会受到由个别的用户所制造的数据修改的影响。也就是说悲观锁假定冲突总会发生，通过独占正在被读取的数据来避免冲突。但是独占数据会导致其他进程无法修改该数据，进而产生阻塞，读数据和写数据会相互阻塞。
乐观锁：
乐观锁假定系统的数据修改只会产生非常少的冲突，也就是说任何进程都不大可能修改别的进程正在访问的数据。乐观并发模式下，读数据和写数据之间不会发生冲突，只有写数据与写数据之间会发生冲突。即读数据不会产生阻塞，只有写数据才会产生阻塞。

47, springMVC的执行流程

springMVC是由dispatchservlet为核心的分层控制框架。首先客户端发出一个请求web服务器解析请求url并去匹配dispatchservlet的映射url，如果匹配上就将这个请求放入到dispatchservlet，dispatchservlet根据mapping映射配置去寻找相对应的handel，然后把处理权交给找到的handel，handel封装了处理业务逻辑的代码，当handel处理完后会返回一个逻辑视图modelandview给dispatchservlet，此时的modelandview是一个逻辑视图不是一个正式视图，所以dispatchservlet会通过viewresource视图资源去解析modelandview，然后将解析后的参数放到view中返回到客户端并展现。

48, 给定一个txt文件，如何得到某字符串出现的次数

File file  = new File( "E://test.txt" );
InputStream is  = new FileInputStream( file );
byte b[] = new byte[1024];
int a  = is.read( b );
String str[] = new String( b, 0, a ).split( "" );
int count  = 0;
for ( int i  = 0; i < str.length; i++ )
{
    if ( "a".equals( str[i] ) )
        count++;
}
System.out.println( count );

49, 对ajax的理解

Ajax为异步请求，即局部刷新技术，在传统的页面中，用户需要点击按钮或者事件触发请求，到刷新页面，而异步技术为不需要点击即可触发事件，这样使得用户体验感增强，比如商城购物车的异步加载，当你点击商品时无需请求后台而直接动态修改参数。

50, AOP与IOC的概念（即spring的核心）

a) IOC：Spring是开源框架，使用框架可以使我们减少工作量，提高工作效率并且它是分层结构，即相对应的层处理对应的业务逻辑，减少代码的耦合度。而spring的核心是IOC控制反转和AOP面向切面编程。IOC控制反转主要强调的是程序之间的关系是由容器控制的，容器控制对象，控制了对外部资源的获取。而反转即为，在传统的编程中都是由我们创建对象获取依赖对象，而在IOC中是容器帮我们创建对象并注入依赖对象，正是容器帮我们查找和注入对象，对象是被获取，所以叫反转。

b) AOP：面向切面编程，主要是管理系统层的业务，比如日志，权限，事物等。AOP是将封装好的对象剖开，找出其中对多个对象产生影响的公共行为，并将其封装为一个可重用的模块，这个模块被命名为切面（aspect），切面将那些与业务逻辑无关，却被业务模块共同调用的逻辑提取并封装起来，减少了系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。

50, hibernate的核心思想

a) Hibernate的核心思想是ROM对象关系映射机制。它是将表与表之间的操作映射成对象与对象之间的操作。也就是从数据库中提取的信息会自动按照你设置的映射要求封装成特定的对象。所以hibernate就是通过将数据表实体类的映射，使得对对象的修改对应数据行的修改。

51，Struts1与Struts2的区别

52，最优删除谋字符串的某个字符

53，mybaties与ibatise的区别

54，类加载的过程

a) 遇到一个新的类时，首先会到方法区去找class文件，如果没有找到就会去硬盘中找class文件，找到后会返回，将class文件加载到方法区中，在类加载的时候，静态成员变量会被分配到方法区的静态区域，非静态成员变量分配到非静态区域，然后开始给静态成员变量初始化，赋默认值，赋完默认值后，会根据静态成员变量书写的位置赋显示值，然后执行静态代码。当所有的静态代码执行完，类加载才算完成。

55，对象的创建

a) 遇到一个新类时，会进行类的加载，定位到class文件
b) 对所有静态成员变量初始化，静态代码块也会执行，而且只在类加载的时候执行一次
c) New 对象时，jvm会在堆中分配一个足够大的存储空间
d) 存储空间清空，为所有的变量赋默认值，所有的对象引用赋值为null
e) 根据书写的位置给字段一些初始化操作
f) 调用构造器方法（没有继承）

56，事务的理解

57，其他未整理

1、集合类以及集合框架；HashMap与HashTable实现原理，线程安全性，hash冲突及处理算法；ConcurrentHashMap；
2、进程和线程的区别；
3、Java的并发、多线程、线程模型；
4、什么是线程池，如何使用?
5、数据一致性如何保证；Synchronized关键字，类锁，方法锁，重入锁；
6、Java中实现多态的机制是什么；
7、如何将一个Java对象序列化到文件里；
8、说说你对Java反射的理解；
9、同步的方法；多进程开发以及多进程应用场景；
10、在Java中wait和seelp方法的不同；
11、synchronized 和volatile 关键字的作用；
12、volatile 本质是在告诉jvm 当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized 则是锁定当前变量，
13、服务器只提供数据接收接口，在多线程或多进程条件下，如何保证数据的有序到达；
14、ThreadLocal原理，实现及如何保证Local属性；
15、String StringBuilder StringBuffer对比；
16、你所知道的设计模式有哪些；
17、Java如何调用c、c++语言；
18、接口与回调；回调的原理；写一个回调demo；
19、泛型原理，举例说明；解析与分派；
20、抽象类与接口的区别；应用场景；抽象类是否可以没有方法和属性；
21、静态属性和静态方法是否可以被继承？是否可以被重写？以及原因？
22、修改对象A的equals方法的签名，那么使用HashMap存放这个对象实例的时候，会调用哪个equals方法；
23、说说你对泛型的了解；
24、Java的异常体系；
25、如何控制某个方法允许并发访问线程的个数；
26、动态代理的区别，什么场景使用；
27、Dex加载过程和优化方式；
28、Jvm和Gc机制；
29、常用的设计模式。

58，其他未整理

JAVA中的几种基本数据类型是什么，各自占用多少字节。
String类能被继承吗，为什么。
String，Stringbuffer，StringBuilder的区别。
ArrayList和LinkedList有什么区别。
讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字
段，当new的时候，他们的执行顺序。
用过哪些Map类，都有什么区别，HashMap是线程安全的吗,并发下使用的Map是什么，他们
内部原理分别是什么，比如存储方式，hashcode，扩容，默认容量等。
JAVA8的ConcurrentHashMap为什么放弃了分段锁，有什么问题吗，如果你来设计，你如何
设计。
有没有有顺序的Map实现类，如果有，他们是怎么保证有序的。
抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接口
么。
继承和聚合的区别在哪。
IO模型有哪些，讲讲你理解的nio ，他和bio，aio的区别是啥，谈谈reactor模型。
反射的原理，反射创建类实例的三种方式是什么。
反射中，Class.forName和ClassLoader区别 。
描述动态代理的几种实现方式，分别说出相应的优缺点。
动态代理与cglib实现的区别。
为什么CGlib方式可以对接口实现代理。
final的用途。
写出三种单例模式实现 。
如何在父类中为子类自动完成所有的hashcode和equals实现？这么做有何优劣。
请结合OO设计理念，谈谈访问修饰符public、private、protected、default在应用设
计中的作用。
深拷贝和浅拷贝区别。
数组和链表数据结构描述，各自的时间复杂度。
error和exception的区别，CheckedException，RuntimeException的区别。
请列出5个运行时异常。
在自己的代码中，如果创建一个java.lang.String类，这个类是否可以被类加载器加
载？为什么。
说一说你对java.lang.Object对象中hashCode和equals方法的理解。在什么场景下需
要重新实现这两个方法。
在jdk1.5中，引入了泛型，泛型的存在是用来解决什么问题。
这样的a.hashcode() 有什么用，与a.equals(b)有什么关系。
有没有可能2个不相等的对象有相同的hashcode。
Java中的HashSet内部是如何工作的。
什么是序列化，怎么序列化，为什么序列化，反序列化会遇到什么问题，如何解决。
java8的新特性。