Java | Koreyoshi

type

status

date

slug

summary

🔍 考点梳理

1.Java语言的特点；标识符，Java的编译命令等

java语言的特点：语法简单、面向对象、稳定、与平台无关、多线程、动态

跨平台：Java的跨平台性是通过将源代码编译成与平台无关的字节码，然后在目标平台上使JVM（Java虚拟机）来解释或编译这些字节码为机器码并执行来实现的，实现了跨平台的兼容性。

标识符：是否符合语法、命名规则。

编译命令

Java源代码文件通常以.java为扩展名。要将Java源代码编译成字节码文件（.class文件），需要使用javac命令。

其他

每个源文件最多只能有一个public类。
如果一个源文件包含public类，那么该文件的名称必须与public类的名称完全一致。
一个源文件中可以有多个非public类。
Java应用程序的入口点是包含public static void main(String[] args)方法的类，这个类可以是public也可以不是（尽管习惯上是public以便于外部调用）。

2.Java源文件的组成与Class，Java源文件的命名；编译后的字节码文件

java源文件的命

如果源文件中包含一个公共类，那么该文件必须以这个公共类的名字命名，并加上.java扩展名。例如，如果公共类名为MyClass，源文件应命名为MyClass.java。如果源文件中没有公共类，则文件名可以自由选择，但通常建议反映其内部类或接口的名称。
源文件中至少需要有一个类（class）或者接口（interface）的定义。Java规范要求，如果源文件中包含公共类（public class），那么源文件的名字必须与该公共类的类名完全一致（包括大小写），并且只能有一个公共类。非公共类的数量没有限制。

编译后的字节码文件

命名：编译Java源文件后，会生成一个或多个.class文件，每个类或接口都会被编译成一个独立的字节码文件。文件名与源文件中对应的类或接口名一致，并且遵循包的目录结构。例如，对于包com.example.myapp中的MyClass，编译后会得到com/example/myapp/MyClass.class。

3.基本数据类型的理解，常量的类型，数组的概念及方法函数

八大基本数据类型

按精度排序

数据类型	位数	字节	范围
boolean	1位	ㅤ	（0,1）
byte	8为	1字节	-128~127
short	16位	2字节	-32768~32767
char	16位	2字节	0~65536
int	32位	4字节	ㅤ
long	64位	8字节	ㅤ
float	32位	4字节	ㅤ
double	64位	8字节	ㅤ

常量的默认类型

整数默认为int
小数默认为double
float后面要带f、F

数组的概念（本质是一个类）

数组是相同类型元素的集合，这些元素存储在一块连续的内存区域中。数组的每个元素都有一个索引，从0开始计数。数组的长度（元素数量）在创建时就固定了，之后不能改变。

数组的方法和函数（待补充课本上的）

排序：Arrays.sort(array)，对数组进行排序。
比较：Arrays.equals(array1, array2)，比较两个数组是否相等。
填充：Arrays.fill(array, value)，用特定值填充整个数组。
复制：Arrays.copyOf(array, newLength)，复制数组并可调整新数组的长度。
打印：虽然不是方法，但使用Arrays.toString(array)可以方便地将数组转换为字符串形式输出，便于查看。

4.类和对象的关系；类的属性和方法概念及访问权限，属性方法的分类（如实例属性，方法；类属性方法）；静态变量和实例变量的区别；方法重写的目的和规则；构造方法的定义；复数、有理数；

类和对象的关系

类与对象的关系类似于蓝图与建筑的关系。类是一种定义，它描述了一类对象共有的属性（数据成员）和行为（方法）。对象是类的实例，是根据类的定义创建出来的具体实体，每个对象都拥有类中定义的属性和方法。

类的属性和方法概念及访问权限，属性方法的分类（如实例属性，方法；类属性方法）

属性（Fields）：表示对象的状态或特征，可以是变量。属性有实例属性（属于对象本身，每个对象的属性值可以不同）和类属性（属于类，所有对象共享同一份属性）之分。自带默认值。

方法（Methods）：定义了对象能够执行的操作。方法同样可以分为实例方法（需要通过对象调用，可以访问实例属性）和类方法（静态方法，可通过类名直接调用，通常操作类属性或执行不依赖于特定对象的行为）。

访问权限：Java中通过访问修饰符来控制属性和方法的访问权限，主要有：

public：任何地方都能访问。
protected：同包内和子类可以访问。
private：仅在定义它的类内可访问。
默认（无修饰符）：仅在同一个包内可访问。

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

静态变量（Static Variables）：属于类，所有该类的对象共享同一份静态变量。静态变量在内存中只有一份拷贝，随类的加载而创建，不依赖于对象实例。

实例变量：属于对象，每个对象都有自己的实例变量副本。实例变量随着对象的创建而分配内存，随着对象的销毁而消失。

方法重写的目的和规则

目的：方法重写（Override）允许子类根据需要修改或增强父类的行为，实现多态性，即同样的方法调用可以根据对象类型的不同而表现出不同的行为。

规则：

方法名、返回类型、参数列表必须与父类方法完全一致。
访问权限不能比父类更严格。
可以抛出更窄的异常或不抛出异常。
使用@Override注解明确表明这是重写方法。

构造方法的定义

构造方法是类的一种特殊方法，用于初始化对象。构造方法的名称与类名相同，没有返回类型（包括void）。每当创建一个新对象时，构造方法会被自动调用。它可以有参数，也可以重载（即一个类可以有多个构造方法）。

未说明构造方法，即默认生成空的构造方法。构造方法可以重载多个。构造方法没有返回值。

复数、有理数（可能有大题）

在面向对象编程中，复数和有理数可以被设计为类，以体现面向对象的抽象和封装特性。

复数类：可以有实部和虚部两个属性，以及加减乘除等运算方法。
有理数类：可以有分子和分母两个属性，以及简化、加减乘除等运算方法。这些类的设计体现了对象的属性和行为，同时也可能包含静态方法来执行一些与类相关的操作，如计算公因数等。

5.类的种类及其区别；Object类及Object类中的常用方法

类的种类及其区别

在Java中，类可以大致分为以下几种类型，每种都有其独特的用途和特点：

普通类（Regular Class）：这是最常见的类，可以包含属性（成员变量）、方法、构造函数等，可以被继承或实现接口。普通类是对象的蓝图，定义了对象的状态和行为。

抽象类（Abstract Class）：抽象类不能直接实例化，它通常包含一个或多个抽象方法（没有具体实现的方法），要求其子类必须实现这些抽象方法。抽象类用于为子类提供一个共同的接口和部分实现。

接口（Interface）：接口是一种完全抽象的类，其中所有的方法都是抽象的（Java 8后可以有默认方法和静态方法）。接口定义了一组行为规范，任何实现该接口的类都必须实现这些行为。

枚举类（Enum Class）：枚举是一种特殊的类，用于定义固定的常量集合。枚举类可以有自己的方法和属性，增加了类型安全性和可读性。

注解类（Annotation Class）：实际上是一种特殊的接口，用于提供元数据。注解可以附加到类、方法、变量等上面，为编译器或运行时环境提供额外信息。

内部类（Inner Class）：包括成员内部类、局部内部类、匿名内部类和静态嵌套类。它们定义在一个类的内部，可以访问外部类的成员，增加了封装性和代码组织的灵活性。

Object类及常用方法（没找到在课本哪里啊）

Object类是Java中所有类的基类，即所有类都直接或间接继承自Object类。Object类定义了一些基本的方法，这些方法在所有类中都可用。

public boolean equals(Object obj)：用于比较两个对象是否相等。默认实现是比较对象的引用是否相同，但通常需要在子类中重写以实现基于内容的比较。

public int hashCode()：返回对象的哈希码值。在使用基于哈希的集合（如HashMap）时非常重要，应与equals方法保持一致。

public String toString()：返回对象的字符串表示形式。默认实现返回类名和其哈希码的字符串形式，通常需要在子类中重写以提供更有意义的描述。

protected Object clone()：用于创建并返回此对象的一个副本。要使用此方法，类必须实现Cloneable接口并重写此方法。

protected void finalize()：当垃圾回收器确定不再有对该对象的引用时，会尝试调用此方法。现在已不鼓励使用，因为垃圾回收机制的不确定性和效率问题。

6.抽象类与接口的比较

相同点

都无法实例化
都可以包含抽象方法

不同点

接口中只能有常量，不能有变量，而抽象类中都可以有。
抽象类可以有非抽象方法，但不能有default实例方法；而接口不可以有非抽象方法，但可以有default实例方法
抽象类不支持多重继承，而接口支持多重继承。

7.接口的成员及访问权限；接口中的成员变量的修饰符；

注意：

类实现某接口，但不拥有接口的static方法
接口中方法的访问权限都是public的，重写时不可省略

接口的成员及访问权限

抽象方法（Abstract Methods）：这是接口的主要成分，它们是没有方法体的方法声明，用于规定实现该接口的类必须提供的方法。从Java 8开始，接口中的抽象方法可以有默认实现（default methods）和静态方法（static methods）。

默认方法（Default Methods）：自Java 8起引入，它们提供了接口方法的默认实现，使得实现接口的类可以选择是否重写这些方法。

静态方法（Static Methods）：同样自Java 8起，接口可以有静态方法，这些方法属于接口本身，而不是实现接口的类的实例。

常量（Constants）：接口中的变量默认是静态（static）、最终（final）的，且必须初始化。这意味着它们是常量，所有实现该接口的类都共享同一份数据。

接口中的成员变量（实际上是常量）只能使用以下修饰符：（要么同时存在，要么同时不存在）

public：接口中的所有成员（包括方法和变量）默认都是public的，即便不明确写出。这是因为接口设计来就是要被实现和使用的，所以其成员需要对外界可见。
static：由于接口的成员是为了被实现它的类共享的，因此它们必须是静态的。这使得即使没有创建接口的实例，也能通过接口名直接访问这些成员。
final：接口中的变量一旦赋值就不能更改，因此它们是final的。这意味着你在声明时就必须给它们初始化值。

8.匿名类的概念及使用；匿名类编译后的字节码文件；匿名类的成员；

匿名类的概念及使用

匿名类是Java中一种特殊的类，它没有具体的名称，直接在创建对象的同时定义类的主体。这种机制常用于快速创建一次性使用的类实例，特别是在需要传递一个类的实例作为参数或者实现某个接口的简单情况时。匿名类简化了代码，减少了单独定义类的需要，使得代码更加紧凑。
匿名类一定是内部类，经常作为上转型对象

匿名类编译后的字节码文件

当含有匿名类的Java源代码被编译时，JVM会为匿名类生成一个独立的.class文件，命名规则通常是包含匿名类的外部类名加上一个数字序号，例如，如果外部类是 MyClass，且这是该类中的第一个匿名类，则编译后生成的文件可能是 MyClass$1.class。这个数字序号表示了匿名类在外部类中定义的顺序。

匿名类的成员

匿名类可以拥有如下类型的成员：

实例变量：虽然可以声明实例变量，但这在匿名类中并不常见，因为匿名类通常用于简短的任务，不需要复杂的内部状态。

局部变量：可以直接访问外部方法的final或effectively final局部变量（Java 8以后对final的要求放宽，只要局部变量事实上未被重新赋值即可）。

方法：可以实现或覆盖继承自超类或接口的方法。

构造函数：匿名类没有显示的构造函数，但编译器会为它生成一个默认构造函数，该构造函数可能会调用超类或实现的接口的构造函数。

匿名类不能定义自身为 public, protected, private 或 static，因为它们没有名字来应用这些修饰符。同时，匿名类不能定义静态成员或声明为抽象类。

9. Exception类的使用和继承，throw和throws，自定义异常类的使用

Exception类的使用和继承

使用：异常的使用主要涉及两个关键字：try-catch用于捕获并处理异常，finally块用于指定无论是否发生异常都需要执行的代码。

继承：开发者可以自定义异常类，通过继承Exception类或其子类。自定义异常通常用于表示应用程序特有的错误条件。

throw和throws

作用：throw用于在代码中手动抛出一个异常。当程序检测到某种错误条件时，可以使用throw语句创建并抛出一个异常对象。

作用：throws用于声明方法可能抛出的异常类型，告诉调用者需要处理或继续声明这些异常。它放在方法签名的后面。例如：

自定义异常类的使用

创建：自定义异常类通常继承自Exception或其子类。一般会提供至少一个构造函数，用于接收并存储异常的详细信息。例如：

使用：在需要的地方抛出自定义异常，并在方法签名中使用throws声明可能抛出的异常。调用者可以捕获这些异常并做相应的处理。

10.String，Integer，Float类使用

在Java中，String、Integer、Float是三种非常基础且常用的类，它们分别用于处理文本字符串、整数和浮点数。下面是这些类的基本使用方法：

String类

String类代表不可变的字符序列。一旦创建，其内容就不能更改。这是Java中最常用的一个类之一。stringbuffer类可以更改

基本操作

创建字符串:

长度获取:

拼接字符串:

比较字符串:

提取子串:

查找字符或子串:

Integer类

Integer类是int类型的包装类，主要用于将基本数据类型int转换为对象，便于在泛型集合中使用或进行更复杂的操作。

常用方法

解析字符串为整数:

转换为字符串:

比较两个整数:

Float类

Float类是float类型的包装类，功能与Integer类似，但用于处理浮点数。

基本操作

解析字符串为浮点数:

转换为字符串:

比较两个浮点数:

注意事项

装箱与拆箱：基本类型与包装类型之间可以通过自动装箱（Autoboxing）和自动拆箱（Auto-unboxing）相互转换，但需要注意潜在的NullPointerException风险。

性能考虑：虽然包装类提供了丰富的功能，但在处理大量数据或性能敏感的场景下，直接使用基本类型会更高效。

常量池：对于String，JVM会维护一个字符串常量池，相同内容的字符串字面量只会被创建一次，以节省内存。使用new String(...)则每次都创建新的对象。

11. this

this是Java的一个关键字，表示当前对象。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。

this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。

实例方法必须只能通过对象来调用，不能用类名来调用。当this出现实例方法中时，代表正在调用该方法的当前对象。

12. 创建子类对象时，构造方法的执行顺序

父类静态代码块 → 子类静态代码块 → 父类普通代码块 → 父类构造方法 → 子类普通代码块 → 子类构造方法

13.上转型对象与多态性

上转型对象

当一个子类实例被赋予其父类类型的引用时，就发生了上转型。
上转型对象不能操作子类新增的成员变量和方法，但是可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类的重写方法。
例如，假设有一个父类Animal和一个子类Dog，那么下面的代码展示了上转型：

多态性

多态性是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。
‣

1、成员变量

编译看左边，运行看左边

2、构造方法

创建子类对象的时候，先访问父类的构造方法，先对父类的数据进行初始化

3、成员方法

编译看左边，运行看右边

因为子类的成员方法存在重写，所以运行访问的时候看右边

4、静态的成员方法：

编译看左边，运行看左边

14. 接口回调的概念及应用

可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法以及接口中的default方法

接口回调（Interface Callback）是一种设计模式，允许我们在某些事件发生或特定条件满足时，由系统自动调用预先定义好的方法。这种设计模式的核心在于，一个对象（调用者）将自己实现的接口（即包含待回调方法的接口）传递给另一个对象（被调用者），后者在适当的时候通过这个接口来调用前者的方法。这种机制使得对象间的通信变得灵活和解耦，特别适用于事件驱动编程、异步处理、或者需要自定义行为的场景。

概念详解

接口定义：首先定义一个接口，该接口包含一个或多个方法声明，这些方法将在特定事件或条件触发时被执行。

实现接口：需要接收回调的类（回调接收者）实现这个接口，并提供具体的实现逻辑。

传递接口实例：回调接收者将自己实现的接口实例传递给另一个类或组件（回调发起者）。

调用回调方法：在回调发起者的内部，当特定事件发生或条件满足时，通过持有的接口引用调用相应的回调方法，从而通知回调接收者进行相应的处理。

应用场景

事件监听：在图形界面编程中，按钮点击、窗口关闭等事件都可以通过接口回调机制来通知事件处理器进行处理。

异步操作：比如网络请求、文件读写等耗时操作，可以使用接口回调来通知主线程操作结果，而不阻塞主线程。

框架与插件系统：许多框架通过接口回调机制允许用户自定义逻辑，如Android的Activity生命周期回调、RabbitMQ的消息处理回调等。

示例代码（Java）

假设我们有一个异步下载图片的任务，我们希望通过接口回调来通知完成状态。

在这个例子中，MainActivity实现了DownloadCallback接口，并将其实例传递给ImageDownloader，当图片下载完成后，ImageDownloader通过回调接口通知MainActivity下载结果。

15. equals与==；toString方法的理解和应用

equals与==

在Java中，equals和==都用于比较，但它们的比较方式和适用场景有所不同：

==：比较是否是同一个东西。这是一个关系运算符，用于比较两个变量的值是否相等。对于基本数据类型，它比较的是值是否相同；而对于引用类型，它比较的是两个对象的内存地址是否相同，即判断两个引用是否指向堆内存中的同一个对象。
equals：比较是否内容相同。这是Object类的一个方法，用于比较两个对象的内容是否相等。默认情况下，Object类的equals方法的行为与==相同，即比较对象的引用是否相同。但是，许多类（如String、Integer等）重写了equals方法，使其比较的是对象的实际内容，而非引用地址。因此，在使用这些类时，equals通常用来判断两个对象的逻辑上是否相等。

toString方法

toString方法也是Object类的一个方法，它的目的是返回对象的字符串表示形式。
在没有被重写的情况下，默认的toString方法返回的是对象的类名加上其十六进制表示的哈希码，例如className@hashCode。这在调试和日志记录时往往不够友好。

16.文件的读、写

在Java中，文件的读取和写入可以通过多种方式实现，常见的有使用FileInputStream、FileOutputStream进行字节流操作，以及使用FileReader、FileWriter进行字符流操作。此外，还可以使用更高级的BufferedReader、BufferedWriter、Scanner和PrintWriter等类，它们提供了更便捷的API。以下是几种基本的读写文件示例：

读文件——>保存（用什么结构进行保存便于排序、comparable接口）——>处理数据：排序、翻译、检索——>写到另一个文件————我猜必考大题

文件写入示例

使用FileWriter

使用PrintWriter（增加自动刷新和格式控制）

使用BufferedWriter

文件读取示例

使用FileReader

使用BufferedReader（增加缓冲，提高效率）

注意事项

使用try-with-resources语句可以自动关闭资源，避免资源泄露。

在处理文件时，始终要准备好处理IOException，这可能是由于文件不存在、权限问题或其他I/O错误引起的。

根据需要选择合适的流类型，字符流适用于文本文件，而字节流适用于二进制文件或需要低级控制的情况。

对于大文件读写，考虑使用BufferedInputStream/BufferedOutputStream或BufferedReader/BufferedWriter以提高效率。

17. Comparable接口的使用

Comparable接口在Java中是用来定义一个类的自然排序规则的。当一个类实现了Comparable接口，它就表明该类的实例之间可以进行比较，从而决定了它们在排序时的先后顺序。

Comparable接口在Java中用于定义一个类的自然排序规则。当你实现Comparable接口时，意味着你为该类的实例提供了一种默认的排序方式。这对于需要对集合（如ArrayList、LinkedList）、数组或使用诸如TreeSet和TreeMap等需要排序的数据结构中的对象进行排序时非常有用。下面是如何使用Comparable接口的一般步骤和注意事项：

实现Comparable接口

定义比较规则：首先，决定你的类如何进行比较。通常，比较是基于类中的一个或多个字段，比如数字的大小、字符串的字典顺序等。

实现compareTo方法：在你的类中实现Comparable接口，并重写compareTo方法。这个方法应该返回一个整数值，根据当前对象与传入对象的比较结果决定返回值：

如果当前对象小于传入对象，则返回负整数；

如果两者相等，则返回0；

如果当前对象大于传入对象，则返回正整数。

示例

假设我们有一个Person类，我们想要根据年龄进行自然排序：

在这个例子中，Person类实现了Comparable<Person>，并重写了compareTo方法，使得Person对象可以根据年龄进行排序。

使用Comparable接口排序

一旦你的类实现了Comparable接口，你就可以直接使用Java集合框架的排序方法，如Collections.sort()或在构造TreeSet、TreeMap时自动排序：

这段代码将会按照年龄从小到大打印出人名和对应的年龄，因为我们在Person类中定义了基于年龄的比较规则。

18.输入输出流的概念，输入输出流对文件的操作

输入输出流（I/O Streams）是Java中用于处理数据输入和输出的核心概念。它们构成了Java I/O系统的基础，允许程序与外部设备（如文件、网络连接、控制台等）进行交互。Java的I/O流分为两大类：输入流（Input Streams）和输出流（Output Streams）。

输入、输出流提供一条通道程序，可以使用这条通道读取“源”中的数据，或把数据送到“目的地”。输入流的指向称做源，程序从指向源的输入流中读取源中的数据；输出流的指向称做目的地，程序通过向输出流中写入数据把信息传递到目的地。

输入流（Input Streams）

输入流负责从源（如文件、网络等）读取数据到程序中。常见的输入流包括：

FileInputStream：用于从文件读取原始字节数据。

FileReader：用于从文件读取字符数据，特别是文本文件。

BufferedReader：增加缓冲区以提高读取效率，常与FileReader等结合使用。

Scanner：提供更高级的文本扫描功能，可以解析不同类型的输入。

输出流（Output Streams）

输出流负责将程序中的数据写入目标（如文件、网络等）。常见的输出流包括：

FileOutputStream：用于向文件写入原始字节数据。

FileWriter：用于向文件写入字符数据，特别适合文本文件。

BufferedWriter：增加缓冲区以提高写入效率，常与FileWriter等结合使用。

PrintWriter：提供格式化输出功能，如自动换行、打印各种数据类型等。

对文件的操作示例

读取文件示例（使用`FileInputStream`和`FileReader`）

写入文件示例（使用`FileOutputStream`和`FileWriter`）

注意事项

在处理文件时，务必使用try-with-resources语句块来自动关闭流，以防止资源泄漏。

根据数据类型选择合适的流，例如文本数据推荐使用字符流，二进制数据推荐使用字节流。

对于大文件操作，建议使用缓冲流（如BufferedInputStream/BufferedOutputStream、BufferedReader/BufferedWriter）来提高效率。

19. 泛型的概念；泛型的安全机制；三类容器List、Set、Map各自的特点；泛型与集合框架的应用，特别是LinkedList<E>，HashMap<K,V>类，TreeSet<E>类，TreeMap<K,V>类等的使用；文件读写；

泛型的概念（小题）

泛型（Generics）是Java中的一种特性，允许在编译时检查类型安全，并且所有的强制类型转换都是自动和隐式的，提高了代码的重用性、类型安全性和可读性。泛型可以应用于类、接口和方法中，允许程序员在编译时指定集合、类或方法的类型参数，从而避免了运行时的类型转换错误。

可以使用“class 名称<泛型列表>”声明一个类，为了和普通的类有所区别，这样声明的类称作泛型类

泛型的安全机制

泛型的安全机制体现在以下几个方面：

类型擦除与编译时类型检查：尽管泛型在编译后会被擦除（Type Erasure），但是编译器会在编译阶段检查类型参数的兼容性，确保类型安全，避免了运行时的ClassCastException。

限制类型参数：泛型可以指定边界，如<? extends T>或<? super T>，确保只接受特定类型的参数或返回特定类型的值。

类型推断：Java编译器能够自动推断泛型类型，使得代码更简洁，减少类型转换的需要。

限制自动装箱和拆箱：泛型有助于减少不必要的自动装箱和拆箱操作，进一步减少错误和提升性能。

三类容器List、Set、Map各自的特点

List（列表）:

有序的集合，允许重复元素。按顺序访问，但是便于增删改查。
最常用的实现类包括ArrayList（动态数组，随机访问快，增删慢）和LinkedList（基于双向链表，增删快，随机访问慢）。

Set（集）:

不允许重复元素，无序。
常用实现有HashSet（基于哈希表，查询速度快）和TreeSet（基于红黑树，自然排序或自定义排序）。

Map（映射）:

存储键值对，键必须唯一。k不能重复。
常见实现包括HashMap（基于哈希表，非线程安全，查询效率高）和TreeMap（基于红黑树，键自然排序或自定义排序）。

泛型与集合框架的应用，特别是LinkedList<E>，HashMap<K,V>类，TreeSet<E>类，TreeMap<K,V>类等的使用（小题大题都会考）

LinkedList:

E代表元素类型，泛型保证了链表中元素类型的统一，增强了类型安全性。
支持快速的插入和删除操作，但随机访问较慢。

HashMap<K,V>:

K代表键类型，V代表值类型，泛型确保键值对的类型安全。
提供快速的键值对存取，但不保证顺序。

TreeSet:

E指集合元素类型，由于TreeSet是有序的，所以泛型还可以通过Comparator指定排序规则。
自动维护集合元素的排序，适合需要排序的集合场景。

TreeMap<K,V>:

同样使用K作为键的类型，V作为值的类型，保证了键值对类型的统一和安全。
根据键自然排序或Comparator排序，适合需要按键排序的映射场景。

文件读写

在Java中，文件读写主要通过I/O流（InputStream/OutputStream和Reader/Writer）实现。例如，使用FileInputStream和FileOutputStream进行字节流的读写，而FileReader和FileWriter用于字符流的读写。更高级的操作可以使用BufferedReader、BufferedWriter、Scanner和PrintWriter等，它们提供了缓冲区以提高效率，并增加了更多便利的读写方法。

读取文件：使用BufferedReader逐行读取文本文件，或使用Scanner按需读取数据。

写入文件：使用BufferedWriter或PrintWriter进行格式化的文本写入，支持自动换行和字符串格式化。

泛型与集合框架的结合应用，如在创建ArrayList, LinkedList, HashMap, TreeSet, TreeMap等集合时，指定泛型参数可以确保集合中元素的类型一致性和安全性，避免了运行时的类型转换异常，提高了代码的健壮性和可维护性。

20.线程的概念，线程的状态；创建线程的方法；

线程的概念

进程是程序的一次动态执行过程。线程是比进程更小的执行单位。一个进程在其执行过程中，可以产生多个线程。

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Java中，线程让程序能够同时执行多个任务，提高了程序的响应速度和执行效率。

多线程是指同时存在几个执行体，按几条不同的执行线索共同工作的情况，它使得编程人员可以很方便地开发出具有多线程功能、能同时处理多个任务的功能强大的应用程序。

线程的状态

Java线程在其生命周期中会经历以下几种状态：

新建（New）：Thread类或其子类的对象被声明并创建时，新生的线程对象处于NEW状态。

可运行（Runnable）：线程已经创建并且调用了start()方法，等待CPU分配时间片执行。这个状态又可以细分为两种：

就绪（Ready）：线程等待CPU调度，获取CPU使用权。

运行（Running）：线程获得CPU时间片，正在执行。

中断状态（BLOCKED，WAITING，TIMED_WAITING）

阻塞（Blocked）：线程因为某种原因（如等待I/O操作完成、等待锁）暂停执行，等待某个条件满足后再进入可运行状态。
等待（Waiting）：线程因为调用了wait()方法，或者在执行join()方法等待另一个线程结束，或者在等待LockSupport.park()等，进入等待状态。需要其他线程的通知或中断才能唤醒。
超时等待（Timed Waiting）：与等待状态相似，不过线程在等待一定时间后会自动返回到可运行状态，如调用了sleep(long millis)、wait(long timeout)等方法。

死亡状态：终止（Terminated）：线程执行完毕或因异常退出run()方法，线程结束。

创建线程的两种方法

在Java中，创建线程主要有以下两种方法：

继承Thread类：创建一个新的类继承Thread类，并重写其run()方法，在run()方法中定义线程执行的逻辑。然后创建该类的实例并调用start()方法启动线程。

实现Runnable接口：定义一个类实现Runnable接口，并实现run()方法。然后将该类的实例作为参数传递给Thread类的构造器，创建Thread对象后调用start()方法启动线程。

📎 猜题

题型

单选 20*1=20

判断 10*1=10

简答 4*5=20

程序分析 5*4=20

编程 2*15

java大题猜测1

java大题猜测2

键盘输入，文件输出

java简答题

第4章：跨平台特性

跨平台：Java的跨平台性是通过将源代码编译成与平台无关的字节码，然后在目标平台上使JVM（Java虚拟机）来解释或编译这些字节码为机器码并执行来实现的，实现了跨平台的兼容性。

第5章：访问权限

public，private，protected，属性和方法的访问权限

第13章：三类容器List、Set、Map各自的特点

三类容器List、Set、Map各自的特点

List（列表）:

有序的集合，允许重复元素。按顺序访问，但是便于增删改查。
最常用的实现类包括ArrayList（动态数组，随机访问快，增删慢）和LinkedList（基于双向链表，增删快，随机访问慢）。

Set（集）:

不允许重复元素，无序。
常用实现有HashSet（基于哈希表，查询速度快）和TreeSet（基于红黑树，自然排序或自定义排序）。

Map（映射）:

存储键值对，键必须唯一。k不能重复。
常见实现包括HashMap（基于哈希表，非线程安全，查询效率高）和TreeMap（基于红黑树，键自然排序或自定义排序）。

第15章：在Java中怎样创建一个线程

在Java中，创建线程主要有以下两种方法：

继承Thread类：创建一个新的类继承Thread类，并重写其run()方法，在run()方法中定义线程执行的逻辑。然后创建该类的实例并调用start()方法启动线程。

实现Runnable接口：定义一个类实现Runnable接口，并实现run()方法。然后将该类的实例作为参数传递给Thread类的构造器，创建Thread对象后调用start()方法启动线程。

💡

有关问题，欢迎您在底部评论区留言，一起交流~

Author:Koreyoshi
URL:https://Koreyoshi1216.com/article/fe23dd4b-1111-466d-938c-5406fc70ade0
Copyright:All articles in this blog, except for special statements, adopt BY-NC-SA agreement. Please indicate the source!

Relate Posts

Koreyoshi

一个无可救药的乐观主义者