面试题（部分有答案）

一、 Java

1.jre和jdk

• JDK
  • JRE
    • JVM
    • LIB
  • JavaC
  • Java
  • JDB
  • Java API

JVM：Java虚拟机，运行Java程序，是Java能实现跨平台性的关键
JRE：Java运行环境，包括Java虚拟机和Java的一些核心类库
JDK：Java开发工具包，包含JRE和供开发者开发的工具
只安装jre的话只能运行Java程序，只有安装了jdk可以进行开发和运行Java程序

2.Java的三大特性，以及如何理解多态

封装，继承，多态；后者都是建立在前者的基础上实现的
多态：多态是同一个行为具有多个不同表现形式或形态的能力，多态体现为父类引用变量可以指向子类对象。多态就是同一个接口，使用不同的实例而执行不同操作。

3.抽象类和接口的异同

实现方式不同：抽象类只能被继承，接口可以被实现
继承方式不同：抽象类属于类所以只能单继承，接口可以多继承
构造器：抽象类中可以有构造器，接口中不能有构造器
方法：抽象类中可以有非抽象方法，接口中只能有抽象方法
变量：抽象类中可以定义普通变量，接口中只能定义public static final,且要赋初值，也就是只能定义为常量。
业务：抽象类着眼于类的共性，抽取出共同特性，定义公共变量，可以减少代码冗余，接口面向行为，定义一种规范，实现类必须重写接口中的方法。
相同点：都不能直接new对象
推荐用接口，减少抽象类的使用。

4.线程池的实现原理

原理：
当用户向线程池提交一个任务(也就是线程)时，线程池会先将任务放入workQueue中。workerSet中的线程会不断的从workQueue中获取线程然后执行。当workQueue中没有任务的时候，worker就会阻塞，直到队列中有任务了就取出来继续执行。
流程：
用户通过submit提交一个任务。线程池会执行如下流程:
判断当前运行的worker数量是否超过corePoolSize,如果不超过corePoolSize。就创建一个worker直接执行该任务。—— 线程池最开始是没有worker在运行的
如果正在运行的worker数量超过或者等于corePoolSize,那么就将该任务加入到workQueue队列中去。
如果workQueue队列满了,也就是offer方法返回false的话，就检查当前运行的worker数量是否小于maximumPoolSize,如果小于就创建一个worker直接执行该任务。
如果当前运行的worker数量是否大于等于maximumPoolSize，那么就执行RejectedExecutionHandler来拒绝这个任务的提交。

5.设计模式

常见的设计模式：单例模式，抽象工厂模式，代理模式，适配器模式、装饰器模式
扩展的：建造者模式、原型模式，外观模式、桥接模式、组合模式、享元模式，策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

6.工厂模式

简单工厂：
创建一个工厂类，被这个工厂类管理的类只能由这个类去创建，缺点是，每扩展一个类，就要对工厂类进行扩展，违背了类的开闭原则

public class Phone{
		public void running(){
			System.out.println("phone is running!");
		}
}

public class Phone {
      public Phone CreatePizza(String type) {
             Phone phone = null;
             if (type.equals("iphone")) {
                    phone = new IPhone();
             } else if (type.equals("huawei")) {
                    phone = new HuaWei();
             } else if (type.equals("xiaomi")) {
                    phone = new XiaoMi();
             }
             return Phone;
      }
}

抽象工厂模式：
创建一个工厂创建类的接口，新建的工厂要实现这个接口，并重写接口中的创建类的抽象方法，需要扩展工厂类的时候，直接新建一个工厂类，让它实现这个接口即可。
接口：

public interface AbsPhone {
       Phone (String type) ;
}
工厂类：
public class PhoneFactory implements AbsPhone {
       @Override
       public Phone CreatePhone(String thpe) {
              Pizza pizza = null;
              if ("cheese".equals(ordertype)) {
                     pizza = new LDCheesePizza();
              } else if ("pepper".equals(ordertype)) {
                     pizza = new LDPepperPizza();
              }
              return pizza;
  }
}     

7.手写一个单例模式以及懒汉式和饿汉式的区别

单例模式：确保一个类最多只有一个实例，并提供一个全局访问点
饿汉式：

public class PreloadSingleton {    
       private static PreloadSingleton instance = new PreloadSingleton();
       //其他的类无法实例化单例类的对象
       private PreloadSingleton() {
       };       
       public static PreloadSingleton getInstance() {
              return instance;
       }
}

懒汉式：

public class Singleton {
       private static Singleton instance=null;
       private Singleton(){
       };
       public static Singleton getInstance()
       {
              if(instance==null)
              {
                     instance=new Singleton();
              }
              return instance;
       }
}

8.Java的数据类型

基本数据类型：
数值整型: short(2Byte),int(4Byte),long(8Byte)
浮点型：float(4Byte),double(8Byte)
字符型：char(2Byte)
字节型：byte
布尔型：boolean(1Byte)
引用数据类型：对象，String，数组

9.IO流列举，分类

按流向分可分为：输入流和输出流
按传输单位分为：字节流和字符流
输入字节流：InputStream
输出字节流：OutputStream
输入字符流：Reader
输出字符流：Writer

根据功能分为：处理流和节点流

10.字符流和字节流的区别

字符流:
Java中的字节流处理的最基本单位为单个字节，它通常用来处理二进制数据
字节流：
Java中的字符流处理的最基本的单元是Unicode码元（大小2字节），它通常用来处理文本数据。
字节流默认不使用缓冲区；字符流使用缓冲区。
字节流通常用于处理二进制数据，实际上它可以处理任意类型的数据，但它不支持直接写入或读取Unicode码元；字符流通常处理文本数据，它支持写入及读取Unicode码元。
字节流实现了InputStream或OutputStream接口
字符流实现了Reader或Writer接口
可以简单理解为：字符流=字节流+缓冲+Unicode

11.如何判断读入的文件下一行是否有数据

使用BufferReader的readLine()方法读出一条记录，再判断内容是否为空

BufferReader bfr = new BufferReader();
bfr.readLine( ).equals("");

但是使用这个方法只能判断读到的当前行否有数据，如何判断下一行是否为空行，还没找到更为简单的方法。

12.Java IO用到的设计模式

JAVA IO框架主要使用的两种设计模式 装饰模式和适配器模式
装饰模式：在由InputStream、OutputStream、Reader和Writer代表的等级结构内部，有一些流处理器可以对另一些流处理器起到装饰作用，形成新的、具有改善了的功能的流处理器。
适配器模式：在由InputStream、OutputStream、Reader和Writer代表的等级结构内部，有一些流处理器是对其他类型的流处理器的适配。这就是适配器的应用。

13.Java的序列化与反序列，如何保存序列化的对象到磁盘，以及如何把磁盘中的对象反序列化

这里要用到ObjectInputStream和ObjectOutputStream
ObjectInputStream是反序列化流，一般和ObjectOutputStream配合使用。
用ObjectOutputStream将java对象序列化然后存入文件中，然后用ObjectInputStream读取出来

14.多线程，实现线程的几种方式

1.继承thread类,重写run()方法

class MyThread extends Thread {
	@Override
	public void run() {
		for (int i = 0;i < 20;i++) {
			System.out.println("一边听歌");
		}
	}
}

测试类
public class Test {
	public static void main(String[] args) {
		MyThread myThread = new MyThread();//创建实例
		myThread.start();//启动线程
		
		for (int i = 0;i < 20;i++) {
			System.out.println("一边敲代码");
		}
	}
}

2.实现runnable接口，重写run()方法

class MyRunnable implements Runnable {
	@Override
	public void run() {
		for (int i = 0;i < 10;i++) {
			System.out.println("一边听歌");
		}
	}
}

测试类：
public class Test {
	public static void main(String[] args) {
		new Thread(new MyRunnable()).start();
		for (int i = 0;i < 10;i++) {
			System.out.println("一边敲代码");
		}
	}
}

3.实现callable接口，重写call()方法

public class MyCallable<String> implements Callable<String> {
 
	private int tickt=10;
	
	@Override
	public String call() throws Exception {
		// TODO Auto-generated method stub
		String result;
		while(tickt>0) {
			System.out.println("票还剩余："+tickt);
			tickt--;
		}
		result=(String) "票已卖光";
		return result;
	}
 
}

测试类：

	public static void main(String[] args) throws InterruptedException, ExecutionException {		
		MyCallable<String> mc=new MyCallable<String>();
		FutureTask<String> ft=new FutureTask<String>(mc);
		Thread thread = new Thread(ft);
		thread.start();
		String result=ft.get();
		System.out.println(result);
	}

15.runable接口和callable接口的异同，如何获取线程的返回值

实现Callable接口的方式，可以获取线程执行call()方法的返回值，也可以处理抛出来的异常
runnable接口不能有返回值，也不能抛出异常
获取线程返回值需要使用实现Callable接口，重写CALL()方法的方式创建线程，call()的返回值就是线程的返回值。

16.Synchronized的底层实现原理

18.对于Volalite的认识

虽然线程共享进程的资源，但是每个线程会把工作内存中的变量copy，在线程内都是对这个副本进行操作，在多线程的情况下是会发生并发问题的。这时候就需要用到Volalite去解决这个问题。
底层实现原理是内存屏障，可以修饰成员变量和静态成员变量，可以避免线程从自己的工作内存中查找变量的值，必须到主存中获取它的值，线程操作volalite变量都是直接操作内存。

19.Java多线程的锁，以及锁的异同

17. 集合有哪些，哪些是线程安全的

15. Arraylist和linklist的区别

16. Hashmap的底层，以及如何扩容

17. HashMap的链表新增元素的方式

18. Treemap和 currentHashmap

19. JVM 垃圾回收算法 标记清除法

20. Java字符串拼接

21. 异常，异常的分类，常见的异常

二、前端以及前后端交互

1.使用JS去除一个数组中的重复元素

三、数据库

1. 事务的概念，以及4大特性

2. MySQL查询执行缓慢，效率低的sql

使用（explain关键字）

3. DB2修改表之后要进行的操作

4. group by之后再进行筛选时用到的关键字

having

5. JDBC的流程

1.加载驱动

Class.forName("com.mysql.jdbc.Driver")

2.创建连接

String url = "jdbc:mysql://localhost:3306/mysql";
String user = "root";
String password = "password";
Connection conn = DriverManager.getConnection(url,user,password)

3.执行sql
a.使用Statement接口

Statement state = conn.createStatement();
String sql = "";
ResultSet rs = state.executeUpdate(sql);

b.使用PreparedStatement接口

String sql = "";
PrepareStatement ps = conn.prepareStatement(sql);
ps.set(i,value);//给SQL语句中第i位占位符赋值value。
ps.executeUpdate();	

4.处理结果集

ResultSet rs = state.execute(sql);
rs.getString(String columnName);//   获取指定字段值    
rs.setString(String columnNmae,String s);// 更新指定字段的值  

5.关闭连接和结果集

conn.close();
rs.close();

6.删除表数据的方式

1.delete（DML），只清空表中记录，且可根据条件部分删除，不更改表的结构
2.truncat （DML），清空表中数据并且删掉表结构
3.drop（DCL），删掉表，不管表中是否有数据，是在物理内存的角度删掉这个表，会把这张表从数据库中清除掉。

7.MySQL的存储引擎，常用的存储引擎的区别以及各自的优点

常见的存储引擎有innoDB和Myisam
innoDB 支持事务，数据和索引分开存放
Myisam 不支持事务，数据和索引放在同一个地方，会维护一个count，所以查询表中记录的总条数会很快。

8.数据库优化

1.分库：实现读写分离，读操作在从库，写操作在主库（主库每隔一段时间会自动更新从库）
2.分表：垂直分表和水平分表
垂直分表：拆分表的列，根据业务逻辑，把业务相关的字段形成一张新表
水平分表：拆分表的行，根据数据的特性，把不同数据分在不同的表中
3.sql优化（常用）:
a.避免使用select ，使用select+具体的字段去替代它，使用select count(1)代替select（）
b.对于表中执行查询次数远远多于增删改的表中数据几乎不重复的字段，建立索引，对于有大量重复数据的字段则不推荐使用索引。
c.where筛选条件后面的多个条件，要根据能筛掉数据的数量由多到少排列
d.对于索引字段的筛选条件，尽量减少模糊查询，如果对于索引字段进行模糊查询，就会不适用索引而进行全表扫描。
e.

9.MySQL的索引，以及索引底层数据结构

底层数据结构：B+树，底层是二分查找算法
索引记录全存储在叶子节点上

10.对索引列执行模糊查询会放弃索引，那如何既使用模糊查询，又用索引

11.组合索引ABC的问题

12.了解的主键生成策略

1.自增
2.序列
3.uuid
4.雪花算法

13.select count（*）用到了索引吗,它是如何实现计数的

14.外连接用到了什么算法，是哪个表与哪个表相比

四、spring

1. Spring分为几个模块

AOP
SpringJDBC
core
context

2. AOP

切点
切面
通知
实现原理

3. AOP的异常通知

4. spring的传播级别和事务的隔离级别

1.事务的隔离级别是两个事务操作临界资源时需要进行管理的
spring的隔离级别有五种
a.默认->与数据库当前的隔离界别保持一致
b.读为提交（read uncommitted）会有脏读
c.读已提交（read committed）
d.可重复读
e.串行化
事务的传播级别是对于新加线程是否要创建事务而定的标准

5. Spring bean的生命周期

6.Spring bean是的线程安全问题

7.SpringBoot优于Spring的地方

8.Spring的循环依赖问题，以及创建顺序

五、SSM

1.SpringMVC的实现流程

2.Mybatis

#{} 和${} 的区别
#{}先预编译SQL，再把参数直接作为字符串，拼接到sql中，能避免SQL注入
${}把参数拼进SQL，再去编译SQL，会出现SQL注入问题，所以尽量用#{}.

3.SpringMVC常用注解

六、Springboot

1.Springboot相关知识，springboot比起spring的优点，

2. Data JPA 实现动态sql

3.SpringBoot的自动装配原理

4.SpringBoot的常用注解

@SpringBootApplication

5.mybatis和hibernate的区别

6.JPA的实现原理

七、Linux

1.Linux常用命令

文本编辑：Vi,Vim
文件操作：mkdir（增）rm（删）cat（查看）
解压 unzip
压缩 tart

2.Linux日志追踪命令

1.如何查看日志最新的两百条记录
2.tail命令如何使用，如何显示文件的末尾两百行

八、SVN，Git和MAVEN

1.Git

九、算法与数据结构

1.数据结构

1）了解哪些树

2）红黑树以及红黑树的原理的优势

3）B树和B+树的异同

4）使用Java实现一个图

5.）使用Java实现链表的头插法

2.算法

1）使用Java实现一个二分查找的算法

public int search (int[] nums, int target) {
        int index = -1;
        int low = 0, high = nums.length-1;
        while (low <= high) {
            int mid = low + (high-low) / 2;
            if (nums[mid] == target) {
                // 在low 到 mid之间找第一个下标
                index = mid;
                high = mid-1;
            } else if (target > nums[mid]) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return index;
    }

2）求1-20的阶乘和

3）快排，以及它的时间复杂度