Java核心基础知识(持续更新)

集合

collection相关

hashmap

jdk1.8的新特性

Lamdba表达式
Stream流
方法引用(::)
函数式接口(@FunctionalInterface)
接口允许default方法和static方法
Optional类
字符串拼接利器-StringJoiner
CompletableFuture类
LocalDateTime类

Collection和Collections区别

https://blog.csdn.net/xiaowanzi_zj/article/details/125775533

finally和return的执行顺序

https://blog.csdn.net/xiaowanzi_zj/article/details/125921219

形参和实参

实际参数是调用有参方法的时候真正传递的内容，而形式参数是用于接收实参内容的参数。

public static void main(String[] args) {
  ParamTest pt = new ParamTest();
  pt.sout("xxxx");//实际参数为 xxxx
}

public void sout(String name) { //形式参数为 name
  System.out.println(name);
}

Java有什么特点

简单易学（Java语言的语法与C语言和C++语言很接近）
面向对象（封装，继承，多态）
平台无关性（Java虚拟机实现平台无关性）
支持网络编程并且很方便（Java语言诞生本身就是为简化网络编程设计的）
支持多线程（多线程机制使应用程序在同一时间并行执行多项任）
健壮性（Java语言的强类型机制、异常处理、垃圾的自动收集等）
安全性

switch是否能作用在 byte 上,是否能作用在 long 上,是否能作用在String上

在 Java 5 以前,switch(expr)中,expr 只能是 byte、short、char、int。从 Java5 开始，Java 中引入了枚举类型,expr也可以是 enum 类型,从Java7开始,expr 还可以是字符串(String),但是长整型（long）在目前所有的版 本中都是不可以的。

用最有效率的方法计算 2 乘以 8

2 << 3（左移 3 位相当于乘以 2 的 3 次方，右移 3 位相当于除以 2 的 3 次 方）

Java语言采用何种编码方案？有何特点？

Java语言采用Unicode编码标准，Unicode（标准码），它为每个字符制订了一 个唯一的数值，因此在任何的语言，平台，程序都可以放心的使用。

Java注释

单行注释 格式： // 注释文字
多行注释 格式： /* 注释文字 */
文档注释 格式：/** 注释文字 */

Java中的多态是什么

就是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
Java中多态其实是一种运行期的状态。为了实现运行期的多态，或者说是动态绑定。
需要满足三个条件：

• 有类继承或者接口实现
• 子类要重写父类的方法
• 父类的引用指向子类的对象

public class Parent{
    
    public void call(){
        sout("im Parent");
    }
}

public class Son extends Parent{// 1.有类继承或者接口实现
    public void call(){// 2.子类要重写父类的方法
        sout("im Son");
    }
}

public class Daughter extends Parent{// 1.有类继承或者接口实现
    public void call(){// 2.子类要重写父类的方法
        sout("im Daughter");
    }
}

public class Test{
    
    public static void main(String[] args){
        Parent p = new Son(); //3.父类的引用指向子类的对象
        Parent p1 = new Daughter(); //3.父类的引用指向子类的对象
    }
}

封装继承多态之间的区别

封装:

所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承:
继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。继承的过程，就是从一般到特殊的过程。

多态:
指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。最常见的多态就是将子类传入父类参数中，运行时调用父类方法时通过传入的子类决定具体的内部结构或行为。

面向对象和面向过程区别

面向过程：
把需要解决的问题分解成一个一个步骤，每个步骤用函数实现，依次调用即可。
面向对象：
把需要解决的问题分解成一个一个步骤，对每个步骤进行相应的抽象，形成对象，通过不同对象之间的调用，组合解决问题。

面向对象的五大基本原则

https://blog.csdn.net/xiaowanzi_zj/article/details/126914321

单一职责原则
​​​​接口隔离原则
依赖倒置原则
开放封闭原则
里氏替换原则

过滤器和拦截器区别

https://blog.csdn.net/xiaowanzi_zj/article/details/123490371

Java8中foreach()不能break,怎么办

https://blog.csdn.net/xiaowanzi_zj/article/details/122969725

throw和throws的区别

https://blog.csdn.net/xiaowanzi_zj/article/details/123194818

拆箱和装箱

https://blog.csdn.net/xiaowanzi_zj/article/details/122465712

==和equals的区别

== 是java提供的等于比较运算符,用来比较两个变量(基本类型是比较值)指向的内存地址是否相同.而equals()是Object提供的一个方法.Object中equals()方法的默认实现就是返回两个对象==的比较结果.但是equals()可以被重写,所以我们在具体使用的时候需要关注equals()方法有没有被重写。

抽象类能使用final修饰吗？

不能,定义抽象类就是让其他类继承的,如果定义为 final 该类就不能被继承,这样彼此就会产生矛盾,所以 final 不能修饰抽象类。

如何实现数组和 List 之间的转换 

List转换成为数组：调用ArrayList的toArray方法。
数组转换成为List：调用Arrays的asList方法。 

https://blog.csdn.net/xiaowanzi_zj/article/details/122183040

String str="i"与 String str=new String("i")一样吗

不一样，因为内存的分配方式不一样。String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String("i") 则会被分到堆内存中。

创建一个对象用什么关键字？对象实例与对象引用有何不同？

new关键字，new创建对象实例（对象实例在堆内存中），对象引用指向对象实 例（对象引用存放在栈内存中）。一个对象引用可以指向0个或1个对象（一根 绳子可以不系气球，也可以系一个气球）;一个对象可以有n个引用指向它（可以 用n条绳子系住一个气球）

java 中 IO 流分为几种

按功能来分：输入流（input）、输出流（output）
按类型来分：字节流和字符流
字节流和字符流的区别是：字节流按 8 位传输以字节为单位输入输出数据，字符流按 16 位传输以字符为单位输入输出数据。
五个类一个接口：File、OutPutStream、InputStream、Writer、Reader;接口是Serializable

数组

运算符

https://blog.csdn.net/xiaowanzi_zj/article/details/121690155

运算符优先级

https://blog.csdn.net/xiaowanzi_zj/article/details/122098699

类的加载顺序

https://blog.csdn.net/xiaowanzi_zj/article/details/116464265

面向对象的思想

做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情

函数式编程思想

只要能获取到结果,谁去做的,怎么做的都不重要,重视的结果,不重视过程

如何判断链表出现死循环

1.对链表访问的每个元素做个标记(修改链表数据结构,增加一个标识),遍历链表,如果遇到已经标记过的元素,则说明链表存在循环。
2.建立一个动态数组,访问每个元素,然后存储在数组中。检查每一个后续的元素,然后从头查找这个数组,检查是否存在数组中。

https://blog.csdn.net/xiaowanzi_zj/article/details/122059529

静态变量和实例变量的区别

静态变量存储在方法区,属于类所有。实例变量存储在堆当中,其引用存在当前线程栈。

代码中如何实现多态

接口实现、继承父类重写方法、同一类中进行方法重载

重写和重载的区别

重载： 发生在同一个类中,方法名必须相同,参数类型不同、个数不同、顺序不同,方法返回值和访问修饰符可以不同,发生在编译时,属于编译时多态。

重写： 发生在父子类中,方法名、参数列表必须相同,返回值范围小于等于父类,抛出的异常范围小于等于父类,访问修饰符范围大于等于父类;父类方法访问修饰符为private则子类就不能重写该方法。属于运行时多态。

重载

重写

验证访问修饰符

 

异常类型 

Final关键字

修饰类不能被继承、修饰方法不能被重写、修饰变量只能赋值一次以后不能被修改。

final finally finalize区别

final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修 饰变量表示该变量是一个常量不能被重新赋值。

finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法 finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代 码。

finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾 回收器来调用，当我们调用System.gc() 方法的时候，由垃圾回收器调用finalize()，回收垃圾，一 个对象是否可回收的最后判断。

接口和抽象类的区别

this与super的区别

super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函
数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）

this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的
形参与类中的成员数据同名，这时需用this来指明成员变量名）

super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其
它构造方法。

super()和this()均需放在构造方法内第一行。

尽管可以用this调用一个构造器，但却不能调用两个。

this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造
函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意
义，编译器也不会通过。

this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：
static变量,static方法，static语句块。

从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

static

1、修饰成员变量
2、修饰成员方法
3、静态代码块
4、修饰类【只能修饰内部类也就是静态内部类】
5、静态导包

static注意事项(1、静态只能访问静态。 2、非静态既可以访问非静态的,也可以访问静态的.)

接口

抽象类

成员变量与局部变量区别

1.成员变量是属于类的,局部变量是属于方法的

2.从变量在内存中的存储方式来看,成员变量是对象的一部分,而对象存在于堆内存,局部变量存在于栈内存

3.从变量在内存中的生存时间上看,成员变量是对象的一部分,它随着对象的创建而存在,而局部变量随着方法的调用而自动消失。

4.成员变量可以被public,private,static等修饰符所修饰,而局部变量不能被访问控制修饰符及static所修饰

5.成员变量和局部变量都能被final所修饰；

6.成员变量没有初始值可以自动赋初始值(被final修饰但没有被static修饰的成员变量必须显示地赋值),局部变量不会自动赋值

静态变量和实例变量区别

静态变量： 静态变量由于不属于任何实例对象，属于类的，所以在内存中只会 有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间。
实例变量： 每次创建对象，都会为每个对象分配成员变量内存空间，实例变量 是属于实例对象的，在内存中，创建几次对象，就有几份成员变量。

静态变量与普通变量区别

static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有 的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始 化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副 本，各个对象拥有的副本互不影响。
还有一点就是static成员变量的初始化顺序按照定义的顺序进行初始化。

静态方法和实例方法有何不同？

静态方法和实例方法的区别主要体现在两个方面：
1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使 用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调 用静态方法可以无需创建对象。
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量 和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此 限制

对象的相等与指向他们的引用相等,两者有什么不同？

对象的相等比的是内存中存放的内容是否相等而引用相等比较的是他们指向的内存地址是否相等。

在Java中,如何跳出当前的多重嵌套循环

数据类型

基本数据类型(数值型(整数类型/浮点类型)/字符型/布尔型)/引用数据类型

引用数据类型:类、接口、数组

字符型常量和字符串常量的区别

1. 形式上: 字符常量是单引号引起的一个字符 字符串常量是双引号引起的若干个字符
2. 含义上: 字符常量相当于一个整形值(ASCII值),可以参加表达式运算 字符串常量代表一个地址值(该字符串在内存中存放位置)
3. 占内存大小 字符常量只占一个字节 字符串常量占若干个字节(至少一个字符结束标志)

什么是字符串常量池

Jdk1.6及之前： 有永久代, 运行时常量池在永久代，运行时常量池包含字符串常量池
Jdk1.7：有永久代，但已经逐步“去永久代”，字符串常量池从永久代里的运行时常量池分离到堆里
Jdk1.8及之后： 无永久代，运行时常量池在元空间，字符串常量池里依然在堆里

String真的是不可变的吗？

我觉得如果别人问这个问题的话,回答不可变就可以了。 下面只是给大家看两个有代表性的例子：

1) String不可变但不代表引用不可以变

String str = "Hello";
str = str + " World";
System.out.println("str=" + str);

结果：

str=Hello World

 解析：
实际上,原来String的内容是不变的，只是str由原来指向"Hello"的内存地址转为指向"Hello World"的内存地址而已，也就是说多开辟了一块内存区域给"Hello World"字符串。

2) 通过反射是可以修改所谓的“不可变”对象

//创建字符串"Hello World"， 并赋给引用s
String s = "Hello World";
System.out.println("s = " + s); // Hello World
// 获取String类中的value字段
Field valueFieldOfString = String.class.getDeclaredField("value");
// 改变value属性的访问权限
valueFieldOfString.setAccessible(true);
// 获取s对象上的value属性的值
char[] value = (char[]) valueFieldOfString.get(s);
// 改变value所引用的数组中的第5个字符
value[5] = '_';
System.out.println("s = " + s); // Hello_World

结果：

s = Hello World
s = Hello_World

解析：
用反射可以访问私有成员， 然后反射出String对象中的value属性， 进而改变通过获得的value引用改变数组的结构。但是一般我们不会这么做，这里只是简单提一下有这个东西。

数组有没有length()方法？String有没有length()方法

数组没有 length()方法 ，有 length 的属性。String 有 length()方法。 JavaScript中，获得字符串的长度是通过 length 属性得到的，这一点容易和 Java 混淆。

在使用HashMap的时候,用String做key有什么好处？

HashMap 内部实现是通过 key 的 hashcode 来确定 value 的存储位置，因为字符串是不可变的，所以当创建字符串时,它的 hashcode 被缓存下来,不需要再次计算,所以相比于其他对象更快。

Integer a= 127 与 Integer b = 127相等吗

对于对象引用类型：==比较的是对象的内存地址。
对于基本数据类型：==比较的是值。如果整型字面量的值在-128到127之间，那么自动装箱时不会new新的Integer 对象，而是直接引用常量池中的Integer对象，超过范围 a1==b1的结果是false

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比较
  System.out.println(b == c); // true
  Integer a1 = 128;
  Integer b1 = 128;
  System.out.println(a1 == b1); // false
  Integer a2 = 127;
  Integer b2 = 127;
  System.out.println(a2 == b2); // true
}

a=a+b与a+=b有什么区别

+=操作符会进行隐式自动类型转换,此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型,而a=a+b则不会自动进行类型转换

3*0.1==0.3返回值是什么

false,因为有些浮点数不能完全精确的表示出来。

验证实验

&和&&的区别

&运算符有两种用法：(1)按位与；(2)逻辑与。&&运算符是短路与运算。逻辑或运算符（|）和短路或运算符（||）的差别也是如此。 

Switch中兼容的数据类型

java支持的数据类型有5种,分别是byte,int,short,char,enum,JDK1.7中新增了String

Object类常用的方法

 equals()/Hashcode()/toString()/wait()/notify()/clone()/getClass()/notifyAll()/finalize()

String类的常用方法

split()/subString()/equals()/hashCode()/indexOf()/lastIndexOf()/startsWith()/endsWith()/concat()/replace()/contains()/toLowerCase()/toUpperCase()/toString()/valueOf()/copyValueOf()/format()/trim()

获取反射的机制

1.通过Object类的getClass方法
2.通过对象实例方法获取对象
3.通过Class.forName方式
核心类:Class、Filed、Method、Constructor

package base;
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        Student stu = new Student();
        Class stu1 = stu.getClass();
        Class stu2 = Class.forName("base.Student");
        Class stu3 = Student.class;
    }
}

创建对象的方式

1.使用new关键字
2.使用Class类的newInstance()方法
3.使用clone方法
4.使用Constructor类的newInstance()方法
5.使用序列化 
6.FactoryBean的getObject()方法

package base;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
public class ObjectDemo {
    public static void main(String[] args) throws Exception {
        Student stu = new Student();

        Student stu1 = (Student)Class.forName("base.Student").newInstance();
        Student stu2 = Student.class.newInstance();

        Constructor constructor = Student.class.getConstructor();
        Student stu3 = constructor.newInstance();

        Student stu4 = (Student)stu.clone();

        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.obj"));
        out.writeObject(stu);
        out.close();
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
        Student stu5 = (Student) in.readObject();
        in.close();
    }
}

String和StringBuffer和StringBuilder

1.string在1.8以前是final定义的char数组,1.9的时候是final定义的byte数组
2.Buffer和Builder的char数据,Buffer线程安全Builder不是线程安全 

Servlet的声明周期

init()/service/destory() 

Java中XML解析方式

DOM/SAX/JDOM/DOM4J 

九大内置对象

request/response/session/config/application/page/pagecontext/exception/out 

异常

https://blog.csdn.net/xiaowanzi_zj/article/details/120544542

基本类型和引用类型区别

 基本数据类型：byte、short、int、long、float、double、char、boolean
引用类型：类(class)、接口(interface)、数组(array)
基本类型保存的值,引用类型保存了是对象的地址,所有基本类型赋值是按值传递(拷贝赋值)引用类型赋值是按引用传递。对比于C++就是&符号。

基本类型和包装类的区别

包装类是一个类可以调用类的方法

基本数据类型和对应封装类如果你只是想使用他们具体的赋值,他们之间本质上是没有区别的.如果你不单单想用一个赋值,是想用里面的方法解决许多繁琐的问题.那就使用封装类吧.因为封装类就是在基本类型不够用的的基础上一出来的.封装类提供了许多的方法供君选择.它可以简化程序员的敲代码的量

 Integer取值范围

Integer类取值和int类型取值一致,取值范围是从-2147483648至2147483647(-231至 231-1),包括-2147483648和 2147483647。但是对于Integer类java为了提高效率,初始化了-128--127之间的整数对象,因此Integer类取值-128--127的时候效率最高。

 注解

https://blog.csdn.net/xiaowanzi_zj/article/details/121259878#

为什么JDK动态代理中要求目标类实现的接口数量不能超过65535个 

https://blog.csdn.net/xiaowanzi_zj/article/details/121154155

isAssignableFrom和instanceof的区别

https://blog.csdn.net/xiaowanzi_zj/article/details/121346317

Java的内部类

https://blog.csdn.net/xiaowanzi_zj/article/details/121893431

Integer和int的区别,Java为什么要设计封装类

Integer和int的区别有很多，我简单说3个方面

• Integer的初始值是null，int的初始值是0
• Integer存储在堆内存，int类型是直接存储在栈空间
• Integer是对象类型，它封装了很多的方法和属性，我们在使用的时候更加灵活。

至于为什么要设计封装类型，最主要的原因是Java本身是面向对象的语言，一切操作都是以对象作为基础。比如像集合里面存储的元素，也只支持存储Object类型，普通类型无法通过集合来存储。