java基础面试题

java语言有哪些特征：

简单易学，有丰富的类库
面向对象，高内聚低耦合
和平台无关性，可以做到一次编写永久使用（jvm则是java跨平台的根本）
安全可靠
支持多线程

面向对象和面向过程

面向过程：分析解决问题的步骤，然后通过函数把这些步骤一步一步地实现，然后在使用的时候一一调用，性能搞，所有单片机，嵌入式开发一般采用面向过程开发。

面向对象：世上的万事万物皆可看做对象，将构成问题的事务分解成为各个对象，而建立对象的目的也不是完成一个个步骤，而是描述某事物在解决整个问题过程中所发生的行为。面向对象有三大特征，封装，继承，多态。故而更加容易维护，容易复用，容易拓展。可以设计出低耦合的系统，但从性能上讲，比面向过程要低。

java8种数据类型

int short byte long

字节 4 2 1 8

默认值 0 0 0 0L

封装类 Integer Short Byte Long

float double

字节 4 8

默认值 0.0f 0.0d

封装类 Float Double

boolean

字节 -

默认值 false

封装类 Boolean

char

字节 2

默认值 null

封装类 Character

注意：

int 是基本数据类型，Integer是int的封装类，是引用类型，int默认值是0，而Integer默认值是null,所以Integer能区分出0和null的情况，一旦java看到null，这个引用还么指向某个对象，在任何引用使用前，必须为其指定一个对象，否则报错
基本数据类型，在声明之前系统会自动给他分空间而引用类型声明时知识分配了引用空间，必须通过该实例化开辟对象之后才能赋值，数据对象也是一个引用对象，将一个数组赋值给另一个数组时只是复制了一个引用，所以通过某一个数组所做的修改在另一个数组中也看得见。
虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java 虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素 boolean元素占8位。这样我们可以得出boolean类型占了单独使用是4个字节，在数组中又是1个字节。使用int的原因是，对于当下32位的处理器（CPU）来说，一次处理数据是32位（这里不是指的是32/64位系统，而是指CPU硬件层面），具有高效存取的特点。

instanceof关键字的作用

用来测试一个对象是否为一个类的实例

1	boolean result = obj instanceof Class;

obj为对象，Class表示一个类或者接口。当obj为Class对象或者是其直接或间接子类，或者是其接口的实现类，结果都是result返回为true，否则false;

int i = 0;
System.out.println(i instanceof Integer);//编译不通过 i必须是引用类型，不能是基本类型
System.out.println(i instanceof Object);//编译不通过
Integer integer = new Integer(1);
System.out.println(integer instanceof Integer);//true
//false ,在 JavaSE规范 中对 instanceof 运算符的规定就是：如果 obj 为 null，那么将返回 false。
System.out.println(null instanceof Object);

java自动装箱与拆箱

装箱是自动将基本数据类型转换为包装类型（int -> Integer ）;调用方法： Integer的valueOf(int)方法

拆箱就是自动将包装器数据类型转换为基本类型（Integer->int）。调用方法：Integer的intValue方法。

在javaSE5之前，如果要生成一个数值为10的Integer对象，必须要

1	Integer i = new Integer(10);

而在从java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，则

1	Integer i = 10;

main:
Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;
sout(i1 == i2);//true;
sout(i3 == i4);//true;

归根结底

public static Integer valueOf(int i) {
 if(i >= -128 && i <= IntegerCache.high)
	 return IntegerCache.cache[i + 128];
 else
 	return new Integer(i);
 }

IntegerCache

private static class IntegerCache {
 static final int high;
 static final Integer cache[];
 static {
 final int low = -128;
 // high value may be configured by property
 int h = 127;
 if (integerCacheHighPropValue != null) {
 // Use Long.decode here to avoid invoking methods that
 // require Integer's autoboxing cache to be initialized
 int i = Long.decode(integerCacheHighPropValue).intValue();
 i = Math.max(i, 127);
 // Maximum array size is Integer.MAX_VALUE
 h = Math.min(i, Integer.MAX_VALUE - -low);
 }
 high = h;
 cache = new Integer[(high - low) + 1];
 int j = low;
 for(int k = 0; k < cache.length; k++)
 cache[k] = new Integer(j++);
 }
 private IntegerCache() {}
 }

从这两段代码上可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127],之间便返回指向Integer.cache中已经存在的对象的引用，否则创建一个新的Integer对象。

上边的代码中i1和i2的数值为100，因此会从cache中读取已经存在的对象。所有i1和i2指向的是同一个对象，而i3和i4，分别指向的是不同的对象。

main:
Double i1 = 100.0；
Double i2 = 100.0；
Double i3 = 200.0；
Double i4 = 200.0；
sout(i1 == i2);   //false
sout(i3 == i4);   //false

原因在于在某个范围内的整型数值的个数是有限的，而浮点数不是。

重载和重写

重写（Override）：顾名思义，重写就是重新写一遍的意思，其实急速在子类中把父类本身有的方法重写写一遍，子类继承了父类的原有的方法，单有时候子类并不想原封不动的继承父类的某个方法所以在方法名，参数列表，返回类型（除去子类中方法的返回值是父类中方法返回值的子类时）都在相同的情况下，对方法体进行修改或者重写，但是注意，子类函数的方法的访问修饰权限不能少于父类的。

public class Father(){
    main:{
    	Son s = new Son();
    	s.sayHello();
    	}
    	public void sayHello(){
            sout("Hello");
    	}
}
class Son extends Father{
    @Override
    public void sayHello(){
        sout("Hello --by");
    }
}

总之，重写

发生在父类和子类之间.
方法名，参数，返回类型（除去子类方法的返回类型是父类中返回类型的子类）必须相同
访问修饰符的限制一定要大于被重写方法的访问修饰符（public > protected > default > private ）
重写方法一定不能抛出新的检查异常或者比被重写的方法申明更加宽泛的检查型异常。

重载（Overload） ：同一个类下，同名的方法如果有不同的参数类型列表（参数类型不同，参数个数不同甚至参数顺序不同）则视为重载，同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。

public class Father {
 public static void main(String[] args) {
 // TODO Auto-generated method stub
	 Father s = new Father();
 	s.sayHello();
 	s.sayHello("wintershii");
 }
 public void sayHello() {
 	System.out.println("Hello");
 }
 public void sayHello(String name) {
 	System.out.println("Hello" + " " + name);
 }
}

重载：

重载是一个类中多态性的一种表现
重载要去方法名相同参数列表不同（参数类型，参数个数，甚至参数顺序）
重载的时候，返回值类型可以相同也可以不同，无法以返回型作为重载函数的区分标准。

equals 与 == 的区别

==比较的是变量（栈）内存中存放对象的（堆）内存地址，用来判断两个对象的地址是否相同，也就是是否比较相同一个对象，比较的真正意义上的指针操作。

比较的是操作符两端的操作数是否是同一个对象
两边的操作数必须是统一类型的（可以是父子类之间）才能编译通过。

比较的是地址，如果是具体的阿拉伯数字的比较，值相等就是true,如 int a = 10 ,long b=10.0L ,double c = 10.0 都是相同的，因为他们都指向地址为10的堆；

public class Father {
 public static void main(String[] args) {
	 int a = 10;
	 long b = 10L;
	 double c = 10.0;
	System.out.println(a == b);	 //true
	 System.out.println(b==c);   //true
	  System.out.println(a==c);	  //true
 }
}

equals:用来比较两个对象的内容是否相等，由于所有的类都是继承java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object中的方法，而Object中的equals方法的返回确实==的判断。

总结

所有的比较是否相等时，都是用equals并且对常量相比较时，把常量写在前面，因为使用object的equals object 可能为null则空指针。在阿里的代码规范中只使用equals ，阿里插件默认会识别，并可以快速修改，推荐安装阿里插件来排查老代码使用“==”，替换成equals

Hashcode的作用

java集合有两个类，一类是List，一类是Set，前者有序可重复，后者无序不重复，当我们在set中插入的时候怎么判断是否已经存在该元素呢？可以通过equals方法，如果元素太多，这样的方法比较满。

于是有人发明了哈希算法来提高集合中查找元素的效率，这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储的那个区域。

hashCode方法可以这样理解，他返回的就是更加对象的内存地址换算出的一个值，这样一来，当集合要添加新的元素的时，先调用这个元素的hashCode方法，就一下能定位到他应该放置的物理位置，如果这个位置上没有元素，就直接存储在这个位置上，不需要在进行任何比较；如果这个位置上已经存在元素，就调用equals方法与新元素比较，相同就不存，不相同就散列到其他地址，这样一来实际调用equals方法的次数就大大降低了几乎只需要一两次。

String,StringBuffer和StringBuilder的区别

String 是只读字符串，由于被final修饰，故string不能被继承，他不是基本数据类型，而是一个对象，且底层源码是一个被final修饰的字符数组，所引用的字符串不能被改变，一经定义，无法再增删改，每次对string的操作都会造成一个新的string对象。

1
2
3

string a = "a";
string b = "b";
string c = a + b;//将会创建一个新的String c ,而String a,String b的值保持不变。

每次+操作后：隐式在堆上new了一个跟原字符串相同的StringBuilder对象，在调用append方法拼接+后边的字符。

StringBuffer和StringBuilder他们两个都继承了AbstractStringBuilder对象。他们的底层都是可变的字符数组，另外StringBuffer对方法加了同步所或者对调用的方法加了同步锁，所以线程是安全的，StringBuilder并没有对方法进行同步锁，故而线程不安全的。

ArrayList和LinkedList的区别

Array(数组)是基于索引（index）的数据结构，它使用索引在数组中搜索和读取数据是很快的。

Array获取数据的时间复杂度是O(1),但是删除数据开销却很大，因为这需要重排数组中所有的数据，（因为删除数据以后，需要把后边的所有数据前移）

缺点：数组初始化必须指定初始化长度，否则报错。

1 2	int[] a = new int[4];//推介使用int[] 这种方式初始化 int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]

List是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式，它继承Collection。

List有两个重要的实现类：ArrayList和LinkedList

ArrayList: 可以看作是能够自动增长容量的数组

ArrayList的toArray方法返回一个数组

ArrayList的asList方法返回一个列表

ArrayList底层的实现是Array, 数组扩容实现

LinkList是一个双链表，在添加和删除元素时具有比ArrayList更好的性能，但在get和set方面弱于ArrayList.当然这些都是对比数据亮很大或者操作很频繁的情况下的。

String类常用对象方法有哪些？

indexOf(): 返回指定字符的索引

charAt():返回指定索引处的字符

replace():字符串替换

trim():去除字符串端空白

split():分割字符串，返回一个分割后的字符串数组

getBytes():返回字符串的byte类型数组

length():返回字符串长度

toLowerCase(): 将字符串转成小写字母

toUpperCase():将字符串转成大写字母

substring():截取字符串

equals():字符串比较