1.java基本数据类型？
byte 1，short 2 ，int 4，long 8 ，float 4，double 8，boolean 1，char 2
2.java为什么要有包装类型？
前 6 个类派生于公共的超类
Number，而Character和Boolean是Object的直接子类。被
final修饰， Java 内置的包装类是无法被继承的。
包装类作用
- 对象化 - 将基本数据类型用对象封装起来，实现一些特色的方法。
- 数据类型转换 - 通过包装类可以实现数据类型转换
- null值校验 - 例如如果基本数据类型没值的话，默认会给值，需要与数据库一致
装箱拆箱
- 装箱：将基本数据类型转换成包装类
- 拆箱：从包装类之中取出被包装的基本类型数据（使用包装类的 xxxValue 方法）
JDK 1.5 之后，Java 提供了自动装箱与自动拆箱的机制 ， 主要依赖于valueOf和parseXXX方法实现。自动装箱和拆箱通常是由编译器在需要时自动进行的。
Integer obj = 10; // 自动装箱. 基本数据类型 int -> 包装类 Integer
int temp = obj; // 自动拆箱. Integer -> int
obj ++; // 直接利用包装类的对象进行数学计算
System.out.println(temp * obj); 
注意 - IntegerCache 内部类
Integer中有这个int缓存，当范围在-128 到 127之间，如果已经存在该对象，则之间复用，不新创建包装类。
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}Java自动装箱和自动拆箱_java自动拆箱和自动装箱-CSDN博客
3.string，stringbuilder，string buffer区别？
- string被final修饰，不可变字符串。
- stringbuilder可变字符串容器对象，线程不安全，效率比string高些
- stringbuffer可变字符串，线程安全，效率低。
String
1.8部分源码，类和变量value数组都是由final修饰，不可变。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
****
}StringBuilder
从以下部分源码可看出构造器调用父类方法进行扩容，说明操作的字符串在父类。然后继承的又只有一个，那就是AbstractStringBuilder类，线程不安全。
public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence
{
/** use serialVersionUID for interoperability */
static final long serialVersionUID = 4383685877147921099L;
/**
* Constructs a string builder with no characters in it and an
* initial capacity of 16 characters.
*/
public StringBuilder() {
super(16);
}
**************************
}然后发现这里操作的字符串没有用final修饰，那就是可变的。
abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* The value is used for character storage.
*/
char[] value;
/**
* The count is the number of characters used.
*/
int count;
****************************************************
}StringBuffer
可以看到，他们所继承的类都一样，不一样的是stringbuffer它重写了继承的方法，并且加上了synchronized关键字，所以线程安全。
public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
private transient char[] toStringCache;
/** use serialVersionUID from JDK 1.0.2 for interoperability */
static final long serialVersionUID = 3388685877147921107L;
public StringBuffer() {
super(16);
}
public StringBuffer(int capacity) {
super(capacity);
}
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
public StringBuffer(CharSequence seq) {
this(seq.length() + 16);
append(seq);
}
@Override
public synchronized int length() {
return count;
}
*******************************
}String、StringBuilder、StringBuffer、StringJoiner类的常用方法，以及区别_stringjoiner fangfa-CSDN博客
4.如何理解面向对象和面向过程？
面向过程就是以函数为主体，通过函数间互相调用实现目的，强调过程。
而面向过程就是将进行的操作封装到一个类中，通过类与类之间的调用实现目的。
5.面向对象的三大特性？
- 抽象，比如讲动物的名字封装成类变量，行为封装成动物方法。
- 封装，将变量和方法封装到对象中。
- 继承，类通过继承可以实现父类的方法，并使用。
- 多态，多个类可以继承一个父类，通过重写方法，实现不同的行为。
6.为什么浮点数不能表示金额？
因为浮点数会丢失精度，而且存储效率不如整型，所以一般正常生产中用bigint，且bigint计算高效。
7.什么是反射，为什么需要反射？*
反射是java作为动态语言的重要标志，通过反射，可以动态修改类的状态，内容。
创建反射的几种方式
Class<?> class=MyClass.class;
MyClass myClass=new MyClass();
Class<?> class=myClass.getClass();
Class<?> class=Class.forName("com.yy.xxx");利用反射对象操作类
调用构造参数创建类对象，简单写一下吧，如果有需要去下面的博客里看看。
User user = userClass.newInstance();
System.out.println(user);
Constructor<?>[] declaredConstructors = userClass.getDeclaredConstructors();
for (Constructor c:declaredConstructors) {
System.out.println(c.getParameterTypes());
}
Method[] methods = userClass.getMethods();
for (Method m:methods) {
System.out.println(m);
}
Field[] declaredFields = userClass.getDeclaredFields();
for (Field f:declaredFields) {
System.out.println(f.getName());
}
Java 中反射的概念、作用和特点，在什么情况下使用反射及使用实例_java反射的作用及应用场景-CSDN博客
8.为什么需要克隆？如何实现克隆？？深拷贝和浅拷贝的区别？
因为经常我们业务上需要复制一份数据。
浅拷贝就是只复制表层对象,并不复制对象内部的对象.
深拷贝是对象及其对象内部对象都复制成新的对象.
他们都可以通过类实现cloneable接口重写clone方法
详情参考
Java深入理解深拷贝和浅拷贝区别_java深拷贝浅拷贝-CSDN博客
9.try-catch-finally 如果catch return了，那么还会执行finally嘛
会在return前执行finally。
10.String为什么被设计成不可变的？
- 字符串复用
- 线程安全
- hashcode 因为不可变,所以hashcode不用重新计算,并且很适合做key
string被final修饰，不可变。这样的好处可以实现字符串复用和线程安全。
当我们改变一个字符串值的时候，他是去创建一个新的字符串，然后把指针更改到新的位置。
Java 中 String 类为什么要设计成不可变的？-腾讯云开发者社区-腾讯云
11.error与exception的区别？以及常见的runtime exception？*
error是一些不可避免的错误，一般不是由于代码错误。
而exception分为运行时异常和编译时异常。
编译时异常try catch。
而运行时异常需要检查代码，比如空指针等等。
java之异常（Exception）与错误（Error）的区别_java中error和exception的区别-CSDN博客
12.抽象类和接口的区别？**
- 接口是定义一种规范，抽象类是定义一个模板。
- 接口没有构造方法。抽象类有构造方法。
- 接口成员变量默认由public static final修饰，必须赋初值，方法由public abstract修饰。抽象类成员变量么有限制，可以有构造方法，抽象方法或具体方法。
- 接口多实现，抽象类单继承。
13.==与equals区别？
在判断字符串时，==会判断内容和地址，而equals只判断内容，因为string重写了equals方法。
14.super和this区别？*
super调用父类方法，this调用子类的方法。
15.java集合类，特点？
- arraylist 基于数组实现，查找快，增删慢，线程不安全，默认长度为10,1.5倍扩容。
- linkedlist基于链表实现，查找慢，增删快。线程不安全。
- vector基于数组实现，线程安全，默认长度为10,2倍扩容。
- hashmap线程不安全，键值对，两倍扩容。底层使用了数组加链表加红黑树。
- concurrenthashmap线程安全。底层采用无冲突时采用乐观锁cas资源重试。冲突时采用synchronize锁代码块。需再看源码。
16.集合排序方案实现？***
Arrays类可以对数组排序
int[] arr = {1, 5, 2, 1, 4};
System.out.println("排序前："+Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("排序后："+Arrays.toString(arr));Collections可以对list排序
List<String> list = new ArrayList<>();
list.add("b");
list.add("d");
list.add("ca");
list.add("da");
System.out.println("排序前："+list);
Collections.sort(list);
System.out.println("排序后："+list);
List<Person> list = new ArrayList<>();
list.add(new Person("李四1", 19));
list.add(new Person("张三1", 59));
list.add(new Person("张三2", 69));
list.add(new Person("张三3", 79));
list.add(new Person("张三4", 89));
System.out.println("按名字排序前：" + list);
Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
//按名字排序
return o1.getName().compareTo(o2.getName());
}
});
System.out.println("按名字排序后：" + list);
System.out.println("按年龄排序前：" + list);
Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
});
System.out.println("按年龄排序后：" + list);实现comparable接口，重写compareTo方法
static class Person implements Comparable<Person> {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "[" + name + "," + age + "]";
}
@Override
public int compareTo(Person o) {
return Integer.compare(this.getAge(), o.getAge());
}
}
list.sort((o1, o2) -> o1.compareTo(o2));参考
一篇文章搞定Java中常用集合的排序方法_java 集合排序-CSDN博客
Java 中如何对集合进行排序_java集合排序-CSDN博客
17.arraylist，linkedlist，vector区别？*
- arraylist 基于数组实现，查找快，增删慢，线程不安全，默认长度为10,1.5倍扩容。
- linkedlist基于链表实现，查找慢，增删快。线程不安全。
- vector基于数组实现，线程安全，默认长度为10,2倍扩容。
ArrayList（1.8）
初始化
//默认容量
private static final int DEFAULT_CAPACITY = 10;
//用于空实例的共享空数组实例。
private static final Object[] EMPTY_ELEMENTDATA = {};
//用于默认大小空实例的共享空数组实例。我们区分它和EMPTY_ELEMENTDATA，
//以便在添加第一个元素时知道要扩展多少。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//用于存储ArrayList元素的数组缓冲区。
//ArrayList的容量是这个数组缓冲区的长度。任何
//elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList
//在添加第一个元素时，都会扩展到DEFAULT_CAPACITY。
transient Object[] elementData;
//数组长度
private int size;
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
//初始化容量
this.elementData =