阿里Java基础面试题文档.docx

阿里Java基础面试题文档.docx

《阿里Java基础面试题文档.docx》由会员分享，可在线阅读，更多相关《阿里Java基础面试题文档.docx（16页珍藏版）》请在冰豆网上搜索。

阿里Java基础面试题文档

1．自我介绍

2．讲一件你印象最深刻的事没事怎么解决的

3．垃圾回收机制怎么工作的

4．是怎么实现的

5．的区别是什么

6．讲一下你对的认识，然后谈一下的性能，主要谈一下哈希冲撞

7．创造线程的几种方式，和接口有什么区别

8．简单说一下你参加的中兴算法大赛

9．说一下你做的聊天工具，如果遇到服务突然卡顿，怎么解决

10．讲一下你对于框架的了解

11．数据库，索引是怎么使用的。

12．你对分布式是否有所了解

13．你对数据结构了解么

14．你为什么想转行做软件呢

15．和

16．浅析与的线程安全性

17．堆排序，快速排序

18．数据库的四大特征，数据库的隔离级别，

19．线程同步机制用的什么？

当初为什么选择这个机制？

20．互斥和条件变量区别？

互斥是阻塞的吗？

当初为什么选择阻塞的机制？

21.消息队列

22.分布式

中多态性的实现

什么是多态

1.面向对象的三大特性：

封装、继承、多态。

从一定角度来看，封装和继承几乎都是为多态而准备的。

这是我们最后一个概念，也是最重要的知识点。

2.多态的定义：

指允许不同类的对象对同一消息做出响应。

即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

（发送消息就是函数调用）

3.实现多态的技术称为：

动态绑定（），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

4.多态的作用：

消除类型之间的耦合关系。

5.现实中，关于多态的例子不胜枚举。

比方说按下F1键这个动作，如果当前在界面下弹出的就是3的帮助文档；如果当前在下弹出的就是帮助；在下弹出的就是帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

下面是多态存在的三个必要条件，要求大家做梦时都能背出来！

多态存在的三个必要条件

一、要有继承；

二、要有重写；

三、父类引用指向子类对象。

中多态的实现方式：

接口实现，继承父类进行方法重写，同一个类中进行方法重载。

与的区别

简单地说，就是一个变量和常量的关系。

对象的内容可以修改；而对象一旦产生后就不可以被修改，重新赋值其实是两个对象。

的内部实现方式和不同，在进行字符串处理时，不生成新的对象，在内存使用上要优于类。

所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入、删除等操作，使用要更加适合一些。

:

在类中没有用来改变已有字符串中的某个字符的方法，由于不能改变一个字符串中的某个单独字符，所以在文档中称类的对象是不可改变的。

然而，不可改变的字符串具有一个很大的优点:

编译器可以把字符串设为共享的。

类属于一种辅助类，可预先分配指定长度的内存块建立一个字符串缓冲区。

这样使用类的方法追加字符比使用+操作符添加字符到一个已经存在的字符串后面有效率得多。

因为使用+操作符每一次将字符添加到一个字符串中去时，字符串对象都需要寻找一个新的内存空间来容纳更大的字符串，这无凝是一个非常消耗时间的操作。

添加多个字符也就意味着要一次又一次的对字符串重新分配内存。

使用类就避免了这个问题。

是线程安全的，在多线程程序中也可以很方便的进行使用，但是程序的执行效率相对来说就要稍微慢一些。

的常用方法

类中的方法要偏重于对字符串的变化例如追加、插入和删除等，这个也是和类的主要区别。

字符串常量

字符串变量（线程安全）

字符串变量（非线程安全）

 简要的说，类型和类型的主要性能区别其实在于是不可变的对象,因此在每次对类型进行改变的时候其实都等同于生成了一个新的对象，然后将指针指向新的对象，所以经常改变内容的字符串最好不要用，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后，的就会开始工作，那速度是一定会相当慢的。

 而如果是使用类则结果就不一样了，每次结果都会对对象本身进行操作，而不是生成新的对象，再改变对象引用。

所以在一般情况下我们推荐使用，特别是字符串对象经常改变的情况下。

而在某些特别情况下，对象的字符串拼接其实是被解释成了对象的拼接，所以这些时候对象的速度并不会比对象慢，而特别是以下的字符串对象生成中，效率是远要比快的：

 S1=“a”+“”+“”;

 =（“a”）（“”）（“”）;

 你会很惊讶的发现，生成S1对象的速度简直太快了，而这个时候居然速度上根本一点都不占优势。

其实这是的一个把戏，在眼里，这个

 S1=“a”+“”+“”;其实就是：

 S1=“a”;所以当然不需要太多的时间了。

但大家这里要注意的是，如果你的字符串是来自另外的对象的话，速度就没那么快了，譬如：

S2=“a”;

S3=“”;

S4=“”;

S1=S23+S4;

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

在大部分情况下>

线程安全的可变字符序列。

一个类似于的字符串缓冲区，但不能修改。

虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

可将字符串缓冲区安全地用于多个线程。

可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

上的主要操作是和方法，可重载这些方法，以接受任意类型的数据。

每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。

方法始终将这些字符添加到缓冲区的末端；而方法则在指定的点添加字符。

例如，如果z引用一个当前内容是“”的字符串缓冲区对象，则此方法调用（""）会使字符串缓冲区包含“”，而（4,""）将更改字符串缓冲区，使之包含“”。

在大部分情况下>

一个可变的字符序列是5.0新增的。

此类提供一个与兼容的，但不保证同步。

该类被设计用作的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

如果可能，建议优先采用该类，因为在大多数实现中，它比要快。

两者的方法基本相同。

在数据结构中有一种称为哈希表的数据结构，它实际上是数组的推广。

如果有一个数组，要最有效的查找某个元素的位置，如果存储空间足够大，那么可以对每个元素和内存中的某个地址对应起来，然后把每个元素的地址用一个数组（这个数组也称为哈希表）存储起来，然后通过数组下标就可以直接找到某个元素了。

这种方法术语叫做直接寻址法。

这种方法的关键是要把每个元素和某个地址对应起来，所以如果当一组数据的取值范围很大的时候，而地址的空间又有限，那么必然会有多个映射到同一个地址，术语上称为哈希冲突，这时映射到同一个地址的元素称为同义词。

毕竟，存储空间有限，所以冲突是不可避免的，但是可以尽量做到减少冲突。

目前有两种比较有效的方法来解决哈希冲突：

链地址法

开放地址法

这里简要说明一下开放地址法，顾名思义，就是哈希表中的每个位置要么存储了一个元素要么为。

当数据比较多的时候，查找一个元素挺费事的，但是可以使用探测的方法进行查找。

这个话题与本主题关系不大，感兴趣的小伙伴可以自行研究。

从这段注释中可以发现每次执行的方法都是调用（）方法的，而对象是一个继承了锁对象的子类，那么剩下的就很清晰了，每一个都有一个锁，只有执行完上面语句块中的代码才会释放锁，从而保证了多线程并发访问的安全性。

什么是线程同步？

当使用多个线程来访问同一个数据时，非常容易出现线程安全问题（比如多个线程都在操作同一数据导致数据不一致）,所以我们用同步机制来解决这些问题。

实现同步机制有两个方法：

1.同步代码块：

（同一个数据）{} 同一个数据：

就是N条线程同时访问一个数据。

2.同步方法：

 数据返回类型方法名（）{}

就是使用来修饰某个方法，则该方法称为同步方法。

对于同步方法而言，无需显示指定同步监视器，同步方法的同步监视器是 也就是该对象的本身（这里指的对象本身有点含糊，其实就是调用该同步方法的对象）通过使用同步方法，可非常方便的将某类变成线程安全的类，具有如下特征：

1，该类的对象可以被多个线程安全的访问。

2，每个线程调用该对象的任意方法之后，都将得到正确的结果。

3，每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。

注：

关键字可以修饰方法，也可以修饰代码块，但不能修饰构造器，属性等。

实现同步机制注意以下几点：

安全性高，性能低，在多线程用。

性能高，安全性低，在单线程用。

1，不要对线程安全类的所有方法都进行同步，只对那些会改变共享资源方法的进行同步。

2，如果可变类有两种运行环境，当线程环境和多线程环境则应该为该可变类提供两种版本：

线程安全版本和线程不安全版本（没有同步方法和同步块）。

在单线程中环境中，使用线程不安全版本以保证性能，在多线程中使用线程安全版本.

一：

进程与线程

概述：

几乎任何的操作系统都支持运行多个任务，通常一个任务就是一个程序，而一个程序就是一个进程。

当一个进程运行时，内部可能包括多个顺序执行流，每个顺序执行流就是一个线程。

进程：

进程是指处于运行过程中的程序，并且具有一定的独立功能。

进程是系统进行资源分配和调度的一个单位。

当程序进入内存运行时，即为进程。

进程的三个特点：

1：

独立性：

进程是系统中独立存在的实体，它可以独立拥有资源，每一个进程都有自己独立的地址空间，没有进程本身的运行，用户进程不可以直接访问其他进程的地址空间。

2：

动态性：

进程和程序的区别在于进程是动态的，进程中有时间的概念，进程具有自己的生命周期和各种不同的状态。

3：

并发性：

多个进程可以在单个处理器上并发执行，互不影响。

并发性和并行性是不同的概念：

并行是指同一时刻，多个命令在多个处理器上同时执行；并发是指在同一时刻，只有一条命令是在处理器上执行的，但多个进程命令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果

线程：

线程是进程的组成部分，一个进程可以拥有多个线程，而一个线程必须拥有一个父进程。

线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源。

它与父进程的其他线程共享该进程的所有资源。

线程的特点：

线程可以完成一定任务，可以和其它线程共享父进程的共享变量和部分环境，相互协作来完成任务。

线程是独立运行的，其不知道进程中是否还有其他线程存在。

线程的执行是抢占式的，也就是说，当前执行的线程随时可能被挂起，以便运行另一个线程。

一个线程可以创建或撤销另一个线程，一个进程中的多个线程可以并发执行。

1.进程的三种基本状态

进程在运行中不断地改变其运行状态。

通常，一个运行进程必须具有以下三种基本状态。

（1）就绪（）状态

当进程已分配到除以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。

（2）执行（）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。

（3）阻塞（）状态正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。

引起进程阻塞的事件可有多种，例如，等待完成、申请缓冲区不能满足、等待信件（信号）等。

阻塞的情况分三种：

（1）、等待阻塞：

运行的线程执行（）方法，该线程会释放占用的所有资源，会把该线程放入“等待池”中。

进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用（）或（）方法才能被唤醒，

（2）、同步阻塞：

运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则会把该线程放入“锁池”中。

（3）、其他阻塞：

运行的线程执行（）或（）方法，或者发出了请求时，会把该线程置为阻塞状态。

当（）状态超时、（）等待线程终止或者超时、或者处理完毕时，线程重新转入就绪状态。

同步机制：

1、