java技术总结

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 propertyint 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_VALUEh = 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博客

浅析Java中为什么要设计包装类_java_脚本之家

3.string，stringbuilder，string buffer区别？

string被final修饰，不可变字符串。
stringbuilder可变字符串容器对象，线程不安全，效率比string高些
stringbuffer可变字符串，线程安全，效率低。

String

1.8部分源码，类和变量value数组都是由final修饰，不可变。

public final class Stringimplements 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 StringBufferextends AbstractStringBuilderimplements 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);}@Overridepublic 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博客

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修饰。抽象类成员变量么有限制，可以有构造方法，抽象方法或具体方法。
接口多实现，抽象类单继承。

抽象类和接口的区别（通俗易理解）-CSDN博客

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>() {@Overridepublic 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>() {@Overridepublic 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;}@Overridepublic String toString() {return "[" + name + "," + age + "]";}@Overridepublic 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 =