牛客网刷题和面试的一些笔记
1.基本类型双等号和引用类型双等号有什么区别？那引用类型要判断内容是否相等应该怎么办？
基本类型双等号是判断两个值是否相等
Int a = 123, int b = 123; a == b 为true
引用类型双等号是判断两个对象在堆的内存地址是否相同
Int a = 123.int b = 123;
Public void bijiao(int a,int b) a==b 为true
如果引用类型需要判断内容是否相等，应该使用equals方法;
2.请你说一下java中的final关键字？
Final关键字用于修饰变量、方法、类，不能修饰关键词
被final修饰的变量，不可以被重新赋值
被final修饰的类不可被继承
被final修饰的方法不能被重写
3.做字符串拼接的时候可以用String吗？StringBuilder和StringBuffer有什么区别呢？
不建议使用String来进行拼接，因为耗时，并且实际上是每次new一个StringBuilder来进行append拼接。
StringBuilder属于线程不安全，但是效率高
StringBuffer属于线程安全，但是效率低，内部使用synchronized 进行同步
4.常用的List集合有哪些呢？有什么区别？
常用的List集合有ArrayList、LinkedList、Vector。
ArrayList底层是数组，它查询速度快，增删速度慢，因为是遍历方式进行查找数据，非线程安全，
LinkedList底层是链表，它查询速度慢，增删速度快，因为是双向循环链表，并且使用双指针，非线程安全
Vector底层是数组，是线程安全的
5.Map中的computeIfAbsent和computeIfPresent有什么区别？
https://www.jianshu.com/p/059d6e908807
ComputeifAbsent()是对Map中的值进行重新赋值，如果Map中的键对应的值为null，那么这次赋于键的值失败；如果键和赋值都不为空，那么相当于新加入map中。
ComputeifPresent()是对Map中的键值进行重新赋值，如果赋予的键值为空，那么键和键值都为null，如果不为空则替换。
这就是Hashmap能为空值的原因
6.throw和throws有什么区别？
throw实例化一个异常对象
throws表示此方法不处理异常，而交给建一个管道抛出去，交给调用方法处处理，调用的方法必须try...catch或者也抛出去
7.线程有几种创建方式？分别是怎么样的？
·四种方式创建多线程
·继承thread
·实现runnable接口
·实现Callable接口
·通过线程池
8.Thread、Runable的区别
Thread和Runnable实质都是继承关系。无论哪种方式，都会new Thread，然后run。
如果线程复杂选择继承Thread，如果线程简单就一个任务，那就是用Runnable
9.并发、并行、串行的区别
串行是在一个时间上，一个任务等待另一个任务完成
并行是时间重叠内，两个任务同一时刻互不干扰的同时执行
并发允许个个任务彼此干扰，统一时间点，只有一个任务运行，交替执行
10.Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？Math.ceil（10.01）等于多少？Math.floor(10.01)等于多少？
Math.round四舍五入，分别是12和-11
Math.ceil向上取整，为11
Math.floor向下取整，为10
11.java 中 IO 流分为几种?
按照流的流向分，可以分为输入和输出流
如果按照单元划分，可以划分为字节流和字符流；
如果按角色划分，可以划分为节点流和处理流；
节点流：可以从或向一个特定的地方(节点读写数据)
处理流：是对一个已存在的流的链接和封装，通过所封装的流的功能调用实现数据读写。
InputStream/Reader：所有输入流的基类，前者是字节输入流，后者是字符输入流。
OutputStream/Writer：所有输出流的基类，前者是字节输出流，后者是字符输出流。
12.JDK和JRE和JVM是什么？
JDK是java的开发工具
JRE是java运行时的环境
在JRE文件下种的bin目录里面就是JVM虚拟机，lib时java的一些类库
13.说下你对== 和 equals 的认识，它们有什么差别？
双等号比较运算符，equals是方法
在基本类型中，比如比较int，双等号比较的是值是否相同，基本类型没有equals比较
在引用类型中，比如比较对象和String，双等号比较的是地址是否相同，equals比较的是值是否相同
如果没有重写equals那么调用的是object的方法，比较的是地址
14.String 是基本数据类型吗？
不是基础类型，是对象只有八种基础类型
分别是：byte(8)，boolean(1)，short(16)，char(16)，int(32)，float(32)，double(64)，long(64)
String s = “abc”；这是常量，放常量池
String因为不可变的特性，所以是线程安全
15.String str="abc"与 String str=new String("abc")的定义方法一样吗？
不一样，String str = “abc”是把abc放入常量池
String str = new String（“abc”）是创建一个对象，会被分配到堆内存中，创建过多会有内存碎片
16.如何将字符串反转？
使用StringBuilder和StringBuffer的reverse（）方法
17.String 类的常用方法都有那些？
·replace（）字符串替换
·trim（）去除两端空白
·split（）分割字符串
·substring（）截取字符串
18.一般的类和抽象类有哪些区别？
·抽象类不能实例化；可以有抽象方法，只需要声明，不需要实现；抽象的子类必须实现抽象方法，不然也是抽象类；
·含有抽象方法的类必须申明为抽象类，抽象类可以没有抽象方法
19.抽象类能使用 final 修饰吗？
不能，因为抽象类需要被继承，如果有final修饰，就表明不能被继承
·final修饰的方法不能重写,但是能被重载
20.接口和抽象类有什么区别？
·抽象类的子类需要extends来继承，而实现接口要用implements
·抽象类可以构造函数，而接口不能
·抽象类可以定义main方法，而接口不能
·抽象子类只能继承一个父类，抽象父类能被多继承，接口能被多个类实现
21.Files的常用方法都有哪些？
·Files.exists（）检测路径是否存在
22.JDBC的步骤？
·配置
public static final String URL = “jdbc://mysql://localhost:3306/xxx”;
public static final String USER = “xxx”;
public static final String PASSWORD = “xxxx”;
·加载驱动程序
Class.forName(“com.mysql.jdbc,Driver”);
·获得数据库链接
Connection conn = DriverManager.getConnection(URL,USER,PASSWORD);
·操作数据库,实现增删改查
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(“select xx from xx”);
·如果有数据，rs.next()返回true
While(re.next){
System.out.println(rs.getString(“xxx”)+”xxx”+rs.getInt(“xxx”));
}
23.什么是Spring IoC？
·也叫控制反转，减少new对象次数，并且降低代码的耦合性，是一种面向对象的方法。
·通过DI依赖注入的方式实现，不需要知道过程，只需要得到结果。
·AOP是一种面向切面的方法
24.面向对象的特征有哪些方面？
·抽象：抽象是将一种对象的共同特征总结出来构造的过程，包括数据抽象（属性）和行为抽象（方法）两方面。抽象只关注对象有那些属性和行为，并不关注这些行为的细节是什么
·继承：是从已有的类（父类也叫超类基类）得到继承信息创建新的类（子类也叫派生类）过程。
·封装：把数据和操作数据的方法绑定起来（对象的get/set方法），堆数据的访问只能通过已定义的接口。
·多态：指允许不同子类对象对于同一消息做出不同的响应（重写/重载）。重载实现的是编译时的多态性，重写实现的时运行时的多态性。
25.访问修饰符public,private,protected,以及不写（默认）时的区别？
Public Protected Default Private
本类 √ √ √ √
同包 √ √ √ ×
子类 √ √ × ×
其他包 √ × × ×
类的成员不写访问修饰时默认为default。
26.float f=3.4;是否正确？
不正确，因为小数默认是double类型，属于双精度，而float数据单精度，双精度转换单精度也叫向下转型（窄化），造成精度损失，编译器会报错。
·两种解决办法：
float f = （float）3.14
float f = 3.14f
27.short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？
·第一个运算有错误，因为s1+1，1为int类型，s1为short，不能编译，正确应为s1 = （short）（s1+1）
·第二个运算没有错误，因为s1+=1相当于s1 = （short）（s1+1），含有强制类型转换
28.Java关键字
·
·2个保留字：goto。Const
·3个特殊直接量：true，false，null
29.int和Integer有什么区别？
·Int是基本类型而integer是包装类，这是为了能够将这些基本类型当作对象来操作
·基本类型的包装类具有自动装箱/拆箱机制，使得二者可以相互转换
·原始类型byte,short,int,char,boolean,float,long,double
·包装类型Byte，Short，Integer，Character，Boolean，Float，Long，Double
class AutoUnboxingTest {
public static void main(String[] args) {
Integer a = new Integer(3);
Integer b = 3; // 将3自动装箱成Integer类型
int c = 3;
System.out.println(a == b); // false 因为包装类数据对象，两个引用没有引用同一对象
System.out.println(a == c); // true a自动拆箱成int类型再和c比较
}
}
==================================================
public class Test03 {
public static void main(String[] args) {
Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
System.out.println(f1 == f2); //true，因为自动装箱如果范围在-128~127之间那么不会new新的integer对象，而是直接应用常量池中的对象
System.out.println(f3 == f4); //false，值的范围超出整形范围，所以需要new新的对象
}
}
30.&和&&的区别？
·&有两种作用：按位与和逻辑与
·&&一种作用：逻辑运算符（也叫短路运算符）
按位与：把左右两边数据转换为2进制，只有两个数据相同的位都为1结果的2进制位才是1
逻辑与：当左右两边都有式子，左边的式子不成立，也会去计算右边的式子
短路运算符：当左右两边都有式子，左边的式子不成立是不会去计算右边式子
31.解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法。
·基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用JVM的栈空间
·通过new关键字和构造器创建的对象和数组则放在堆空间
·方法区是线程共享的内存取余，用于存储被虚拟机加载的类信息、常量、静态变量、即编译器编译后的代码等数据
32.父类与子类初始化顺序（代码）
public class Base{
private String baseName = "base";
public Base(){
callName();
}
public void callName(){
System. out. println(baseName);
}
static class Sub extends Base{
private String baseName = "sub";
public void callName(){
System. out. println (baseName) ;
}
}
public static void main(String[] args){
Base b = new Sub();
}
}
·执行Base b = new Sub();时由于多态b编译时表现位Base类特性，运行时表现为Sub类特性
·Base b = new Sub();不管哪种状态都会调用Base构造器执行callName()方法
·执行方法时，由于多态表现为子类特性，所以会先再子类知否右callName();
·而此时子类尚未初始化(执行完父类构造器后才会开始执行子类)，如果有就执行，没有再去父类寻找
33.对Collection和Collections描述正确的是
·java.util.Collection集合接口，提供了对集合对象进行基本操作的通用接口方法。
·java.util.Collections包装类，包含各种有关集合操作的静态方法
34.Java中基本的编程单元为？
·java的基本变成单元是类，没有类就没有函数
·基本存储单元是变量
35.Java创建对象的方式有几种？
五种方式
·通过new关键字:ObjectName obj = new ObjectName();
·通过反射的Class类的newlnstance()方法：ObjectName obj = ObjectName.class.newInstance();
·使用反射的Constructor类的newInstance()方法： ObjectName obj = ObjectName.class.getConstructor.newInstance();
·使用对象克隆clone()方法： ObjectName obj = obj.clone();
·使用反序列化（ObjectInputStream）的readObject()方法： try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }
36.JAVA 异常类的描述？
·异常都是Throwable的子类
·Exception（异常）：是程序本身可以处理的异常
·Error（错误）：程序无法处理的错误，发生在虚拟机。
·非运行异常：也就是能被编译器检查出来的错误，必须要try-catch捕获和throws抛出除了RuntimeException和Error其它都是检查异常
·运行时异常，（RuntimeException与其子类）和错误（Error），也就是运行了才能出现的异常
37.接口java.util.Collection常用方法？
·size()：返回集合中元素的个数
·add()：向集合中添加一个元素
·addAll(Colletion coll)：将形参coll包含的所有元素添加到当前集合中
·isEmpty()：判断这个集合是否为空
·clear()：清空集合元素
·constainAll(Collection coll)：判断当前集合与coll的所有元素
·remove(Collection coll)：从当前集合中删除包含coll集合的元素
·iterator()：返回一个iterator接口实现类的对象，遍历集合
38.ArrayList和Vector主要区别是什么？
两者的底层都是数组实现
不同的是Vector支持线程的同步，也就是内部加锁，成倍增长容量
ArrayList不支持线程同步，原来的一般增长容量
39.在Java中，以下数据类型中,需要内存最多的是？
·Long类型，64位
·Object是引用的数据类型，只申明而不创建实例，只会再栈内存中开辟空间，默认为空，空占1bit
40.Object类中的方法有那些？
·hashCode()：用于获取对象的哈希值
·equals(Object obj)：用于确认两个对象是否相同
·clone()：创建并返回此对象的一个副本
·toString()：返回该对象的字符串表示
·notify()：唤醒再此对象监视器上等待的单个线程
·waut()：用于让当前线程失去操作权限，当前线程静茹等待序列
·finalize()：当垃圾回收期确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法
41.Java语言中，创建二位数组格式要注意什么？
一维长度必须定义，二维可以后续定义，也就是行必须定义不能为空
float f[][] = new float[][6] 这是错的格式
42.父类不能执行子类方法（代码）
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
public void bark(){
System.out.println("狗可以吠叫");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal();
Animal b = new Dog();
a.move();
b.move();
b.bark();
}
}
·编译看左边，运行看右边，也就是编译的时候会把它当成左边的类型，运行的时候看右边类型的方法体。也就是调用了Animal.bark，但是父类并不存在，所以编译错。
·父类型引用指向子类型对象，无法调用只在子类型里定义的方法
43.重写和重载的区别是什么？
·重载：同名不同参，调用相同的方法，方法的内容也一致，但是参数传入的值不同。父类操作，与返回值无关
·重写：同名同参，但是方法执行的内容不同。子类操作
44.两个对象调用同一个地址（代码）
class Two{
Byte x;
}
class PassO{
public static void main(String[] args){
PassO p=new PassO();
p.start();
}
void start(){
Two t=new Two();
System.out.print(t.x+””);
Two t2=fix(t);
System.out.print(t.x+” ” +t2.x);
}
Two fix(Two tt){
tt.x=42;
return tt;
}
}
·Byte是byte的包装类型，所以默认为空的时候为null，不是0
·t是一个引用类型的地址，在调用fit（Two tt）函数是，是一个实参到形参的传值，也就是把t的地址赋值给了tt，但是都指向的是堆内存Byte x，因此当对tt.x和t.x指向是相同的。因此t.x也是42
·Two t2=fix(t)的时候把t的地址引用到t2，所以t2也是42
45.Finally的特性（代码）
public class Demo {
public static String sRet = "";
public static void func(int i){
try{
if (i%2==0){
throw new Exception();
}
}
catch (Exception e){
sRet += "0";
return;
}
finally{
sRet += "1";
}
sRet += "2";
}
public static void main(String[] args){
func(1);
func(2);
System.out.println(sRet);
}
}
·func(1)会执行得到结果字符“12”
·func(2)执行有异常，会被捕获，sRet=”120”，之后return，但是不管结果如何，都会被执行finally即sRet=”1201”
46.Java程序初始化顺序(代码)
class A {
public A() {
System.out.println("class A");
}
{ System.out.println("I'm A class"); }
static { System.out.println("class A static"); }
}
public class B extends A {
public B() {
System.out.println("class B");
}
{ System.out.println("I'm B class"); }
static { System.out.println("class B static"); }
public static void main(String[] args) {
new B();
}
}
·父类的静态代码块
·子类的静态代码块
·父类的普通代码块
·父类的构造方法
·子类的构造方法
·子类的普通代码块
·构造方法的意思是创建对象的时候被调用
47.多线程对int型变量x的操作，哪个不需要进行同步？（选择题）
x=y;
x++;
++x;
x=1;
·因为y的值不确定，所以我们要加锁
·x++和++x由于x是优先被读入寄存器的，再进行+1的操作，如果没有加锁，可能出现数据异常
·x=1是原子性操作，也就是不能再划分为更小的操作
Java中原子性操作有：
除long和double之外基本类型的赋值
所有引用reference的赋值操作
Java.concurrent.Atomic.*包类的所有操作
48.String与StringBuffer的区别是？
·String对象不可变，一旦创建不能修改它的值，对于已经存在修改String对象的修改都是new一个StringBuilder来进行append拼接
·StringBuffer/StringBuilder为可变对象，都是继承AbstractStringBuilder类
·String是常量，是线程安全
·String，StringBuilder，StringBuffer都有final修饰，三者都是不可变，不可变指的是引用不可变（也就是地址不变，内容可以变）
49.call by value和call by reference的区别
·call by value 是值传递，是将变量的一个副本传递到方法中，方法中如何操作该变量的副本，都不会改变原变量的值
public static void test(int a,int b) { //传递变量的副本，不会改变原变量的实际值
a = a + b;
}
public static void main(String[] args) {
int a = 1, b = 2;
test(a, b);
System.out.println("a=" + a + ",b="+b);
}
·call by reference是引用传递，是将变量的内存地址传递给方法，方法操作变量时会找到保存在该地址的变量，对其进行操作，会对原变量造成影响
public static void test(StringBuffer str) { //把”hello”的引用地址传进来
str.append(" World");
}
public static void main(String[] args) {
StringBuffer string = new StringBuffer("hello");
test(string);
System.out.println(string); //改变了原String对象的值
}
50.抽象类和接口的特点
抽象类（某种事物的共有属性和方法，可以归为概念类：动物中的猫狗）：
·抽象类可以构造方法
·抽象类可以存在普通属性，方法，静态属性和静态方法。
·有抽象方法的必定是抽象类，抽象类可以存在抽象方法，但不必须
·抽象类中的抽象方法，需要子类实现，如果子类不实现也是抽象类
·抽象类不能被实例化，抽象类和抽象方法必须被abstract修饰
接口（抽象方法和常量的集合，可以归特特征会飞的：超人蜻蜓飞机）：
·在接口中只有方法的声明，没有方法体，并且都是抽象方法
·接口中只有常量，因为定义的变量在编译都会被默认加上public static final
·在接口中的方法都可以被public修饰
·接口中没有构造方法，也不能实例化接口对象（所以接口不能继承类）
·接口可以实现多继承
51.SQL语言中删除一个表的指令
·dorp table：完全删除表，包括表结构
·delete from table：删除表里面数据，保留表结构，但可以加where删除一行或多行
·truncate table：只能删除表数据，会保留表结构，不能加where，数据不可恢复
52.收回用户创建表的权限
revoke create table from xx：收回权限
with grant option ：表示这个用户可以权限传递。
53.类方法和实例方法区别
·类方法是static修饰的方法，是类的方法，通常调用是类名.方法名
·实例方法是普通的方法，是对象的方法，需要通过对象调用对象名.方法名
54.Hashtable 和 HashMap 的区别是
Hashtable：
是一个散列表，它存储的内容是键值对(key-value)映射
函数都是同步的，是线程安全，它的key、value都不可以为null
直接使用对象的hashCode
HashMap
由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主题，链表则是为了解决哈希冲突而存在的
不是线程安全，HashMap可以接受为null的键值
HashMap重写计算hash值
55.HashCode和equals如何使用
·首先一个hashmap的初始长度是16
·通过key的值来进行hashcode得到存放在数组表的index下标
·将key和value来进行entiy封装放入index
·如果是空位置则直接放入，如果同一个下标有数据，则要equals比较key值
Key值比较相同则覆盖原本数据
Key值比较不相同则链表进行链接
·两者搭配使用构成hashmap的使用
·需要使用equals比较是因为两个对象的相等，则他们必须有相同的hashcode，如果两个对象有相同的hashcode，但他们未必相等
56.怎么声明一个类不会被继承，什么场景下用
·被final修饰的类不能够被继承，一个类中的方法没有重写的必要，就可以使用
·典型的Math（数学类，计算使用），里面的方法都是类方法，直接Math.max调用
57.自定义异常怎么理解
·虽然自定义但是也需要继承java的异常
·符合java语法，但业务逻辑不符合
·分层结构中，统一在表现出捕获处理
58.Spring、SpringMVC、Springboot的区别是什么？
·spring是一个全栈的开发框架，核心时控制反转IOC和面向切面AOP
·springmvc是spring基础之上的M（model）V（view）C（contorller）框架，主要处理web开发的路径映射和视图渲染、文件配置、后台接口逻辑开发，也是基于servlet核心部件是前端控制器（DS）
·springboot更专注与开发微服务后台接口，不注重开发前端，默认优于配置，简化了插件配置流程，不需要配置xml，简化了配置流程
59.SpringMVC的工作流程
·用户发起请求给服务器，被前端控制器拦截
·前端控制器向路径处理映射器进行请求查询
·路径映射器返回执行链给前端控制器
·前端控制器根据执行链发送请求给处理器（contorller）
·处理器返回数据给modelandview容器进行装载
·处理器返回modelandview容器给前端控制器
·前端控制器发送数据给view解析器进行解析
·返回一个view对象到模板中进行填充渲染
·最后返回给前端进行显示
60.SpringMVC的九大组件
·处理映射器（告诉你找谁）
·处理适配器（干活的工人）
·处理异常器（治安入员）
·视图解析器（把String对象转换为View类型）
·请求视图名称跟踪器（定义controller中没有定义返回类型）
·语言解析器（区域划分展示）
·主题解析器（更换风格）
·上传解析器（文件转换IO流）
·闪存地图管理器（重定向）
61.Spring的核心是什么？
·spring是一个开源框架，spring也是一个生态，是所有spring框架的基石
·spring是为了简化企业开发而生，使得开发变得优雅和简洁
·spring是一个IOC和AOP容器框架
IOC：控制反转（思想，具体实现是DI容器注入）
AOP：面向切面编程（日志，事务配置，把关键核心代码嵌入到业务逻辑中）
容器：包含并管理应用对象的生命周期，spring就是桶，对象就是水
62.DBMS（关系型数据库）的四个特性是什么？
·原子性：一个事物对数据库的所有操作，是一个不可分割的工作单元，这些操作要么全部执行，要么什么也不做（由事务管理子系统来实现）
·隔离性：一个事物独立执行的结果，事务完成时，要使用所有的数据都保持一致的状态（完整性子系统实现）
·一致性：事务应该在另一个事务对数据的修改前或修改后进行访问（并发控制子系统实现）
·持久性：保证事务对数据库的修改是持久有效的，即使发生系统故障也不丢失（恢复管理子系统实现）
63.子类在什么时候用super，this又是什么意思
·子类构造函数调用父类构造函数用super
·子类重写父类方法后，若想调用父类中被重写的方法用super
·子类调用未被重写的方法可以直接调用
·this可以调用方法、属性、利用this表示当前对象、调用本身构造方法
·super可以调用父类属性或方法（同名时）、利用super表示父类、调用父类构造方法
64.Sql中内链接、左连接、右链接区别
·内连接：查询两个表通过某一属性的交集
·左连接（也叫左外链接）：左表的记录会全部表示出来，而右表只会显示符合搜索条件的记录，记录不足的地方均为null
·右链接（也叫右外链接）：游标的记录会全部表示出来，而坐标只会显示符合搜索条件的记录，记录不足的地方均为null
65.Sql中order by和group by的区别
·order by用来对一属性数据进行排序，desc是降序，des是升序
·group by用来对一属性数据进行分组使用聚合函数
·常见的聚合函数：sum求和、max最大值、min最小值、avg平均值、first第一条记录、last最后一条记录、count统计记录数
- 排他锁和共享锁以及封锁协议
共享锁(S)：共享用于不更改或不更新数据的操作（只读），如select
如果事务T对数据A加上共享锁后，则其它事务只能对A再加共享锁，不能加排他锁。获准共享锁的事务只能读数据，不能修改数据。
排他锁(X)：用于修改操作，如insert、update、delete。确保不会同时对同一资源进行多重修改
事务T对数据A加上排他锁后，则其它事务不能再对A加任何类型的封锁。获准排他锁的事务既能读数据，又能修改数据。
扩展阶段：在对任何数据项读写之前，都要申请获得数据项的封锁
收缩阶段：每个事务中，所有的封锁请求必须先于解锁请求
两段锁协议：所有事物必须分为两个阶段对数据项进行加锁和解锁(可能死锁)
67.ValueOF的特性（代码）
public class CharToString {
public static void main(String[] args){
char myChar = 'g';
String myStr = Character.toString(myChar);
System.out.println("String is: "+myStr);
myStr = String.valueOf(myChar);
System.out.println("String is: "+myStr);}}
ValueOF源码：
public static String toString(char c) { return String.valueOf(c); }
public static String valueOf(char c) { char data[] = {c}; return new String(data, true); }
·能够看到toString和valueOf方法对于char来说返回的是String对象中包含c的值
·只有char变为int才会变为对于的assic码
68.Final、finally、finalize三个区别
·final可以作为修饰符修饰变量、方法、类
被修饰的变量为常量、方法不能重写、类不能继承
·finally用于在异常处理中定义总是执行的代码，无论无论try块中的代码是否引发异常，catch是否匹配成功，finally块中的代码总是被执行
·finalize方法在垃圾回收器执行内存对象清理时调用
69.JSP和servlet是什么
不同之处
JSP在静态HTML内容中嵌入java代码，java代码被动态执行后生成HTML内容
servlet在java代码中通过HttpServletPesponse对象动态输出html内容
特点
Serlvet虽然主要编写业务逻辑代码，但在java源文件中通过字符串拼接的方式生成动态html内容会导致代码维护困难、可读性差
JSP虽然规避了Servlet在生成HTML内容方面的劣性，但是在HTML中混入大量、复杂的业务逻辑也是不可取的
通过MVC来规避劣性使servlet专注业务逻辑开发，JSP专注前端开发
70.JSP的四大作用域
名称 作用域
Application 在所有应用程序中有效
Session 在当前会话中有效
Request 在当前请求中有效
Page 在当前页面有效
71.JSP九大内置对象
·Request对象
封装了由客户端生成的HTTP请求的所有细节
·response对象
用于响应客户请求，向客户请求输出信息。
·Session对象
由于http使一种无状态协议，通过session可以在应用程序的web页面间进行跳转，保存用户的状态，使整个用户会话存在，直至关闭浏览器。
·application对象
保存所欲应用中的共有数据。在服务器启动时自动创建，在服务器停止时销毁。
·out对象
用户在web浏览器内输出信息，并且管理服务器上的输出缓冲区
·pageContext对象
获取页面上下文
·config对象
取得服务器的配置信息
·page对象
代表jsp本身
·exception对象
处理jsp文件执行时发生的所有错误和异常
72.java通过反射创建对象由几种方式
·使用class对象的newLnstance()方法来创建对象
public class Pig {
public static void main(String[] args) throws IllegalAccessException, InstantiationException {
//通过类.class的方式获取一个该类的Class实例
Class hogClass = Hog.class;
//通过调用newInstance()方法获取一个Hog的实例， 该方法会返回一个Object类型的对象并且会抛出两个异常，
Hog hog = (Hog) hogClass.newInstance();
hog.getName();
}
}
class Hog {
public void getName() {
System.out.println("青青草原"); //输出青青草原
}
}
·通过Constructor类的newlnstance()方法获取
public class Pig {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//通过类.class的方式获取一个该类的Class实例
Class hogClass = Hog.class;
//调用Class类的getConstructor()获得一个指定的构造器（参数为空则获得默认的构造器）对象 注意 获得的构造器得是被public修饰的
Constructor constructor = (Constructor) hogClass.getConstructor();
//调用Constructor的newInstance()方法获取一个Hog实例（注意要强转）
Hog hog = (Hog) constructor.newInstance();
hog.getName();
}
}
class Hog {
public Hog() {
System.out.println("无参构造函数"); //输出无参构造函数
}
public void getName() {
System.out.println("青青草原"); //输出青青草原
}
}
73.Static修饰变量和i++的顺序（代码）
public class Test{
private static int i=1;
public int getNext(){
return i++;}
public static void main(String [] args){
Test test=new Test();
Test testObject=new Test();
test.getNext(); //返回1，i=2
testObject.getNext(); //返回2，i=3
System.out.println(testObject.getNext()); //返回3，i=4
}
}
·static修饰i所以i是一个类属性，只要是以Test为对象的都共用i
·return i++先返回i，之后再进行相加
74.变量的初始化（代码）
public class foo{
public static void main (String[] args){
String s;
System.out.println("s=" + s);
}
}
·局部变量可以先声明不用初始化赋值，但是如果后面使用到了就要赋值初始化
75.关于java中ClassLoader你怎么理解？
·java系统提供3种类加载器：启动类加载器（Bootstrap ClassLoader） 扩展类加载器（Extension ClassLoader） 应用程序类加载器（Application ClassLoader）
·类只需要加载一次，因此保证类加载过程线程安全，防止类加载多次
·Java程序的类加载采用双亲委派模型：如果一个类加载器收到了类的加载请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求时，子加载器才会尝试自己去加载
·应用程序类加载器(Application ClassLoader)负责加载用户类路径(ClassPath)上所指定的类库，不是所有的ClassLoader都加载此路径。
76.String的底层（代码）
public class Test {
public static void main(String args[]) {
String s = "祝你考出好成绩！";
System.out.println(s.length());
}
}
Java中String底层是char数组构成的，它的length()返回数组大小，unicode中中文的一个汉字代表一个字符
77.volatile关键字是什么意思
·用于限定变量只能从内存中读取，保证对所有线程而言，值都是一致的。但是并不能保证原子性，也就不能保证线程安全
·出于运行速率的考虑，java编译器会把经常访问到的变量放到缓存（工作内存）中，读取变量则从缓存中读。但是在多线程编程中，内存中的值和缓存中的值可能会出现不一致。
78.Mysql索引怎么理解
·索引就像目录一样，能够帮我们快速地查找到我们想要的数据，避免全表扫描，但在一点程度上降低写速度
·mysql的存储结构是innodb和myisam
·数据存储在内存中，所以避免进行过多的IO操作，数据库innodb使用B+树
79.栈和堆存放什么数据
·栈内存中存放函数中定义的一些基本类型的变量和对象的引用变量
·堆内存中存放new创建的对象和数组
80.丢失更新、不可重复读、脏读
·丢失修改：两个事务读取了某一个值48，其中一个事务先进行操作完成，另一个事务之后进行操作，把原先事务的操作给覆盖了，这种现象就是丢失修改
·不可重复读：事务T1先读取数据，事务T2执行更新操作，是T1无法再现前一次读取的结果
·脏读：事务T2读取到了T1事务操作时的修改值，但是事务T1之后又回滚了
·破坏了事务的隔离性
81.Socket两种创建方法
·socket也叫套接字，就是源ip地址，目标ip地址，源端口号和目标端口号的组合
·服务器端实例：ServerSocket server = new ServerSocket(端口号)
·客户端：Socket soc = new Socket(ip地址，端口号)
82.JAVA内部类
分为四种：成员内部类，静态内部类，局部内部类，匿名内部类
·成员内部类无视外部类修饰词，可以直接访问外部类属性
·静态内部类相当于外部类的成员，只需要实例就能创建
·局部内部类作用域只在本身
·匿名内部类常用在线程
83.线程的状态
五种状态
·新建（new）新创建的一个线程对象
·可运行（runnable）线程创建后，调用了start（）方法，该状态的线程位于可运行线程池中，等待线程调度选中，获取cpu使用权
·运行（running）线程获得了cpu时间片，执行程序代码
·阻塞（blocked）线程因为某种原因泛起了cpu使用权，让出了cpu的时间片，暂时停止运行。直至线程进入可运行（runnable）状态，才有机会获得cou时间片转到运行（running）状态
·死亡（dead）线程run（）、main（）方法执行结束，或者异常退出了run（）方法该线程结束声明周期。
84.JAVA线程运行状态图
85.Sleep()和wait()的区别
·sleep方法让正在执行的线程主动让出cpu，在指定时间后cpu再回到该线程继续往下执行（只是让出了cpu，并不会进入锁池队列，不回释放同步锁）
·wait方法让当前线程暂时退出同步锁资源，一爱你其它正在等待该资源的线程得到该资源而运行，只有调用了notify()方法，之前调用wait()线程才会解除wait状态，参与竞争同步资源锁。
·sleep时线程thread的方法，wait时object的方法
·sleep可以在任何地方是使用，wait只能在同步方法或同步块中使用
86.数据库的三范式
·第一范式：最基本的形式，数据库表中的所有字段值都是不可分解的原子值
·第二范式：第一范式的基础上，确保数据库表中的每一列都和主键相关
·第三范式：不依赖其它非主属性，属性直接依赖于主键
87.Java程序的种类
·Application：java应用程序，是可以由java解释器直接运行的程序
·Applet：即Java小应用程序，是可随网页下载到客户端由浏览器解释执行的java程序
·Servlet：java服务器端小程序，由web服务器中配置运行的java程序
88.Java基本的回收算法
·复制算法：两个区域A和B，初始对象咋A，继续存活的对象转移到B
·标记清理算法：一块区域，标记可达对象（可达性分析）回收不可达对象，会出现碎片
·标记-整理算法：多了碎片整理，整理出更大的内存放更大对象
两个概念：新生代和年老代
·新生代：初始对象，生命周期短
·永生代：长时间存在的对象
整个java的垃圾回收是新生代和年老代的写作，这种叫做分代回收
89.Java自动拆箱和自动装箱过程
·自动装箱：把基本类型赋值给它的包装类型，使用的是valueOf
·自动拆箱：把包装类型赋值给它的基本类型，使用的是intValue
90.new Integer(123) 与 Integer.valueOf(123)区别
·new Integer(123)每次都会新建一个对象
·Integer.valueOf(123)会使用缓存池中的对象，多次调用会取得同一个对象的引用
91.String.intern()含义
·使用String.intern()可以包装相同内容的字符串变量引用同一的内存对象
92.Java三大集合
·List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问
·Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）
·Map集合中保存Key-value对形式元素，访问时只能根据每项元素的key访问其value
93.Java线程中run和start的区别（代码）
public static void main(String args[]) {
Thread t = new Thread() {
public void run() {
pong();
}
};
t.run(); //不会开启多线程，所以执行pong
System.out.print("ping"); //等待主线程执行完ping，再执行ping
}
static void pong() {
System.out.print("pong");
}
·run方法是一thread调用普通方法，还是会在main主线程中运行，是不会开启多线程
·start方法是启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕，而直接继续执行下面代码
·yield方法是暂停当前正在执行的线程对象，并执行其它线程（运行状态转到可运行状态）
94.Java字符串拼接有几种方式
·通过+号进行拼接（实际上还是通过new StringBuilder对象来进行拼接）
·通过concat拼接，实际上申请char类型的buf数组，将需要拼接的字符串都放在数组里，返回String对象
·append方法拼接，其中Stringbuffer和StringBuilfer都有append方法，但是buffer的append方法加上了sychronized同步锁，线程安全
95.Java语言的机制
·java中去除了指针机制，变为了引用
·java的内存管理不需要程序员来管理，java虚拟机来完成对内存的管理
·GC机制的优点是，系统会自动处理不再被引用的对象，在cpu空前或者存储空间不足的时候清理。提高了编程的效率
96.会话跟踪机制
·cookies：服务器创建，把令牌信息保存在用户机器上，下次用户再次访问可以根据令牌发送给服务器，进行身份验证
·url重写：用户访问的链接后可以包含get参数，访问某条对应的数据
·隐藏式表单域：通过隐藏表单，当用户提交表单会包含隐藏的信息
·session机制：把信息保存在服务器，但是并发环境下对服务器压力大
97.JVM结构
·五个部分
·堆
·本地方法栈
·方法区
·PC寄存器
·虚拟机栈
栈帧
98.Finally的特性
public class Test {
public static void main(String[] args) {
System.out.println(test());
}
private static int test() {
int temp = 1;
try {
System.out.println(temp); //输出1
return ++temp; //返回2，但是先把retrun值存在临时空间
} catch (Exception e) {
System.out.println(temp);
return ++temp;
} finally {
++temp; //temp=3
System.out.println(temp); //输出3
}}}
·若try代码含有return，同时存在finally（无return）代码块时，先执行finally代码块
·若try代码含有reruen，同时存在finally（有return）代码块时，此时finally代码块内的return值将直接返回（try中return值会被覆盖）
99.Java中你的statis关键字理解
·static可以修饰变量，方法，构造器、初始化块、内部类
·类成员不能访问实例成员，因为类成员属于类的，类成员的作用域比实例成员的作用域更大，完全可能出现类成员已经初始化完成，但实例成员还不曾初始化的情况，如果允许类成员访问实例成员将会引起大量错误。
·静态变量：属于类，存储在方法区，可以通过类名访问
·静态方法：属于类，可以通过类名访问
·静态块：属于类，当类加载时候被隐式调用一次，可以通过类名访问
·静态内部类：可以包含静态成员，也可以包含非静态成员。静态内部类不能访问外部类的实例成员，只能访问外部类的静态成员。
100.Java泛型
·用来规定一个类、接口或方法所能接受的数据的类型。
·无边界通配符<?>
让泛型能够接受未知类型的数据
·固定上边界通配符<? extends E>
能够接受指定类及其子类型的数据
·固定下边界通配符<? super E>
能够接受指定类及其父类型的数据
101.Java反射机制理解
Java对象在允许时表现为两种类型，即编译时类型和允许时类型。Person p = new Student();生成一个p的变量，变量的编译时类型为Person，运行时类型为Student
·程序运行时接收到一个对象，编译时类型为object，但程序需要调用对象的方法。这就需要程序运行时发现对象类的真实信息。
·如果编译时无法知道该对象属于那些类，程序只能依靠运行时的信息来发现该对象和类内部信息，这就需要反射。
102.Java序列化理解
·ObjectOutputStream：提供序列化大对象并把其写入流的方法
·ObjectInputStream：读取流并反序列化对象
·Serializable：序列化必须实现的接口，父类实现，子类也可以序列化，子类实现，父类每实现，子类可以序列化
·transient关键字：修饰的内容不允许序列化
·serialVersionUID：保持序列化版本的兼容性，反序列化保持对象的唯一性
103.StringBuffer的方法
·StringBuffer s = new StringBuffer(x); x为初始化容量长度
·s.append(“Y”);”Y”表示长度为y的字符串
·length始终返回当前长度y
·capacity如果字符串长度没有初始化长度大，返回初始化长度；如果append后字符串长度超过初始化长度，caoacity返回增长后的长度
104.Instanceof的作用(代码)
class A{}
class B extends A{}
class C extends A{}
class D extends B{}
A obj = new D();
System.out.println(obj instanceof B); //D是B的子类，可以转型，为true
System.out.println(obj instanceof C); //D与C并没有直接继承，不可以转型，为false
System.out.println(obj instanceof D); //D与D是同一类，可以转型
System.out.println(obj instanceof A); //A是D的基类，可以转型为true
·instanceof是判断前者是否可以类型转换为后者，可以转换位true，分为向上和向下转型
105.单例模式
·单例模式是java中最简单的设计模式。属于创建型模式，涉及到一个单一的类。该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象方式，可以直接访问，不需要实例化该类的对象。
·单例类只能有一个实例
·单例类必须自己创建自己唯一实例
·单例类必须给所有其它对象提供这一实例
106.数据库事务隔离级别
·四个级别，为了解决更新丢失，脏读，不可重复读、幻影读
·未提交（read uncommitted）
·授权读取（read committed）
·可重复读取（repeatable read）
·序列化（serializable）
107.基本类型、包装类型、String之间的转换
·String.valueOf方法，能够把八大基本类型转换为String类型
·String aa =”123”,int a = 123; aa+a = 123123这是因为String是字符类型，相加会自动进行类型转换，把基本类型转换为String
·int转换Integer，自动封装，相当于new包装类对象
·Integer转换int，自动拆箱，调用Integer.vlaueOf
·Integer转换为String，调用toString方法
·String转化为Integer，调用Integer.valueOf
·int转换为String，调用String.valueOf
·String转换为int,调用Integer.parseXxx
108.Linux基本命令
·kill xxx 杀死某个进程 kill -HUB 重写加载某个进程
·ls：列出目录及文件名
·cd：切换目录
·pwd：显示当前的路径
·mkdir：创建一个新的目录
·rmdir：删除一个空的目录·
·cp：赋值文件或目录
·rm：删除文件或目录
·mv：移动文件与目录
109.Sql视图作用
·创建视图格式：carete view 视图名 as 查询语句
·查询视图格式：select * from 视图名
·删除视图格式：drop view 视图名
·视图只能查看不能修改，增加了安全性
110.Java中的内存分配
·栈内存：存储局部变量，局部变量就是方法中的变量；类似于栈，先进后出
·堆内存：存储new的对象，程序结束由OS回收
·静态区：存储的是全局变量和静态变量
·常量池：字符串存储的区域
·程序代码区：存放函数体的二进制代码
111.TCP的运行阶段
·链接创建
·数据传送
·链接终止
112.线程守护
·为了保护当主线程执行完毕，而其它线程也被关闭的线程
·其它线程全部运行完毕，守护线程才会自动销毁
·jvm会等待非守护线程结束，不会等待守护线程结束。GC线程就是守护线程
113.Collection接口和Map接口
·collection是集合的接口
·list接口：内容允许重复
·ArrayList
·LinkedList，也是先了Queue接口
·Vector
·Set接口：内容不允许重复
·Queue接口：队列
·sortedSet：单值排序接口
·Map也是集合的接口
·HashMap接口：无序存放，key不重复
·HashTable接口：无序存放，key不重复
·TreeMap接口：按key排序，jey不重复
114.JSON对象格式
·JSON由{键：值}组成，需要注意的是：
键用引号（单双）引起来，也可以不用引号
值的取值类型：数字、字符串、逻辑值、数组、JSON对象、null
115.socket阻塞与非阻塞，同步与异步
·同步：也就是浏览器发出一个功能请求，在没有得到结果之前，不能进行其它操作。
B/S（同步）：提交请求->等待服务器处理（不能进行其它操作）->处理完毕返回
·异步：当浏览器异步过程调用发出后，调用者不能立刻得到结果，可以进行其它操作。
Ajax（异步）：请求通过实践出发->服务器处理（可以进行其它操作）->处理完毕返回
·阻塞：调用结果返回之前，当前线程会被挂起（线程进进入等待状态，CPU不会给线程分配时间片）。函数只有在得到结果才会返回。
阻塞和同步不同，阻塞是没得到结果在等待状态，而同步是线程仍然工作但还没处理完
·非阻塞：不能立刻得到结果之前，函数不会等待，立刻返回
116.ServletRequest对象常用方法
·request.getCookies返回一个数组，包含客户端发送该请求的所有Cookie对象
·request.getAttribute以对象形式返回已命名属性的值，如果没有给定名称的属性存在，则返回null
·request.getHeader以字符串形式返回指定的请求头的值。Cookie也是头的一种
·request.getParameter以字符串形式返回请求参数的值，或者如果参数不存在则返回null
117.Map接口
·接口不允许new对象，Map和SortedMap都是接口
·HashMap允许null-null键值对，线程不安全
·TreeMap允许value为null，不允许key为null
118.Java内存结构
119.Maven和ant是什么
·ant和maven都是基于Java的构建工具。Ant是软件构建工具，maven定位是软件项目管理和理解工具。
·ant特点
没有一个约定的目录结构
必须明确让ant做什么，什么时候做，然后编译，打包
没有生命周期，必须定义目标及其实现的任务序列
没有继承依赖管理
Maven特点：
拥有约定，知道你的代码在哪里，放到哪里去
拥有一个生命周期，例如指向mvn install可以自动编译，测试，打包构建过程
只需要定义一个pom.xml，然后把源码放到默认的目录maven帮你处理
拥有依赖管理，仓库管理
120.>>和>>>的区别
·>>算术右移操作符，高位补符号位，也就是正数补0，负数补1
·>>>逻辑右移符操作符，无符号移位，高位补0
121.Where和having的区别
·where是一个约束声明，使用where来约束来自数据库的数据
·where实在结果返回之前起作用
·where中不能使用聚合函数
·having是一个过滤声明，在查询返回结果集以后，对查询结果进行过滤操作
·having可以使用聚合函数
·having自居在聚合后对组记录进行筛选
122.两张表字段相同，找出B表中与A表不同的数据，并把它与到A表中数据显示
SELECT * from teacher
UNION
select DISTINCT * from teachers WHERE t_id not in (SELECT t_id from teacher);
首先找出A表数据，再进行拼接。B表中与A表中不同的数据进行拼接
123.强转顺序大于+-/，与括号括号平级
(short)10/10.22为double类型
·首先10进行强转为短整形
·因为存在浮点数，所以short提升类型为double
124.线程Join()函数
·thread.join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。
·t.join() 调用线程t在此之前执行完毕
·t.join() 等待t线程，等待时间是1000毫秒
125.Synchronized和lock锁的区别
·lock是一个接口，而Synchronized是关键字
·Synchronized会自动释放锁，而kicj必须手动释放锁
·lock可以让等待锁线程响应中断，而Synchronized不会，线程会一直等待
·通过lock可以指定线程有没有拿到锁，而Synchronized不能
·lock能提高多个线程读操作的效率
·Synchronized能锁类，方法代码Kauai，而lock只能代码块
126.线程池是什么？
·一种管理多线程线程处理的方式，处理过程中可以将任务添加到队列中，然后再创建线程后管理这些任务
