Java SE

基础

对java的理解

平台无关性,GC垃圾回收机制,面向对象,类库,异常处理

平台无关性: 源码编译成字节码,再由不同平台的JVM进行解析,java语言在不同的平台上运行时不需要重新编译,JVM在执行字节码的时候,把字节码转换成平台具体上的机器指令

为什么JVM不直接不将源码解析成机器码去执行?

准备工作:每次执行会有各种检查(语法,语义,重新编译,分析),性能下降,形成字节码能保证多次执行程序,不用
检查

JDK和JRE区别

JDK: Java Development Kit 的简称,java开发工具包,提供了Java的开发环境和运行时环境
JRE:Java Runtime Environment 的简称,Java运行环境,为java的运行提供了所需环境

JVM内存模型

类加载器 ( ClassLoader )

  根据特定格式,加载class文件到内存
  主要在类装载的加载阶段,作用是从系统外部获得类二进制数据流
  它通过将类文件里的二进制数据流装载进系统,然后交给Java虚拟机进行连接,初始化等操作

  种类:
    BootStrapClassLoader: C++编写,加载核心库 java>*
    ExtClassLoader: Java编写,加载扩展库 javax.*
    AppClassLoader: Java编写,加载程序所在目录
    自定义ClassLoader: Java编写,定制化加载

执行引擎 ( Execution Engine )

  对命令进行解析

本地接口 ( Native Interface )

  融合不同开发语言的原生库为Java所用

运行时数据区 ( Runtime Data Area )

  JVM内存结构模型

程序计数器

  一块小的内存区域,线程私有,是唯一不会发生OutOfMemoryError(内存溢出)的区域,可理解为
  方法进栈后,每一行代码都有一个标识,程序按标识往下执行

java虚拟机栈

• 每个方法执行,都会创建一个栈帧,方法调用进栈,方法结束出栈
• 栈帧伴随方法的开始而开始,结束而结束
• 栈帧里存放着 局部变量,操作数栈,动态链接 以及 方法出口等
  • 局部变量表: 包含方法执行过程中所有变量; 其所需的 内存空间 在编译期间 就完成了 分配,运行期不会改变
  • 操作数栈: 入栈,出栈,复制,交换,产生消费变量
• 栈容易出现java.lang.StackOverFlowError,栈内存溢出错误,常见于递归调用,递归过深,栈帧数超过虚拟机深度

本地方法栈

  本地方法栈为native方法服务,java虚拟机栈为java方法服务

堆

• 功能就是 储存对象的实例,堆分为 新生代和 老年代
• 新生代分Eden,Survivor1,Survivor2三个区域,垃圾收集器主要管理的区域,Eden区回收效率很高
• 不是所有对象实例都会分配到堆上去,java虚拟机栈也会分配
• 堆容易出项OutOfMemoryError错误,内存溢出
• JDK7后原先位于方法区的字符串常量池移动到了堆中

堆和栈的区别
  管理方式: 栈自动释放,堆需要GC
  空间大小: 栈比堆小
  碎片相关: 栈产生的碎片远小于堆
  分配方式: 栈支持静态和动态分配,而堆只支持动态分配
  效率: 栈的效率比堆高

方法区

• 存放加载的 类信息,常量,静态变量,静态代码块,字符串常量池等信息
• 类信息包括类的版本,字段,方法,接口等
• JDK7后原先位于方法区的字符串常量池移动到了堆中

元空间(MetaSpace)和永久代(PermGen)的区别?
元空间和永久代都是方法区的实现,方法区只是一种JVM的规范
JDK8后使用了元空间替代了永久代
元空间使用本地内存,永久代使用的是JVM内存

元空间比永久代的优势:
  字符串常量池存在永久代中,容易出现性能问题和内存溢出
  类和方法的信息大小难确定,给永久代的大小指定带来困难
  永久代会给GC带来不必要的复杂性

内存分配策略

静态存储: 编译时确定每个数据目标在运行时的存储空间需求 不允许有可变数据,嵌套,递归,会导致计算
动态存储(栈式存储): 编译时未知,运行时确定 先知道数据区的大小,才能分配内存
堆式存储: 编译和运行时都无法确定,动态分配 如对象实例

JVM怎么解析.class文件?

  通过类加载器将符合格式要求的class文件加载进内存,并通过执行引擎去解析里面的字节码,并提交给操作系统去执行

JVM三大性能调优参数
  -Xss: 规定了每个线程虚拟机栈(堆栈)的大小 一般256K足够。此配置将会影响此进程中并发线程数的大小
  -Xms: 堆的初始值 初始java堆的大小,即该进程创建出来时堆的大小
  -Xmx: 堆能达到的最大值 一旦对象容量唱过-Xms大小,则将java堆大小扩容至该参数。为防止堆扩容导致内存抖动,影响程序进行稳定性,一般设置成与Xms一样大

类的装载过程

加载: 通过类加载器加载class文件字节码,生成class对象
链接:

• 校验: 检查加载的class的正确性和安全性
• 准备: 为类变量分配存储空间并设置类变量初始值
• 解析: JVM将常量池内的符号引用转换为直接引用

初始化: 执行类变量赋值和静态代码块

类的实例化顺序

问：比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字 段，当new的时候，他们的执行顺序。

答： 类加载器实例化时进行的操作步骤（加载–>连接->初始化）。
父类静态变量、 父类静态代码块、 子类静态变量、 子类静态代码块、 父类非静态变量（父类实例成员变量）、 父类构造函数、 子类非静态变量（子类实例成员变量）、 子类构造函数。

栈和堆的区别？

1.堆内存用来存放由new创建的对象和数组。
2.栈内存用来存放方法或者局部变量等
3.堆是先进先出，后进后出
4.栈是后进先出，先进后出

构造方法

用于初始化对象状态的特殊方法类型。在实例化类时调用,并为对象分配内存。构造方法的名称必须和类名相同。构造方法没有显式返回类型 隐式返回类的当前实例。

根据构造方法中传递的参数,分为默认构造方法和参数化构造(有参无参)
无参构造(默认构造):
  不用接受任何值,主要用于使用默认值初始化实例变量,如果类中没有定义构造方法,编译器会隐式创建无参构造
有参构造(参数化构造):
  可以接收参数的构造方法

如何操作字符串常量池？

JVM实例化字符串常量池时

String str1 = "hello";
String str2 = "hello";
System.out.println("str1 == str2" : str1 == str2 ) //true

通过new创建的 字符串对象 不指向字符串池 的任何对象,但是可通过 使用字符串的intern()方法来指向其中的一个。
java.lang.String.intern()返回一个 保留池字符串,就是在 全局字符串池中有了一个入口, 如果以前没有在 全局字符串池中,那么它就会被 添加 到里面

不同JDK版本间initern()方法的区别
JDK6:
  调用时,如果字符串常量池已创建该字符串对象,则返回池中的该字符串的引用。
  否则,将此字符串对象添加到字符串常量池中,并且返回该字符串对象的引用
JDK6+:
  调用时,如果字符串常量池已创建该字符串对象,则返回池中的该字符串的引用。
  否则,如果字符串对象已经存在Java堆中,则将堆中对此对象的引用添加到字符串常量池中,并且返回该引用;
  如果堆中不存在,则在池中创建该字符串并返回其引用

String s1 = "Hello";
String s2 = new String("Hello");
String s3 = s2.intern();
System.out.println("s1 == s3? " + (s1 == s3));// true

String的常见API

length();//计算字符串的长度

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

getChars();//截取多个字符

equals();//比较两个字符串

equalsIgnoreCase();//比较两个字符串,忽略大小写

startsWith();//startsWith()方法决定是否以特定字符串开始

endWith();//方法决定是否以特定字符串结束

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

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

lastIndexOf();//查找字符或者子串是后一次出现的地方。

substring();//截取字符串

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

concat();//连接两个字符串

replace();//替换

trim();//去掉起始和结尾的空格

valueOf();//转换为字符串

toLowerCase();//转换为小写

toUpperCase();// 转换为大写

如何将字符串反转？

使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

示例代码：

// StringBuffer reverse
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("abcdefg");
System.out.println(stringBuffer.reverse()); // gfedcba
// StringBuilder reverse
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("abcdefg");
System.out.println(stringBuilder.reverse()); // gfedcba

重载和重写的区别

  重载:发生在同一类中,方法名相同,参数类型,返回值,个数,访问权限修饰符可以不同,发生在编译时
  重写:发生在父类中,方法名,参数列表必须相同,返回值范围与抛出的异常小于等于父类,访问权限修饰符大于等于父类,如果父类方法为private则子类不能重写该方法

String 和 StringBuffer、StringBuilder 的区别是什么？String 为什么是不可变的？

  String类中使用final关键字字符数组来保存字符串,所以String对象或常量是不可变的,且线程安全
  而StringBuffer和StringBuilder都继承自AbstractStringBuilder类,AbstractStringBuilder中也是使用字符数组来保存,但没有用final关键字修饰,所以可变

  StringBuffer对方法或调用的方法加了同步锁,所以线程安全
   StringBuild没有对方法加同步锁,所以非线程安全

使用:
  操作少量数据使用String
  单线程操作大量数据使用 StringBuilder 线程不安全,不同步,效率高
  多线程操作大量数据使用 StringBuffer 线程安全,同步,效率低

自动装箱与拆箱

  装箱: 将基本数据类型用引用类型包装起来
  拆箱: 将包装类型转为基本数据类型

==与equals

  ==:基本类型比较的是值,引用类型比较的是地址
  equals:重写前比较的是地址,重写后比较的是值

this关键字

this关键字是引用当前对象的引用变量。 它可以用于引用当前类属性，如实例方法，变量，构造函数等。它也可以作为参数传递给方法或构造函数。 也可以作为当前类实例从方法返回。

• this可以用来引用当前的类实例变量。
• this可以用来调用当前的类方法（隐式）
• this()可用于调用当前的类构造函数。
• this可以作为方法调用中的参数传递。
• this可以作为构造方法调用中的参数传递。
• this可以用于从方法返回当前类实例。

super关键字

super关键字是引用变量，用于引用父类对象。 无论何时创建子类的实例，都会隐式创建父类的实例，该实例由父类引用变量引用。 如没有super或this这俩关键字，编译器则隐式地在类构造函数中调用super()

• super可用于引用直接父类实例变量
• super可用于调用直接父类方法
• super()可用于调用直接父类构造函数

this和super的区别：

super始终指向父类上下文，而this始终指向当前类上下文。
super主要用于初始化子类构造函数中的基类变量，而this主要用于在类构造函数中传递时区分本地变量和实例变量。
super和this必须是构造函数中的第一个语句，否则编译器将抛出错误。

final关键字

作用于:变量,方法,类

 final变量: 表示常量，只能被赋值一次，赋值后值不再改变
     基本数据类型的变量,初始化后就不能更改;引用类型则初始化后不会再指向另外对象,但内容是可变的
 final方法: 1. 无法被重写,将方法锁定,以防继承的类修改其含义
      2. 效率,以前需要,现在则不用final来优化,类中所有private方法都隐式指定为final
 final类: 无法被继承,所有成员方法都会被隐式为final方法

空白final变量
未在声明时初始化的最终变量称为final空白变量。final空白变量可以直接赋值初始化。 也可以使用类构造函数初始化它。 当用户具有一些不得被其他人更改的数据时，例如：身份号码

Object常见方法

public final native Class<?> getClass()
//native方法，用于返回当前运行时对象的Class对象，使用了 final关键字修饰，故不允许子类重写。

public native int hashCode() 
//native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的 HashMap。

public boolean equals(Object obj)
//用于比较2个对象的内存地址是否相等，String类对该方法进行了重写用户 比较字符串的值是否相等。 

protected native Object clone() throws CloneNotSupportedException
//naitive方法，用于创建并返回 当前对象的一份拷贝。
//一般情况下，对于任何对象 x，表达式 x.clone() != x 为true，x.clone().getClass() == x.getClass() 为true。
//Object本身没有实现Cloneable接口，所以不重写clone方法并且进行调用的话会发生 CloneNotSupportedException异常。

public String toString()
//返回类的名字@实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个方 法。

public final native void notify()
//native方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视 器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。

public final native void notifyAll()
//native方法，并且不能重写。跟notify一样，唯一的区别就是会唤醒 在此对象监视器上等待的所有线程，而不是一个线程。 

public final native void wait(long timeout) throws InterruptedException
//native方法，并且不能 重写。暂停线程的执行。注意：sleep方法没有释放锁，而wait方法释放了锁 。timeout是等待时间。
 
public final void wait(long timeout, int nanos) throws InterruptedException
//多了nanos参数， 这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。 所以超时的时间还需要加上nanos毫秒。 

public final void wait() throws InterruptedException
//跟之前的2个wait方法一样，只不过该方法一直等 待，没有超时时间这个概念 

protected void finalize() throws Throwable { }
//实例被垃圾回收器回收的时候触发的操作

访问权限修饰符

主要标示修饰块的作用域，方便隔离防护
public： 被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。

protected: 只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。

default：“默认访问模式“。只允许在同一个包中进行访问。

private: 只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。

拷浅贝和深拷贝区别

浅拷贝
  复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化,
  传递地址指向，新的对象并没有对引用数据类型创建内存空间
深拷贝
  将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变
  对引用数据类型的成员变量的所有的对象都开辟了内存空间

异常

Throwable类有两个子类Exception(异常)和Error(错误)
  Exception(异常): 程序可以处理的异常
  Erroe(错误): 程序无法处理

Throeable类常用方法

public String getMessage():返回异常发生时的详细信息
public String toString():返回异常发生时的简要描述
public String getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可
以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

try块: 用于发现异常,后面可接多个catch块,没有catch块则必须跟finally块
cache块: 用于处理try发现的异常
finally块: 无论如何都会执行,当try或cache中有return时,finally会在方法返回之前执行
 finally不会执行的情况:

• finally语句块异常
• 前面代码中system.exit(0)退出程序或system.exit(1)结束虚拟机
• 程序所在线程死亡
• 关闭CPU

throw 和 throws 的区别？
throw 声明一个方法可能抛出的所有异常信息，
throws 声明但是不处理，而是将异常往上传，谁调用就交给谁处理。而throw则是指抛出的一个具体的异常类型

常见的异常类有哪些？

NullPointerException：空指针,当应用程序试图访问空对象时，则抛出该异常。

ClassCastException：类型转换异常,当试图将对象强制转换为不是实例的子类时，抛出该异常。

IllegalArgumentException：传递非法参数异常,抛出的异常表明向方法传递了一个不合法或不正确的参数。

IndexOutOfBoundsException：索引越界,指示某排序索引（例如对数组、字符串的排序）超出范围时抛出。 

NumberFormatException：数字格式异常,试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时抛出该异常

SQLException：提供关于数据库访问错误或其他错误信息的异常。

FileNotFoundException：当试图打开指定路径名表示的文件失败时，抛出此异常。

IOException：当发生某种I/O异常时，抛出此异常。此类是失败或中断的I/O操作生成的异常的通用类。

ArrayStoreException：试图将错误类型的对象存储到一个对象数组时抛出的异常。

ArithmeticException：当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。 

NegativeArraySizeException：如果应用程序试图创建大小为负的数组，则抛出该异常。

NoSuchMethodException：无法找到某一特定方法时，抛出该异常。

SecurityException：由安全管理器抛出的异常，指示存在安全侵犯。

UnsupportedOperationException：当不支持请求的操作时，抛出该异常。

RuntimeExceptionRuntimeException：是那些可能在Java虚拟机正常运行期间抛出的异常的超类。

常见Error

StackOverflowError: 深递归导致栈被耗尽而抛出的异常

OutOfMemoryError: 内存溢出异常

NoClassDefFoundError: 找不到class定义的异常 ,类找不到依赖的class或jia;依赖存在,但在不同域;大小写问题

final、finally、finalize 有什么区别？

• final 关键字,修饰变量成常量
• finally 作用在try-catch代码块中,释放内存资源
• finalize Object的垃圾回收方法,由垃圾回收器重写,调用

获取用键盘输入常用的的两种方法

1.通过Scanner

Scanner input = new Scanner(System.in);
String s = input.nextLine():
input.close;

2.通过BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
String s = input.readLine();

接口和抽象类的区别?

1.接口的方法默认是public abstract,java8前方法在接口不能有实现,8开始有普通方法,但必须是加static静态或default修饰表示新拓展,抽象类的方法可以是任意访问修饰符
2.接口中的实例变量 默认是public static final修饰,抽象类中则不一定
3.一个类可以实现多个接口,而抽象类只能实现一个
4.实现接口要实现接口中的所有方法,抽象类则不一定
5.接口不能new实例化,但可以声明,但必须引用一个实现该接口的对象
6.构造函数：抽象类可以有构造函数；接口不能有
7.main 方法：抽象类可以有 main 方法，并且我们能运行它；接口不能有 main 方法
8.接口只能做方法声明，抽象类中可以做方法声明，也可以做方法实现

泛型

面向对象的转型只会发生在具有继承关系的父子类中（接口也是继承的一种）
向上转型：其核心目的在于参数的统一上，根本不需要强制类型转换。
向下转型：是为了操作子类定义的特殊功能，需要强制类型转换，
可是现在存在的问题是：向下转型其实是一种非常不安全的操作，以为编译的时候，程序不会报错，而在运行的时候会报错，这就是传说中的—迷之报错。

在JDK1.5之后，新增加了泛型的技术，这就将上述向下转型的问题消灭在了萌芽之中。

泛型的核心意义在于：
类在进行定义的时候可以使用一个标记，此标记就表示类中属性或者方法以及参数的类型，标记在使用的时候，才会去动态的设置类型

List、List