java基础

基础

语言概述

C语言:

• 极好的福利：贴近硬件， 运行极快， 效率极高。
• 两个沉重的枷锁： 指针和内存管理

c++:

​ 太复杂。 图形和游戏领域表现好

java：

​ 为了实现跨平台， 我们在操作系统和应用程序之间增加了一个抽象层： Java 虚拟机

​ java 2 标准版(J2SE)： 去占领桌面
​ Java 2 移动版(J2ME)： 去占领手机
​ Java 2 企业版(J2EE)： 去占领服务器 ( 【三高：高可用，高性能，高并发】 )

​ JAVA的成功除了自己具备跨平台特性外，更重要的是正好踩中了互联网发展的节奏。微软的成功除了windows好用外，也是正好踩中了个人电脑发展的节奏。

计算机的高级编程语言类型:

• 编译型 : 程序执行速度快。因此像开发操作系统、大型应用程序、数据库系统等时都采用它，像C/C++
• 解释型.： 而一些网页脚本、服务器脚本及辅助开发接口这样
  的对速度要求不高、对不同系统平台间的兼容性有一定要求的程序则通常使用解释性语言，如Java、
  JavaScript、Python等等。

​ Java 语言是两种类型的结合；

​ java用Unicode

​ Java是一种强类型语言，每个变量都必须声明其类型。

面试题

比较javascript 和 java

JavaScript 与 Java 是两个公司开发的不同的两个产品。Java 是原 SunMicrosystems 公司推出的面向对象的程序设计语言，特别适合于互联网应用程序开发；而 JavaScript 是 Netscape 公司的产品，为了扩展 Netscape 浏览器的功能而开发的一种可以嵌入 Web 页面中运行的基于对象和事件驱动的解释性语言。JavaScript 的前身是 LiveScript；而 Java 的前身是 Oak 语言。

下面对两种语言间的异同作如下比较：

（1）基于对象和面向对象：Java 是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象；JavaScript 是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（Object-Based）和事件驱动（Event-Driven）的编程语言，因而它本身提供了非常丰富的内部对象供设计人员使用。

（2）解释和编译：Java 的源代码在执行之前，必须经过编译。JavaScript 是一种解释性编程语言，其源代码不需经过编译，由浏览器解释执行。（目前的浏览器几乎都使用了 JIT（即时编译）技术来提升 JavaScript 的运行效率）

（3）强类型变量和类型弱变量：Java 采用强类型变量检查，即所有变量在编译之前必须作声明；JavaScript 中变量是弱类型的，甚至在使用变量前可以不作声明，JavaScript 的解释器在运行时检查推断其数据类型。

（4）代码格式不一样。

补充：上面列出的四点是网上流传的所谓的标准答案。其实 Java 和 JavaScript最重要的区别是一个是静态语言，一个是动态语言。目前的编程语言的发展趋势是函数式语言和动态语言。在 Java 中类（class）是一等公民，而 JavaScript 中函数（function）是一等公民，因此 JavaScript 支持函数式编程，可以使用 Lambda函数和闭包（closure），当然 Java 8 也开始支持函数式编程，提供了对 Lambda表达式以及函数式接口的支持。对于这类问题，在面试的时候最好还是用自己的语言回答会更加靠谱，不要背网上所谓的标准答案。

字符编码表

• ASCII (一个字节表示, 一个128个字符，实际上一个字节可以表示256个字符,只用128个)

• Unicode (两个字节来表示字符，字母和汉字统都是占用两个字节，
  这样浪费空间)

  不会有乱码现象

  兼容ASCII码

• utf-8 (对unicode改进，大小可变的编码，字母使用1个字节，汉字使用3个字节)

• gbk (可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节)

• gb2312 (可以表示汉字，gb2312 < gbk)

• big5码(繁体中文台湾，香港）

怎样将 GB2312 编码的字符串转换为 ISO-8859-1 编码的字符串？

String s1 = "你好";
String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");

转义和注释

转义

\r 和 \n 不一样

// 	/r是回车，\n换行
//  遇到换行时，光标移动到最前面，然后换行后的字符替代当前光标内容
public class ChangeChar{
	public static void main(String[] args) {
		System.out.println("1234 \r9"); //9234
		System.out.println("3\n4");
	}
}

文档注释

javadoc -d (文档保存路径) [-xx] [-yy] (java文件)

JUnit

java单元测试

如果执行@Test。执行顺序，先@Before，再@Test，后@After

即使@Test抛出异常，@Before和@After里面代码块依旧会执行

@Test
public void m1() {
	System.out.println("m1 方法被调用");
}

@Before
public void init() {
	System.out.println("初始化资源");
}

@After
public void After() {
	System.out.println("关闭资源");
}

自增

面试题

int i = 1;
i = ++i;
System.out.println(i);   //i为2

    
int i = 1;
i = i++;
System.out.println(i);   //i为1

【解析】

==========  i=++i; 底层 
(1) i=i+ 1;
(2) temp=i;
(3) i=temp:

=========== i=i++；底层    
_temp = i;
i = i + 1;
i = _temp;

==========类似
   int y = x++
底层源码：    
_temp = x;  
x = x + 1;  
y = _temp;

可变参数

• 可变参数的实参可以为0个或任意多个。实参可以为数组。

• 可变参数的本质就是数组.

• 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

• 一个形参列表中只能出现一个可变参数

  下面写法错误

  public void f3(int… nums1, double… nums2) { }

正则表达式

1. 正则表达式：定义字符串的组成规则。

2. 单个字符:[]
   如： [a] [ab] [a-zA-Z0-9_]
   特殊符号代表特殊含义的单个字符:
   \d:单个数字字符 [0-9]
   \w:单个单词字符[a-zA-Z0-9_]

3. 量词符号：
   ?：表示出现0次或1次
   *：表示出现0次或多次
   +：出现1次或多次
   {m,n}:表示 m<= 数量 <= n

   • m如果缺省： {,n}:最多n次
   • n如果缺省：{m,} 最少m次

4. 开始结束符号

• ^:开始
• $:结束

5. 正则对象：
6. 创建
7. var reg = new RegExp(“正则表达式”);
8. var reg = /正则表达式/;
9. 方法
10. test(参数):验证指定的字符串是否符合正则定义的规范

基本功

进制

二进制：以0b 或0B 开头。
十进制：
八进制：以数字0 开头表示。
十六进制： 以0x 或0X 开头表示。此处的A-F 不区分大小写

原、反、补码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tRH6nulx-1645968588651)(D:\09__my-JAVA\学习笔记\java基础.assets\image-20210423123914671.png)]

位运算符

java 中有7 个位运算(&、|、^、~、>>、<<和>>>)

1）算术右移>>：符号位不变,并用符号位补溢出的高位
2) 算术左移<<: 符号位不变,低位补0
3) >>> 逻辑右移也叫无符号右移,运算规则是**: 高位补0**
4) 特别说明：没有<<< 符号

静态导入

好处：简化操作（建议在有很多重复调用的时候使用）

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        //之前是需要Math.random()调用的
        System.out.println(random());
        System.out.println(PI);
    }
}

Lambda

概述

• Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。
• Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法。
• jdk 8 中有另一个新特性：default， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。

语法

语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符

代码示例

/**无参无返回值*/
@FunctionalInterface
public interface NoReturnNoParam {
    void method();
}
		 //无参无返回
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println("NoReturnNoParam");
        };
        noReturnNoParam.method();

/**一个参数无返回*/
@FunctionalInterface
public interface NoReturnOneParam {
    void method(int a);
}
	 	//一个参数无返回
        NoReturnOneParam noReturnOneParam = (int a) -> {
            System.out.println(a);
        };
        noReturnOneParam.method(6);


/**多参数无返回*/
@FunctionalInterface
public interface NoReturnMultiParam {
    void method(int a, int b);
}
		//多个参数无返回
 		NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
            System.out.println( a+b);
        };
        noReturnMultiParam.method(6, 8);

//========= 有返回 =========
/*** 无参有返回*/
@FunctionalInterface
public interface ReturnNoParam {
    int method();
}
 			//无参有返回值
         	ReturnNoParam returnNoParam = () -> {
                System.out.print("ReturnNoParam");
                return 1;
            };
 			int res = returnNoParam.method();
        	System.out.println( res);

/**一个参数有返回值*/
@FunctionalInterface
public interface ReturnOneParam {
    int method(int a);
}

/**多个参数有返回值*/
@FunctionalInterface
public interface ReturnMultiParam {
    int method(int a, int b);
}

        //多个参数有返回值
		ReturnMultiParam returnMultiParam = (int a, int b) -> {
            System.out.println( a  + b );
            return 1;
        };

        int res3 = returnMultiParam.method(6, 8);
        System.out.println("return:" + res3);

简化

//1.简化参数类型，可以不写参数类型，但是必须所有参数都不写
    NoReturnMultiParam lamdba1 = (a, b) -> {
        System.out.println("简化参数类型");
    };
    lamdba1.method(1, 2);

//2.简化参数小括号，如果只有一个参数则可以省略参数小括号
    NoReturnOneParam lambda2 = a -> {
        System.out.println("简化参数小括号");
    };
    lambda2.method(1);

//3.简化方法体大括号，如果方法条只有一条语句，则可以省略方法体大括号
    NoReturnNoParam lambda3 = () -> System.out.println("简化方法体大括号");
    lambda3.method();

 //4.如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号
    ReturnOneParam lambda4 = a -> a+3;
    System.out.println(lambda4.method(5));

    ReturnMultiParam lambda5 = (a, b) -> a+b;
    System.out.println(lambda5.method(1, 1));

关键字

修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QP0FeDca-1645968588653)(java基础.assets/image-20210512104632611.png)]

this和super区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2txslOXR-1645968588655)(java基础.assets/image-20210512121646393.png)]

final

final可以修饰类、属性、方法和局部变量.

1. final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如下位置之一【(选择一个位置赋初值即可】:

• 定义时:如public final double TAX_RATE=0.08;
• 在构造器中
• 在代码块中。

2)如果final修饰的属性是静态的，则初始化的位置只能是

• 定义时
• 在静态代码块
• 不能在构造器中赋值。

3. final类不能继承,但是可以实例化对象。
   4)如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。

5)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

6. final不能修饰构造方法(即构造器)
   7)final和static往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理。
   8)包装类(Integer,Double,Float，Boolean等都是final),String也是final类。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EcJ1VCKx-1645968588656)(java基础.assets/image-20210517152521202.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uFLUfG3w-1645968588656)(java基础.assets/image-20210517152637549.png)]

finalize

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vd98Yirl-1645968588657)(java基础.assets/image-20210513154316755.png)]

易混淆

全局变量可以不赋值，有默认值。局部变量必须赋值

属性可加修饰符，局部变量不可以

接口可以继承接口，而且支持多重继承。抽象类可以实现(implements)接口，抽象类可继承具体类也可以继承抽象类。

匿名内部类可以继承其它类，可以实现其他接口

符号辨析

• &&与&和|| 与 |

  &&：短路运算

  eg： 例如，对于 if(str != null&& !str.equals(“”))表达式，当 str 为 null 时，后面的表达式不会执行，所以不会出现 NullPointerException

  如果将&&改为&，则会抛出 NullPointerException 异常。
  ​ &： 当&操作符两边的表达式不是 boolean 类型时， &表示按位与操作

• << 与 <<< (0填充空位)

  A = 0011 1100

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eJByKTF0-1645968588658)(java基础.assets/1612089791013.png)]

​ 右移一位相当于除2取商。右移n位相当于除2ⁿ取商

​ 左移一位相当于乘2。左移n位相当于x2 ⁿ
【常见面试题：int a=2*8怎样运算效率最快？】

​ 用 int a = 2<<3

length

数组没有 length()方法

JavaScript 和 数组有 length 的属性。

String 有 length()方法。

Scanner

• next():
  读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其去掉，只有在输入有效字符之后，next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。
• nextLine()：
  结束符只是Enter键，即nextLine()方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的.

Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
			scanner.next();
如果在控制台上输入” hello” ，则nextLine打印出来的是” hello”,而next是 “hello”,自动舍去了有效字符前的空格。

clone与copy的区别

Employee tobby =new Employee(“CMTobby”,5000)
Employee cindyelf=tobby

​ 只是简单了copy了一下reference， cindyelf和tobby都指向内存中同一个object，这样cindyelf或者tobby的一个操作都可能影响到对方。

​ 我们希望得到tobby的一个精确拷贝，同时两者互不影响，这时候， 我们就可以使用Clone来满足我们的需求

Employee cindy=tobby.clone()，

​ 这时会生成一个新的Employee对象，并且和tobby具有相同的属性值和方法。

Shallow Clone与Deep Clone

JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用

调用Clone()方法的对象所属的类(Class)必须implements Clonable接口，否则在调用Clone方法的时候会抛出CloneNotSupportedException

如何实现对象克隆？

有两种方式：

1). 实现 Cloneable 接口并重写 Object 类中的 clone()方法；

2). 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆

**注意：**基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用 Object 类的 clone 方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。

取模运算：异号时看第一个符号

​ 负数%负数＝负数；
​ 负数%正数＝负数；
​ 正数%负数＝正数；

重写和重载【辨析】

	区别点	重载 overloading	重写 overriding
1	定义	方法名称相同，参数的类型或个数不同	方法名称、参数的类型、返回值类型全部相同
2	权限	对权限没有要求	被重写的方法不能拥有比父类更加严格的权限
3	范围	发生在一个类中	发生在继承中

Integer比较

class AutoUnboxingTest {
	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比较
	}
}

public class Test03 {
	public static void main(String[] args) {
		Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
		System.out.println(f1 == f2); // T
		System.out.println(f3 == f4); // F
	}
}

简单的说，如果整型字面量的值在-128 到 127 之间，那么不会 new 新的 Integer对象，而是直接引用常量池中的 Integer 对象，所以上面的面试题中 f1f4 的结果是 false。

两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对？

不对，如果两个对象 x 和 y 满足 x.equals(y) == true，它们的哈希码（hash code）应当相同。Java 对于 eqauls 方法和 hashCode 方法是这样规定的：

(1)如果两个对象相同（equals 方法返回 true），那么它们的 hashCode 值一定要相同；

(2)如果两个对象的 hashCode 相同，它们并不一定相同。

当然，你未必要按照要求去做，但是如果你违背了上述原则就会发现在使用容器时，相同的对象可以出现在 Set 集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。

内部类可以引用它的包含类（外部类）的成员吗？有没有什么限制？

一个内部类对象可以访问创建它的外部类对象的成员，包括私有成员。

try{}里有一个 return 语句，那么紧跟在这个 try 后的finally{}里的代码会不会被执行，什么时候被执行，在 return前还是后?

会执行，在方法返回调用者前执行。

阐述 final、finally、finalize 的区别。

1） final：修饰符（关键字）有三种用法：如果一个类被声明为 final，意味着它不能再派生出新的子类，即不能被继承，因此它和 abstract 是反义词。将变量声明为 final，可以保证它们在使用中不被改变，被声明为 final 的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。被声明为 final 的方法也同样只能使用，不能在子类中被重写。

（2）finally：通常放在 try…catch…的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要 JVM 不关闭都能执行，可以将释放外部资源的代码写在 finally 块中.

（3）finalize：Object 类中定义的方法，Java 中允许使用 finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写 finalize()方法可以整理系统资源或者执行其他清理工作。

异常

抓取 ExampleA 类型异常的 catch 块能够抓住 try 块中抛出的 ExampleB 类型的异常）

抓到异常后就不再执行后面try

class ExampleA extends Exception {
}

class ExampleB extends ExampleA {
    public ExampleB(String s) {
        System.out.println(s);
    }
}

public class CatchOrder {
    public static void main(String[] args) throws ExampleB {
        try {
            throw new ExampleB("b");
        } catch(ExampleA e){
            System.out.println("ExampleA");
        }
        catch(Exception e){
            System.out.println("Exception");
        }
    }
}
输出  b
    ExampleA
  

数据类型

概述

java 数据类型分为两大类基本数据类型，引用类型

• 基本数据类型有8中―数值型[byte , short , int , long , float ,double] char , boolean
• 引用类型[类，接口，数组]

1字节: byte、boolean

2字节：char、short

4字节：int【默认】、float

8字节：long、double【默认】

整型细节

Java各整数类型有固定的范围和字段长度，不受具体OS[操作系统]的影响，以保证java程序的可移植性。

浮点数细节

1. 关于浮点数在机器中存放形式的简单说明

   ​ 浮点数=符号位+指数位+尾数位
   尾数部分可能丢失，造成精度损失(小数都是近似值)。

2. 浮点型常量有两种表示形式
   （1）十进制数形式:如:5.12 512.0f.512(必须有小数点)
   （2）科学计数法形式:如:5.12e2 [5.12*10的2次方]5.12E-2[5.12/10的2次方]

3. 通常情况下，应该使用double型，因为它比float型更精确。[举例说明]
   double num9 =2.1234567851;
   float num10 = 2.1234567851F; // 会丢失一些位数

4. 浮点数使用陷阱:2.7和8.1/3比较

   double num7=2.7;

   double num8=8.1/3; //2.9999…997他两不等

   当我们对运算结果是小数的进行相等判断是，要小心
   应该是以两个数的差值的绝对值，在某个精度范围类判断
   比较相等一般用

   Math.abs(num7 - num8)<0.00001

   如果是直接查询得的的小数或者直接赋值，是可以判断相等

字符类型

在java中,char的本质是一个整数，在输出时，是unicode码对应的字符。

可以直接给char赋一个整数，然后输出时,会按照对应的unicode字符输出[97-》a]
char类型是可以进行运算的,相当于一个整数，因为它都对应有Unicode码.

char 型变量中能不能存贮一个中文汉字，为什么？

char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。

补充：使用 Unicode 意味着字符在 JVM 内部和外部有不同的表现形式，在 JVM内部都是 Unicode，当这个字符被从 JVM 内部转移到外部时（例如存入文件系统中），需要进行编码转换。所以 Java 中有字节流和字符流，以及在字符流和字节流之间进行转换的转换流，如 InputStreamReader 和 OutputStreamReader，这两个类是字节流和字符流之间的适配器类，承担了编码转换的任务；

String

split方法

public static void count(String s){
    String srr [] = s.split(" ");
    for (int i = 0; i < srr.length; i++) {
        System.out.println("=="+srr[i]+"==");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rTLBL5Cc-1645968588660)(java基础.assets/image-20210606195225442.png)]

总结：左边有几个空格，split后就会存几个“”，最后的空格不论多少个都不记录

创建对象

（1）对象在方法区的常量池

​ String str="1 hello";//直接赋值的方式

（2）对象在堆内存

​ String str=new String("hello");//实例化的方式

【总结】

1. 直接赋值（String str = “hello”）：只开辟一块堆内存空间，并且会自动入池，不会产生垃圾。

2. 构造方法（String str= new String(“hello”);）:会开辟两块堆内存空间，其中一块堆内存会变成垃圾被系统回收，而且不能够自动入池，需要通过public String intern();方法进行手工入池。

   String str =new String("Lance").intern();//进行手工入池操作
   

3. 在开发的过程中不会采用构造方法进行字符串的实例化。

【== 和 equals】

​ String中==在对字符串比较的时候，对比的是内存地址。

​ equals比较字符串内容

测试题

intern

常量池不同值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-emAz2h55-1645968588661)(java基础.assets/image-20210621084005984.png)]

对象属性

对象创建问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KD1CWeM8-1645968588661)(java基础.assets/image-20210519161051442.png)]

【重点】执行方法会在栈中重新开辟一块空间

string vs stringbuffer

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jz5g9MCM-1645968588662)(java基础.assets/image-20210519172143219.png)]

String不可变好处

• 可以实现多个变量引用堆内存中的同一个字符串实例，避免创建的开销。
• 我们的程序中大量使用了String字符串，有可能是出于安全性考虑。
• HashMap中key为String类型，如果可变将变的多么可怕。
• 当我们在传参的时候，使用不可变类不需要去考虑谁可能会修改其内部的值，如果使用可变类的话，可能需要每次记得重新拷贝出里面的值，性能会有一定的损失。

【String、StringBuffer、StringBuilder之间的区别】

String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）
在大多数情况下三者在执行速度方面的比较：StringBuilder > StringBuffer > String

从1拼接到8万耗时
StringBuffer 的执行时间：50
StringBuilder 的执行时间：27
string 的执行时间：7215

对于三者使用的总结：
1）如果要操作少量的数据用 = String
2）单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3）多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

类型转化

自动转换（低精度-》高精度）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IGsiXKY2-1645968588663)(java基础.assets/image-20210422204706095.png)]

• (byte, short)和char之间不会相互自动转换。Boolean不参与转化
• byte, short, char他们三者可以计算，在计算时首先转换为int类型。

强制类型转换（高精度——》低精度）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ckzooTzv-1645968588664)(java基础.assets/image-20210422205414632.png)]

拆装箱

装箱：由基本类型向对应的包装类转换

拆箱：包装类向对应的基本类型转换

jdk1.5后课自动拆装箱（编译器帮忙）

int m = 0;
Integer obj = m; //自动装箱
int n = obj; //自动拆箱

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

【1、 实现 int 和 Integer 的相互转换】

int m = 500;
Integer obj = new Integer(m); // 手动装箱
int n = obj.intValue(); // 手动拆箱

基本类型和Stirng互转

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-du6FAPlx-1645968588665)(java基础.assets/image-20210422205842368.png)]

【面试题】

Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//F

Integer i5 = 127;//底层Integer.valueOf(127)
Integer i6 = 127;//-128~127
System.out.println(i5 == i6); //T

Integer i9 = 127; //Integer.valueOf(127)
Integer i10 = new Integer(127);
System.out.println(i9 == i10);//F

Integer i13=128;
int i14=128;
System.out.println(i13==i14);//T

short s1 = 1; s1 = s1 + 1;错

short s1 = 1; s1 += 1; 对

对于 short s1 = 1; s1 = s1 + 1;由于 1 是 int 类型，因此 s1+1 运算结果也是 int型，需要强制转换类型才能赋值给 short 型。

而 short s1 = 1; s1 += 1;可以正确编译，因为 s1+= 1;相当于 s1 = (short(s1 + 1);其中有隐含的强制类型转换。

Java 中如何实现序列化，有什么意义？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。

序列化是为了解决对象流读写操作时可能引发的问题（如果不进行序列化可能会存在数据乱序的问题）。要实现序列化，需要让一个类实现 Serializable 接口，该接口是一个标识性接口，标注该类对象是可被序列化的，然后使用一个输出流来构造一个对象输出流并通过 writeObject(Object)方法就可以将实现对象写出（即保存其状态）；如果需要反序列化则可以用一个输入流建立对象输入流，然后通过 readObject 方法从流中读取对象。序列化除了能够实现对象的持久化之外，还能够用于对象的深度克隆

构造器

• 构造器是完成对象的初始化，不是创建对象

• 显示定义构造器后，就不能用默认无参构造器，除非显示定义无参构造器

this（）可访问构造器：只能在构造器中访问另一个构造器，必须放在第一条语句位置

######构造器不能被继承，因此不能被重写，但可以被重载。

类加载

java内存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-toyre8X9-1645968588666)(java基础.assets/image-20210602092516723.png)]

解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法

通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用 JVM 中的栈空间；

通过 new 关键字和构造器创建的对象则放在堆空间

程序中的字面量（literal）如直接书写的 100、”hello”和常量都是放在常量池中，常量池是方法区的一部分

方法区和堆都是各个线程共享的内存区域，用于存储已经被 JVM 加载的类信息、常量、静态变量、JIT 编译器编译后的代码等数据

栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间

String str = new String("hello");

上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而”hello”这个字面量是放在方法区的。

补充 1：较新版本的 Java（从 Java 6 的某个更新开始）中，由于 JIT 编译器的发展和”逃逸分析”技术的逐渐成熟，栈上分配、标量替换等优化技术使得对象一定分配在堆上这件事情已经变得不那么绝对了。

补充 2：Java 语言并不要求常量一定只有编译期间才能产生，*运行期间也可以将新的常量放入池中，String类的 intern()*方法就是这样的。

看看下面代码的执行结果是什么并且比较一下 Java 7 以前和以后的运行结果是否一致。

1、类被加载的时机

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2odhfC7D-1645968588667)(java基础.assets/image-20210517102946779.png)]

2、同一个类中，先静态->普通->构造

一个类中，先静态的【先父后子】，【按照父和子类分别执行下面】再普通的，再构造

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cluf5hYU-1645968588668)(java基础.assets/image-20210517104603587.png)]

3、不同类中

父类静态，子类静态

父类普通、构造

子类普通、构造

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k7IMbTnd-1645968588669)(java基础.assets/image-20210517105330530.png)]

class AAA { //父类Object
    {
    	System.out.println("AAA 的普通代码块"); 
    }
    public AAA() {
        //(1)super()
        //(2)调用本类的普通代码块
        System.out.println("AAA() 构造器被调用....");
    }
}

class BBB extends AAA {
    {
    	System.out.println("BBB 的普通代码块...");
    }
    public BBB() {
        //(1)super()
        //(2)调用本类的普通代码块
        System.out.println("BBB() 构造器被调用....");
    }
}

public static void main(String[] args) {
	new BBB();//(1)AAA 的普通代码块(2)AAA() 构造器被调用(3)BBB 的普通代码块(4)BBB() 构造器被					调用
}

4、大综合（☆）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xTR0ZuTb-1645968588670)(java基础.assets/image-20210517111023531.png)]

【案例】

class A02 { //父类
    private static int n1 = getVal01();
    static {
    	System.out.println("A02 的一个静态代码块..");//(2)
    }
    {
    	System.out.println("A02 的第一个普通代码块..");//(5)
    }
    public int n3 = getVal02();//普通属性的初始化
    public static int getVal01() {
        System.out.println("getVal01");//(1)
        return 10;
    }
    public int getVal02() {
        System.out.println("getVal02");//(6)
        return 10;
    }
    public A02() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化......
        System.out.println("A02 的构造器");//(7)
    }
}

class B02 extends A02 { // 子类
    private static int n3 = getVal03();
    static {
    	System.out.println("B02 的一个静态代码块..");//(4)
    }
    public int n5 = getVal04();
    {
    	System.out.println("B02 的第一个普通代码块..");//(9)
    }
    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }
    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }
    //一定要慢慢的去品..
    public B02() {//构造器
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化...
        System.out.println("B02 的构造器");//(10)
        // TODO Auto-generated constructor stub
    }
}

class C02 { 
    private int n1 = 100;
    private static int n2 = 200;
    private void m1() {
    }
    private static void m2() {
    }
    static {
        //静态代码块，只能调用静态成员
        //System.out.println(n1);错误
        System.out.println(n2);//ok
        //m1();//错误
        m2();
    }
    {
        //普通代码块，可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}

测试

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        //老师说明
        //(1) 进行类的加载
        //1.1 先加载父类A02 1.2 再加载B02
        //(2) 创建对象
        //2.1 从子类的构造器开始
        //new B02();//对象
        new C02();
    }
}

class A {
	static {
		System.out.print("1");
	}
	public A() {
		System.out.print("2");
	}
}
class B extends A{
	static {
		System.out.print("a");
	}
	public B() {
		System.out.print("b");
	}
}
public class Hello {
	public static void main(String[] args) {
		A ab = new B(); // 1a2b
		ab = new B();	// 2b
        // 执行结果：1a2b2b
	}
}

描述一下JVM 加载class 文件的原理机制?

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-suYYSDb8-1645968588672)(java基础.assets/image-20210621085735682.png)]

类的加载过程

JVM将类加载过程分为三个步骤：装载（Load），链接（Link）和初始化(Initialize)

数组

数组中元素可以是基本类型，也可是引用类型，但不可混用

集合Collection接口

1)可以动态保存任意多个对象，使用比较方便!
2)提供了一系列方便的操作对象的方法:add、remove、set、get等

3)使用集合添加,删除新元素的示意代码-简洁了

Java 的集合类很多，主要分为两大类，如图：[背下来]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c4liXZw9-1645968588672)(java基础.assets/image-20210525201045084.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IfkaPxi2-1645968588673)(java基础.assets/image-20210525201108483.png)]

List接口

特性

里面元素有序（存入和取出顺序一致），且可重复

支持索引

遍历：迭代器、增强for循环、for

实现类

• 1、ArrayList

  ArrayList基本和vector等同，除了ArrayList是线程不安全的（执行效率高）

• 2、LinkedList

  ​ 1)LinkedList底层实现了双向链表和双端队列特点

  ​ 2)可以添加任意元素(元素可以重复)，包括null

  ​ 3)线程不安全，没有实现同步

• 3、vector

  ​ 线程同步

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UxUGuPO9-1645968588674)(java基础.assets/image-20210525220342526.png)]

Set接口

特性

1)无序（添加和取出的顺序不一致)，没有索引

2)不允许重复元素，所以最多包含一个null

3）遍历方种：迭代器、增强for循环【不能用索引遍历】

实现类

• 1、HashSet

​ 底层是HashMap，HashMap底层是（数组+链表+红黑树）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K60Nfhwh-1645968588674)(java基础.assets/image-20210525221352812.png)]

HashSet

// String 的 equals 比较值
set.add(new String("hsp"));//ok
set.add(new String("hsp"));//加入不了.
// 对象 的 equals 如果没重写就继承object类，比较地址
set.add(new Dog("tom"));//OK
set.add(new Dog("tom"));//Ok

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P5mmjKZr-1645968588675)(java基础.assets/image-20210526162647820.png)]

重写hashCode和equals方法

class Employee {
    private String name;
    private int age;
	// 省略构造、set、get等方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
        Objects.equals(name, employee.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
	}
}

• 2、LinkedHashSet

1. LinkedHashSet是 HashSet的子类
   2)LinkedHashSet底层是一个 LinkedHashMap，底层维护了一个数组+双向链表
2. LinkedHashSet根据元素的 hashCode值来决定元素的存储位置，同时使
   用链表维护元素的次序(图)，这使得元素看起来是以插入顺序保存的。
3. LinkedHashSet不允许添重复元素

• 3、TreeSet

//1. 当我们使用无参构造器，创建TreeSet 时，仍然是无序的
//2. 老师希望添加的元素，按照字符串大小来排序
//3. 使用TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类)
// 并指定排序规则

TreeSet treeSet = new TreeSet(new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        //下面调用String 的compareTo 方法进行字符串大小比较
        //如果要求加入的元素，按照长度大小排序
        //return ((String) o2).compareTo((String) o1);
        return ((String) o1).length() - ((String) o2).length();
}
});
//添加数据.
treeSet.add("jack");

Map 接口

介绍

注意:这里讲的是JDK8的Map接口特点 Map_.java
1)Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value
2) Map 中的key 和value可以是任何引用类型的数据，会封装到HashMap$Node对象中
3) Map 中的 key 不允许重复，原因和HashSet一样，前面分析过源码.

4. Map 中的value可以重复
5. Map 的key可以为null, value也可以为null，注意key为null,只能有一个，value为null,可以多个.
   6)常用String类作为Map的key
6. key 和 value之间存在单向一对一关系，即通过指定的key总能找到对应的value

遍历方式

containsKey:查找键是否存在

keySet:获取所有的键

values:获取所有的值

entrySet:获取所有关系k-v

// =========== 1.keySet() ==========
Set keyset = map.keySet();
	//(1) 增强for
    for (Object key : keyset) {
    	System.out.println(key + "-" + map.get(key));
    }
	//(2) 迭代器
    Iterator iterator = keyset.iterator();
    while (iterator.hasNext()) {
        Object key = iterator.next();
        System.out.println(key + "-" + map.get(key));
    }

// =========== 2.values() ==========
Collection values = map.values();// 也是增强for或迭代器

// =========== 3.entrySet() ==========
Set entrySet = map.entrySet();// EntrySet>
    //(1) 增强for
    for (Object entry : entrySet) {
        //将entry 转成Map.Entry
        Map.Entry m = (Map.Entry) entry;
        System.out.println(m.getKey() + "-" + m.getValue());
    }
    //(2) 迭代器
    Iterator iterator3 = entrySet.iterator();
    while (iterator3.hasNext()) {
        Object entry = iterator3.next();
        //System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue)
        //向下转型Map.Entry
        Map.Entry m = (Map.Entry) entry;
        System.out.println(m.getKey() + "-" + m.getValue());
    }

HashMap小结

1 ) Map接口常用实现类:HashMap、Hasntable和Properties.

2. HashMap是 Map接口使用频率最高的实现类。
3. HashMap 是以 key-val对的方式来存储数据(HashMap$Node类型)
   4)key不能重复,但是值可以重复,允许使用null键和null值。
   5)如果添加相同的key，则会覆盖原来的key-val ,等同于修改.(key不会替换，val会替换)6)与HashSet一样,不保证映射的顺序，因为底层是以hash表的方式来存储的.(jdk8的hashMap底层数组+链表+红黑树)
4. HashMap没有实现同步，因此是线程不安全的,方法没有做同步互斥的操作,没有
   synchronized

TreeMap

TreeMap treeMap = new TreeMap(new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        //按照传入的k(String) 的大小进行排序
        //按照K(String) 的长度大小排序
        //return ((String) o2).compareTo((String) o1);
        return ((String) o2).length() - ((String) o1).length();
    }
});
treeMap.put("jack", "杰克");
treeMap.put("tom", "汤姆");
treeMap.put("kristina", "克瑞斯提诺");
treeMap.put("smith", "斯密斯");
treeMap.put("hsp", "韩顺平");//加入不了

HashTable

介绍

1)存放的元素是键值对:即K-v
2) hashtable的键和值都不能为null，否则会抛出NullPointerException

3. hashTable使用方法基本上和HashMap一样
4. hashTable是线程安全的(synchronized)， hashMap是线程不安全的

HashTableExercise.javaHashtable table = new Hashtable0;//ok
table.put("john".100); //ok
table.put(null, 100); //异常
table.put("john", null);//异常
table.put("lic" ,100);//oktable.put(" lic",88);//替换System.out.println(table);

Hashtable 和HashMap 对比

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EMbjEEJX-1645968588676)(java基础.assets/image-20210529071213307.png)]

Properties

1. Properties继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形
   式来保存数据。
2. Properties还可以用于从xxx.properties 文件中，加载数据到Properties类对象,
   并进行读取和修改

//1. Properties 继承Hashtable
//2. 可以通过k-v 存放数据，当然key 和value 不能为null
//增加
Properties properties = new Properties();
//properties.put(null, "abc");//抛出空指针异常
//properties.put("abc", null); //抛出空指针异常
properties.put("lic", 88);//如果有相同的key ， value 被替换

选用集合实现类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PVXKzqfa-1645968588677)(java基础.assets/image-20210529073227511.png)]

Collections

//我们希望按照字符串的长度大小排序
Collections.sort(list, new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        //可以加入校验代码.
        return ((String) o2).length() - ((String) o1).length();
    }
});

//int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
System.out.println("tom 出现的次数=" + Collections.frequency(list, "tom"));

Object maxObject = Collections.max(list, new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
    	return ((String)o1).length() - ((String)o2).length();
    }
});

面试

List、Set、Map 是否继承自 Collection 接口？

List、Set 是 ，Map 不是。Map 是键值对映射容器，与 List 和 Set 有明显的区别，而 Set 存储的零散的元素且不允许有重复元素（数学中的集合也是如此），List是线性结构的容器，适用于按数值索引访问元素的情形。

Collection 和 Collections

Collection 是一个接口，它是 Set、List 等容器的父接口；Collections 是个一个工具类，提供了一系列的静态方法来辅助容器操作，这些方法包括对容器的搜索、排序、线程安全化等等。

TreeMap 和 TreeSet 在排序时如何比较元素？Collections 工具类中的 sort()方法如何比较元素？

TreeSet 要求存放的对象所属的类必须实现 Comparable 接口，该接口提供了比较元素的 compareTo()方法，当插入元素时会回调该方法比较元素的大小。

TreeMap 要求存放的键值对映射的键必须实现 Comparable 接口从而根据键对元素进行排序。

Collections 工具类的 sort 方法有两种重载的形式，

• 第一种要求传入的待排序容器中存放的对象实现 Comparable 接口以实现元素的比较；
• 第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator 接口的子类型（需要重写 compare 方法实现元素的比较），相当于一个临时定义的排序规则，其实就是通过接口注入比较元素大小的算法，也是对回调模式的应用（Java 中对函数式编程的支持）。

泛型

好处

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zYEdHcS5-1645968588678)(java基础.assets/image-20210529155015094.png)]

使用细节

1. 说明: T, E只能是引用类型

interface List{}，class HashSet 等等

看看下面语句是否正确?:

List< Integer> list = new ArrayList < Integer> 0); //OK
List<int> list2 = new ArrayList <int> ();//错误

2.在给泛型指定具体类型后，可以传入该类型或者其子类类型
3.泛型使用形式

List<Integer> list1 = new ArrayList < Integer> ();
List< Integer> list2 = new ArrayList<> 0; [说明:]推荐这样写 (简洁)    

3.如果我们这样写List list3 = new ArrayList(); 默认给它 E就是Object

自定义泛型类

基本语法

class 类名<T,R...> { } //...表示可以有多个泛型成员

注意细节
1)普通成员可以使用泛型(属性、方法)
2)使用泛型的数组，不能初始化
3)静态方法中不能使用类的泛型(静态是类加载时的，早于创建对象)
4)泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)
5)如果在创建对象时，没有指定类型，默认为Object

自定义泛型接口

➢基本语法
interface 接口名 {}
➢注意细节
1)接口中，静态成员也不能使用泛型(这个和泛型类规定一样)
2)泛型接口的类型，在继承接口或者实现接口时确定
3)没有指定类型，默认为Object

自定义泛型方法

基本语法

修饰符 返回类型 方法名(参数列表) {}
➢ 注意细节
1.泛型方法，可以定义在普通类中，也可以定义在泛型类中
2.当泛型方法被调用时，类型会确定

3.public void eat(E e) {}， 修饰符后没有 时，eat方法不是泛型方法，而是使用了泛型

//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类
	public void run() {//普通方法
	}
    //说明泛型方法
    //1.  就是泛型
    //2. 是提供给fly 使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}

class Fish<T, R> {//泛型类
	public void run() {//普通方法
	}
    public<U,M> void eat(U u, M m) {//泛型方法
    }
    //说明
    //1. 下面hi 方法不是泛型方法，因为没有< >
    //2. 是hi 方法使用了类声明的泛型
    public void hi(T t) {
    }
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }
}

// ========= 测试 =================
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
        System.out.println("=======");
        car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型
        //测试
        //T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}

泛型的继承和通配符

1)泛型不具备继承性

List