JavaSE基础-面试提问

1.1重载与重写（了解）

重载：发生在同一个类，方法名必须相同，发生在编译时。
重写：发生在父子类中，方法名、参数列表必须相同。如果父类被private修饰，则子类不能重写该方法。

1.2String、StringBuffer、StringBuilder（必会）

String：String类中使用final关键字字符数组保存字符串，所以String对象不可变
StringBuffer、StringBuilder：没有final关键字修饰，所以这两种对象可变

操作少量数据用String（对象不可变，理解为常量，线程安全）
单线程操作大量数据用StringBuilder（builder工人）（未加同步锁，线程不安全）
多线程操作大量数据用StringBuffer（buffer缓冲区）（加了同步锁，线程安全）

1.3装箱与拆箱（了解）就好比int（拆箱）和integer（装箱）

装箱：将基本类型包装起来
拆箱：将包装类型转换为基本类型

1.4==与equals（必会）

== 是判断两个对象的地址是不是相等（基本类型是比较值，引用类型则比较内容）
equals()方法
一、类没覆盖该方法，则和==一样比较对象
二、类覆盖了该方法，则比较的是对象里的内容

1.5final关键字主要用在三个地方：变量、方法、类（必会）

final修饰变量：如果是基本类型变量，数值初始化后便不能修改；如果是引用类型变量，则对其初始化之后便不能指向另一对象。
final修饰类：表明这个类不能被继承
final修饰方法：把方法锁定，防止继承类修改它的含义；效率

1.6异常处理（了解）

所有的异常都有共同的祖先java.lang包中的throwable类，这个类有两个重要子类exception（异常）和error（错误）

1.7error和exception的区别（了解）

Error类一般值与虚拟机有关的问题，如系统崩溃、虚拟机错误、内存空间不足、方法调用栈溢出等。对于这类错误导致程序中断，应该要程序终止
Exception类可处理异常，尽可能处理异常，而不是随意终止异常

1.8接口和抽象类的区别（必会）

1、你有一些方法想要默认的实现，就用抽象类
2、你想要多重继承，但是子类不能够继承多个类，你就可以使用接口，实现多个接口来解决

1.9什么是单例模式模式？

单例模式：某个类的实例在多线程的环境下只会被创建一次出来。
单例模式：饿汉式、懒汉式、双检锁 单例模式

饿汉式：线程安全，一开始就初始化
懒汉式：线程不安全，延迟初始化
双检锁：线程安全，延迟初始化

1.10手写冒泡排序（必会）

1、输入10个数scanner input = new scanner（system.in）
2、定义列表int sort[] = new int[10]
3、循环接收10个数放进列表sort[i] = input.nextInt();
4、两个for循环，第n个数和第n+1个数比较，小放左边。最坏的情况，最小的
数在右边，知道把右边的数移到左边来，最后打印输出即可。

1.11BIO、NIO、AIO有什么区别？（了解）

BIO：block io 同步阻塞式io，特点：模式简单使用方便，并发处理能力低
NIO：new io 同步非阻塞io，特点：实现多路复用
AIO：asynchronous io 异步非阻塞io 基于事件和回调机制

1.12六种数据结构（了解）

1、数组：长度固定、可用下标索引、元素类型一致
2、列表：可包含重复元素、自动调整大小
3、集合：不可有重复元素
4、堆栈：只允许对最后插入的元素进行操作（后进先出）
5、队列：第一个插入的元素也是第一个被删除的元素（先进先出）例如：排队等待公交车、银行、超市里的等待队列
6、链表：每个节点含有数据并指向下一个节点（增、删容易，只需要改变指针指向即可；查、改较难）

1.13Java集合体系有什么？（必会）

1.14List的三个子类特点（必会）

ArrayList底层结构是数组，底层查询快，增删慢
LinkedList底层结构是链表型，增删快，查询慢
Vector底层结构是数组 线程安全，增删慢，查询也慢，垃圾

1.15List和map、set区别（必会）

结构特点：
List和Set都是单列数据的集合
Map是存储kv结构（键和值）的双列数据集合

List存储的数据有序，并且允许重复
Map存储的数据无序，k不允许重复
Set存储的数据无序，并且不允许重复

1.16HashMap底层原理（必会）

Jdk1.8之前，数组+链表
Jdk1.8之后，数组+链表+红黑树（链表长度超过8）
链表的键%数组的长度=数组的下标
如果28%12=4，16%12=4，即是：链表的键28、16在长度为12的数组的4下标

红黑树：根节点必黑、新增为红色，允许黑连黑、不允许红连红
然后就是根据这个特性进行变色、左右旋转得到最终平衡即可！！！
把某个数左旋，这个数的左叶节点脱离，插入至这个数的父节点

1.17HashMap、HashTable、ConcurrentHashMap有什么区别（必会）

HashMap不加锁，所以线程不安全，是一个接口，是map的一个子接口，不允许键重复，允许
空键空值，效率高，适用单线程。

ConcurrentHashMap一次锁住一个桶，默认将hash表分为16个桶，get、put、
remove操作只锁住当前需要的桶，这样能进来16条线程执行，并发性能显著提升

HashTable线程安全的一个集合，锁机制：一次锁整个hash表，不允许null键和值，适用多线程。但是这个是遗
留物，内部很多没优化和冗余，垃圾，不用。

1.18什么是线程？线程和进程的区别（必会）

线程：是进程的一个实体，是cpu调度和分派的基本单位
进程：操作系统进行资源分配和调度的一个独立单位

1.19创建线程有几种方式（必会）

1、继承thread类

public class MyClass extends Thread{
	public void run(){
		System.out.println(“我的线程正在运行”)
	}
}
MyClass tt = new MyClass();
tt.start();

2、实现Runnable接口
如果自己的类继承了另一个类，无法继承Thread，此时可实现一个Runnable接口

public class MyClass extends OtherClass implements Runnable{
	public void run(){
		System.out.println(“我的线程正在运行”);
	}
}
MyClass myClass = new MyClass();
Thread thread = new Thread(myClass);   //new一个线程对象，把我的类放进去
thread.start();

3、实现Callable接口
有返回值，可以声明抛出异常类
具体代码实现：

Public class ThirdClass implements Callable<Integer>{
//重写 call()方法
//定义实现 Callable接口的实现类，并实现 call()方法。注意：Callable有泛型限制，与返回值类型一致。这里是 Integer
}
ThirdClass tt=new ThirdClass(); //再创建 Callable实现类的实例 tt
FutureTask<Integer> task = new FutureTask<Integer>(tt);//使用 FutureTask类包装 Callable的实例 tt
//注意：泛型限制与返回结果一致。 
new Thread(task,"线程").start();   //以 FutureTask对象（task）作为 Thread的 target来创建线程，并启动。
Integer result=task.get();//会有异常。调用 FutureTask对象（task）的 get()方法获得返回值

4、通过线程池方法
线程池就是事先将多个线程对象放到一个容器里，当使用的时候就不用new线程，而是直接去池中拿线程即可。在 JDK的java.util.concurrent.Executors中提供了生成多种线程池的静态方法。

ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4);
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPooL(4);

常用的线程池有哪些？
newSingleThreadExecutor：单线程的线程池，保证所有任务执行顺序按照任务的提交顺序执行
newFixedThreadPool：固定大小的线程池，每次提交任务就创建一个线程，直至达到线程池的最大数
newCachedThreadPool：可缓存的线程池，线程池大小完全依赖jvm能够创建最大线程数
newScheduledThreaPool：无限大的线程池，定时以及周期性执行任务的需求

1.20线程的基本方法有哪些？（必会）

1、线程等待（wait）：会释放锁，其他线程可拿，一般用在同步方法中
2、线程睡眠（sleep）：不会释放锁，此线程一直占用
3、线程让步（yield）：让出cpu执行时间片，再重新竞争，看哪条线程优先级高
4、线程中断（interrupt）：通知信号，只影响线程内部，不改变状态如阻塞、终止
5、线程唤醒（notify）：唤醒等待的单个线程，直到当前线程释放此对象的锁，才继续执行被唤醒的线程
6、等待其他线程终止（join）：当前线程转为阻塞，当另一线程结束，当前线程才变为就绪状态，等待cpu的宠幸

1.21wait和sleep的区别？（必会）

public class sleepAndWait {

	public static class MultiThread {
		 
		
		private static class Thread1 implements Runnable{		
			public void run() {
				
				synchronized(MultiThread.class){
					System.out.println("进入第1条线程 ...");
					System.out.println("第1条线程进入等待状态，释放锁。。。");
					
					try{
						
						MultiThread.class.wait();
					}catch(InterruptedException e){
						e.printStackTrace();
					}
					
					System.out.println("第1条线程 is going on ...");
					System.out.println("第1条线程 is being over!");
				}
			}
			
		}
		
		private static class Thread2 implements Runnable{
			public void run() {	
				
				synchronized(MultiThread.class){
					System.out.println("进入第2条线程 ...");
					System.out.println("第2条线程  notify唤醒 第1条线程 的等待状态 ...");
					MultiThread.class.notify();
					System.out.println("第2条线程睡眠10秒...");
					
					try{
						Thread.sleep(10000);
					}catch(InterruptedException e){
						e.printStackTrace();
					}
					
					System.out.println("第2条线程 is going on ...");
					System.out.println("第2条线程 is being over!");
				}
			}		
		}
		
		public static void main(String[] args) {
			new Thread(new Thread1()).start();
			
			new Thread(new Thread2()).start();
		}
	 
	}
}

打印结果：

进入第1条线程 …
第1条线程进入等待状态，释放锁。。。

进入第2条线程 …
第2条线程 notify唤醒 第1条线程 的等待状态 …
第2条线程睡眠10秒…
第2条线程 is going on …
第2条线程 is being over!

第1条线程 is going on …
第1条线程 is being over!