java期末考试知识点复习总结
目录
一：3到4章知识点总结
1.控制流（if else swich break；） 循环（while for）
2.类型转换
隐式类型转换（自动转换）：
强制类型转换：
八进制 十六进制输出：
二：第5章面对对象基础：
1.类和对象：
2.封装：
3.构造方法（Constructor）：
三：第六章 继承 重写 接口 this和super关键字 抽象类和抽象方法 接口 多态 static和final关键字
1. 继承：
2. 重写：
3. 接口（Interface）：
4. this 和 super 关键字：
5. 抽象类和抽象方法：
6. 多态：
7. static 和 final 关键字：
四：数组与集合类：
1.数组：
初始化数组：
访问数组元素：
数组排序：
2.Arrlist讲解：
1. 声明和实例化 ArrayList：
2. 添加和访问元素：
3. 删除元素：
4. 遍历 ArrayList：
3.Set类常用接口HashSet：
基本操作：
迭代遍历：
4.set接口实现交集并集差集运算：
1. 差集（Difference）：
2. 交集（Intersection）：
3. 并集（Union）：
5.HashMap基本操作：
1.什么是 HashMap
2.创建 HashMap 集合
3.HashMap 集合常用方法
4.遍历 HashMap 集合 （较为重要）
标题五：Sting类：
标题六：日期类
1.Date类：构造方法
1.Date 类有如下两个构造方法。
2.Date常用方法 :
2.SimpleDateFormat类
实例化：
格式化 ：
解析
3.综合应用 ：
标题七：Integer类
1.Integer类的构造方法
2. Integer类常用方法
标题八：文件操作
可点击目录直接跳转到指定章节
一：3到4章知识点总结
1.控制流（if else swich break；） 循环（while for）
注：此部分不会单独考察，会结合其他知识点，复习请见作业实验四分支结构与循环结构
2.类型转换
隐式类型转换（自动转换）：
隐式类型转换是指在编译时由编译器自动完成的类型转换。它发生在两种数据类型之间，其中一 种数据类型的范围更大，而另一种数据类型的范围更小。
例如：
int num1 = 10;
double num2 = num1; // int类型转换为double类型，发生了隐式类型转换
在这个例子中，int类型的`num1`被隐式转换为double类型的`num2`。这是因为double类型的范围更大，可以容纳int类型的值。
强制类型转换：
显式类型转换是指通过强制使用强制类型转换操作符（`(type)`）来执行的类型转换。它发生在两种数据类型之间，其中一种数据类型的范围较大，而另一种数据类型的范围较小。
例如：
double num1 = 3.14;
int num2 = (int) num1; // double类型转换为int类型，发生了显式类型转换
在这个例子中，double类型的`num1`被显式转换为int类型的`num2`。由于int类型的范围较小，因此需要使用强制类型转换操作符将其转换为int类型。
八进制 十六进制输出：
在Java中，可以使用整型变量表示八进制和十六进制的数值，并将其输出为相应的形式。下面是关于八进制和十六进制输出的详细说明和示例代码：
八进制输出：
八进制数使用前缀`0`表示。可以使用`Integer.toOctalString()`方法将整数转换为八进制字符串。
示例代码：
int octalNum = 83; // 十进制数值83
String octalString = Integer.toOctalString(octalNum);
System.out.println("八进制数：" + octalString); // 输出：123
十六进制输出：
十六进制数使用前缀`0x`表示。可以使用`Integer.toHexString()`方法将整数转换为十六进制字符串。
示例代码：
int hexNum = 171; // 十进制数值171
String hexString = Integer.toHexString(hexNum);
System.out.println("十六进制数：" + hexString); // 输出：ab
需要注意的是，输出的八进制和十六进制字符串都是以字符串形式呈现的，而不是直接作为数值进行计算、
还可以进行格式化输出：
System.out.printf("%x\n",x);//按16进制输出
System.out.printf("%o\n",x);//按8进制输出二：第5章面对对象基础：
1.类和对象：
类用class关键字定义
对象用类名 对象名 =new 类名（参数）；的方法来实例化对象
调用非静态（前缀没有static）方法和非静态成员变量需要先实例化对象，用对象名.方法名（成员变量）来进行调用。
代码演示：
// 类的定义
class Car {
// 成员变量
String brand;
String color;
// 成员方法
void startEngine() {
System.out.println("发动引擎");
}
}
// 对象的实例化
Car myCar = new Car();
2.封装：
使用private关键字对于一些成员方法和成员变量进行访问权限控制，并设立对应的get和set方法用于修改和调用
代码演示：
class Employee {
private String name; // 私有成员变量
private int age;
// 公共方法用于访问私有成员变量
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 0) {
this.age = age;
} else {
System.out.println("年龄不能为负数");
}
}
}
// 创建对象并使用封装的方法访问成员变量
Employee emp = new Employee();
emp.setName("John");
emp.setAge(25);
System.out.println("姓名：" + emp.getName());
System.out.println("年龄：" + emp.getAge());
在上述示例中，我们创建了一个名为Employee的类，并在类中定义了私有成员变量name和age。通过公共的访问方法（getter和setter），我们可以控制对私有成员变量的访问，并确保数据的有效性。
3.构造方法（Constructor）：
构造方法是一种特殊的方法，用于创建和初始化对象。它在实例化类时自动调用，并负责执行一些初始设置或操作。
示例代码：
class Person {
private String name;
private int age;
// 构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 成员方法
public void displayInfo() {
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
}
}
// 创建对象时调用构造方法进行初始化
Person person = new Person("Alice", 30);
person.displayInfo();
在上述示例中，我们在类中定义了一个构造方法Person(String name, int age)，它接受两个参数并用于初始化成员变量name和age。在创建对象时，构造方法会被自动调用，并使用提供的参数进行对象的初始化
注意构造方法和构造方法的区别：
1.成员方法格式：
返回值类型 //(例如void，boolean，int等)// 方法名//（自己随便取一个）//（参数）{
方法体
}
2.构造方法：
类名 （参数）{
方法体
}
三：第六章 继承 重写 接口 this和super关键字 抽象类和抽象方法 接口 多态 static和final关键字
1. 继承：
继承是面向对象编程中的一种机制，通过它，一个类可以继承另一个类的属性和方法。被继承的类称为父类或超类，继承这些属性和方法的类称为子类。子类可以使用父类的成员变量和方法，并可以扩展或重写它们。
class Animal {
void eat() {
System.out.println("动物吃食物");
}
}
class Dog extends Animal {
void bark() {
System.out.println("狗在叫");
}
}
// 创建子类对象并调用继承的方法
Dog dog = new Dog();
dog.eat(); // 继承自父类
dog.bark(); // 子类自己的方法
在上述示例中，`Animal`类作为父类，`Dog`类继承了`Animal`类。`Dog`类可以访问`Animal`类的方法`eat()`，并且还可以定义自己的方法`bark()`。
2. 重写：
重写是指子类重新定义父类中已存在的方法，以便在子类中实现。重写方法必须具有相同的名称、参数列表和返回类型。
重写方法使用`@Override`注解来标识。注意单词拼写不要在这种地方扣分
class Animal {
void eat() {
System.out.println("动物吃食物");
}
}
class Dog extends Animal {
@Override
void eat() {
System.out.println("狗吃骨头");
}
}
// 创建子类对象并调用重写的方法
Dog dog = new Dog();
dog.eat(); // 重写的方法
在上述示例中，`Dog`类重写了父类`Animal`的方法`eat()`，并重新定义了狗吃骨头的行为。
3. 接口（Interface）：
接口是一种定义了一组抽象方法和常量的类型，它没有实现的方法体。类可以实现（implement）一个或多个接口，并实现接口中定义的所有方法。接口提供了一种规范，以确保实现类具有特定的行为。
示例代码：
interface Drawable {
void draw();
}
class Circle implements Drawable {
@Override
public void draw() {
System.out.println("画一个圆形");
}
}
// 创建实现类对象并调用接口方法
Circle circle = new Circle();
circle.draw(); // 实现接口的方法
在上述示例中，`Drawable`接口定义了一个抽象方法`draw()`，`Circle`类实现了该接口并提供了具体的实现。
注意：
1.接口是用interface 接口名的形式构成，没有class关键字的事情，不要乱加东西
2.接口里面的成员方法是抽象方法，书写时可省略abstract关键字
3.其他类可以通过implements关键字获取接口，例如class A implements B
4.接口里面的成员变量是常量，默认前缀为final static （可省略）。例如 final static int a=0；
5.接口中的抽象方法必须全部被实现
4. this 和 super 关键字：
this`关键字引用当前对象，在方法内部使用它可以访问当前对象的成员变量和方法。
`super`关键字引用父类对象，在子类中使用它可以调用父类的成员变量和方法。
示例代码：
class Animal {
String name;
void eat() {
System.out.println("动物吃食物");
}
}
class Dog extends Animal {
void display() {
String name = "Dog";
System.out.println(this.name); // 当前对象的name
System.out.println(super.name); // 父类的name
super.eat(); // 调用父类的方法
}
}
// 创建子类对象并调用方法
Dog dog = new Dog();
dog.name = "Tom";
dog.display();
在上述示例中，`Dog`类中的`display()`方法使用了`this`关键字来访问当前对象的`name`成员变量，使用`super`关键字来访问父类的`name`成员变量，并调用父类的`eat()`方法。
注意：
1.调用方法时默认调用父类的方法
2.使用this关键字首先调用本类有参方法，子类没有该方法的话，去调用父类有参方法
3.super关键字去调用父类有参，没有就报错喽，遭老罪了那就
5. 抽象类和抽象方法：
抽象类是不能被实例化的类，它用于定义一个或多个抽象方法。抽象方法是没有具体实现的方法，必须由子类进行重写实现。如果一个类包含抽象方法，那么它必须声明为抽象类。
示例代码：
abstract class Shape {
abstract void draw(); // 抽象方法
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("画一个圆形");
}
}
// 创建子类对象并调用抽象方法
Circle circle = new Circle();
circle.draw(); // 实现抽象方法
在上述示例中，`Shape`类是一个抽象类，其中定义了一个抽象方法`draw()`。`Circle`类继承了`Shape`类，并实现了抽象方法`draw()`。
6. 多态：
在多态中，父类的引用变量可以引用子类的对象，从而实现对不同子类对象的统一操作。
示例代码：
class Animal {
void sound() {
System.out.println("动物发出声音");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("狗在叫");
}
}
class Cat extends Animal {
@Override
void sound() {
System.out.println("猫在喵喵叫");
}
}
// 创建父类引用变量并调用子类的方法
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.sound(); // 多态调用，输出：狗在叫
animal2.sound(); // 多态调用，输出：猫在喵喵叫
在上述示例中，`Animal`类是父类，`Dog`和`Cat`类是子类。通过父类的引用变量分别指向不同的子类对象，可以实现对不同子类对象的方法调用。
7. static 和 final 关键字：
- `static`关键字用于声明静态成员变量和静态方法。静态成员变量属于类级别，所有对象共享同一份数据；静态方法不依赖于对象的实例，可以直接通过类名调用。
- `final`关键字用于声明常量、禁止方法重写和类继承。被`final`修饰的变量无法再次赋值，被`final`修饰的方法无法被子类重写，被`final`修饰的类无法被继承。
示例代码：
class MathUtil {
static final double PI = 3.14159; // 常量
static int add(int a, int b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
System.out.println(MathUtil.PI); // 静态成员变量访问
int sum = MathUtil.add(5, 3); // 静态方法调用
System.out.println(sum);
}
}
在上述示例中，`MathUtil`类包含一个静态成员变量`PI`和一个静态方法`add()`。通过类名直接访问静态成员变量和调用静态方法。
关于static的几点注意：（重点）
在使用`static`关键字时，有一些注意事项需要记住：
1. 静态成员属于类级别：使用`static`关键字声明的成员变量和方法属于类级别，而不是实例级别。这意味着所有的对象实例共享同一个静态成员，而不是为每个对象实例创建一个数据。
2. 静态成员可以直接通过类名访问：由于静态成员属于类，而不是对象实例，所以可以直接使用类名访问静态成员，而无需创建对象实例。
3. 静态方法不能访问非静态成员：静态方法只能访问静态成员，如果需要在静态方法中访问非静态成员，可以通过创建对象实例来间接访问。
4. 静态方法中不能使用this关键字：由于静态方法属于类级别，而不是实例级别，因此无法使用`this`关键字引用当前对象。`this`关键字只能在实例方法中使用。
5. 静态块的初始化：使用静态块可以在类加载时进行静态成员的初始化操作。静态块使用`static`关键字和花括号包裹，当类被加载时，静态块中的代码会被执行一次。
6. 静态方法的重写和覆盖：静态方法不能被子类重写，因为静态方法属于类级别，而不是实例级别。子类可以定义一个与父类中的静态方法同名的方法，但并不是重写，而是隐藏了父类的静态方法。
四：数组与集合类：
1.数组：
数组这一块只有排序比较重要一点，其他的都是些语法问题。
数组是一种数据结构，用于存储一组相同类型的元素。在Java中，数组是固定长度的，一旦创建后，其长度就不能再改变。以下是对数组的详细讲解：
声明数组：
在声明数组时，需要指定数组的类型和长度。语法格式如下：
```
<数据类型>[] <数组名称> = new <数据类型>[长度];
```
int[] numbers = new int[5]; // 声明一个长度为5的int类型数组
String[] names = new String[3]; // 声明一个长度为3的String类型数组
double[] scores = new double[10]; // 声明一个长度为10的double类型数组
```
初始化数组：
数组可以通过两种方式进行初始化：静态初始化和动态初始化。
- 静态初始化：在声明数组的同时为数组元素赋值。
示例：
int[] numbers = {1, 2, 3, 4, 5}; // 静态初始化int类型数组
String[] names = {"Alice", "Bob", "Charlie"}; // 静态初始化String类型数组
- 动态初始化：先声明数组，然后使用循环或逐个赋值的方式为数组元素赋值。
示例：
int[] numbers = new int[5]; // 动态初始化int类型数组
for (int i = 0; i < numbers.length; i++) {
numbers[i] = i + 1;
}
String[] names = new String[3]; // 动态初始化String类型数组
names[0] = "Alice";
names[1] = "Bob";
names[2] = "Charlie";
访问数组元素：
数组元素的访问使用索引（下标）来指定。数组索引从0开始，最大索引为数组长度减1。
示例：
int[] numbers = {1, 2, 3, 4, 5};
System.out.println(numbers[0]); // 输出第一个元素，结果为1
System.out.println(numbers[2]); // 输出第三个元素，结果为3
String[] names = new String[3];
names[0]
数组排序：
Arrays.sort() 方法可以对任意类型的数组进行排序，包括基本数据类型和引用类型。排序是按照元素的自然顺序进行的，对于数字类型，是按照升序排序，对于字符串类型，是按照字典顺序排序。
示例：
int[] numbers = {5, 2, 8, 1, 4};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers)); // 输出 [1, 2, 4, 5, 8]
String[] names = {"Alice", "Bob", "Charlie"};
Arrays.sort(names);
System.out.println(Arrays.toString(names)); // 输出 ["Alice", "Bob", "Charlie"]
注意 ：
需要导包，需要导包！不要在这种地方疑惑为什么代码报错，看看是不是没导包！
2.Arrlist讲解：
ArrayList 是 Java 中常用的动态数组（可变长度数组）实现，它位于 `java.util` 包中。ArrayList 提供了一系列方法来操作数组，使其具有动态扩展和缩减的能力。以下是对 ArrayList 的详细讲解以及使用时的注意事项：
1. 声明和实例化 ArrayList：
在使用 ArrayList 之前，需要先进行声明和实例化。语法格式如下：
ArrayList<元素类型> arrayList = new ArrayList<>();
```
示例：
ArrayList numbers = new ArrayList<>(); // 声明一个整数类型的 ArrayList
ArrayList names = new ArrayList<>(); // 声明一个字符串类型的 ArrayList
2. 添加和访问元素：
ArrayList names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
System.out.println(names.get(0)); // 输出第一个元素，结果为 "Alice"
System.out.println(names.get(2)); // 输出第三个元素，结果为 "Charlie"
3. 删除元素：
使用 `remove()` 方法可以根据索引或元素值来删除 ArrayList 中的元素。
示例：
ArrayList names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
names.remove(1); // 删除索引为1的元素，即 "Bob"
names.remove("Alice"); // 删除元素值为 "Alice" 的元素
4. 遍历 ArrayList：
- 使用普通的 for 循环和 `size()` 方法来遍历 ArrayList。
- 使用增强的 for 循环来遍历 ArrayList。
- 使用迭代器（Iterator）遍历 ArrayList。
示例：
ArrayList names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// 使用普通的 for 循环遍历
for (int i = 0; i < names.size(); i++) {
System.out.println(names.get(i));
}
// 使用增强的 for 循环遍历
for (String name : names) {
System.out.println(name);
}
// 使用迭代器遍历
Iterator iterator = names.iterator();
while (iterator.hasNext()) {
String name = iterator.next();
System.out.println(name);
}
注意事项：
- ArrayList 只能存储引用类型，不能存储基本数据类型。如果需要存储基本数据类型，可以使用其对应的包装类（例如 `Integer`、`Double`）。
。
3.Set类常用接口HashSet：
HashSet 是 Java 中的一种集合（Collection）类型，它实现了 Set 接口。HashSet 基于哈希表实现，它不保证元素的顺序，并且不允许包含重复元素。以下是对 HashSet 的详细讲解：
基本操作：
- 添加元素：使用 `add()` 方法向 HashSet 中添加元素。
- 删除元素：使用 `remove()` 方法根据元素值删除 HashSet 中的元素。
- 判断是否包含元素：使用 `contains()` 方法判断 HashSet 是否包含某个元素。
示例：
HashSet set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");
System.out.println(set.contains("Apple")); // 输出 true
System.out.println(set.contains("Grapes")); // 输出 false
set.remove("Banana");
System.out.println(set); // 输出 [Apple, Orange]
迭代遍历：
- 使用增强的 for 循环遍历 HashSet 中的元素。
- 使用迭代器（Iterator）遍历 HashSet 中的元素。
示例：
HashSet set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");
// 使用增强的 for 循环遍历
for (String fruit : set) {
System.out.println(fruit);
}
// 使用迭代器遍历
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
String fruit = iterator.next();
System.out.println(fruit);
}
4.set接口实现交集并集差集运算：
在 Java 中，集合的差集、交集和并集可以使用 Set 接口的实现类来实现。下面是对这些运算的详细讲解：
1. 差集（Difference）：
差集是指两个集合中不相同的元素组成的集合。在 Java 中，可以使用 Set 接口的 `removeAll()` 方法来实现差集运算。
示例：
Set set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
Set difference = new HashSet<>(set1);
difference.removeAll(set2);
System.out.println(difference); // 输出 [1, 2, 3]
2. 交集（Intersection）：
交集是指两个集合中共有的元素组成的集合。在 Java 中，可以使用 Set 接口的 `retainAll()` 方法来实现交集运算。
示例：
Set set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
Set intersection = new HashSet<>(set1);
intersection.retainAll(set2);
System.out.println(intersection); // 输出 [4, 5]
3. 并集（Union）：
并集是指两个集合中所有元素的集合，不包含重复的元素。在 Java 中，可以使用 Set 接口的 `addAll()` 方法来实现并集运算。
示例：
Set set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
Set union = new HashSet<>(set1);
union.addAll(set2);
System.out.println(union); // 输出 [1, 2, 3, 4, 5, 6, 7, 8]
注意事项：
- 运算结果的集合类型和原集合的类型保持一致，可以使用 Set 接口的实现类（如 HashSet）来存储运算结果。
5.HashMap基本操作：
1.什么是 HashMap
HashMap 是 Map 接口的实现类，它存储的内容是键值对(key-value)映射，其中 key、value 都可以为 null。
- HashMap 是无序的，即被存入到 HashMap 中的元素，在遍历 HashMap 时，其输出是无序的。
2.创建 HashMap 集合
使用以下代码即可创建一个 HashMap 集合。
public static void main(String[] args) {
// 创建 HashMap 集合,key 存储字符串类型，value 存储整数类型
Map hashMap = new HashMap<>();
}
3.HashMap 集合常用方法
常用方法示例：
public static void main(String[] args) {
// 创建 HashMap 集合,key存储字符串类型，value存储整数类型
Map hashMap = new HashMap<>();
// 添加元素
hashMap.put("李四",28);
hashMap.put("张三",26);
hashMap.put("王五",26);
// 根据 key 获取 value 值
Integer zs = hashMap.get("张三");
System.out.println(zs);
// 获取所有 key 值
Set strings = hashMap.keySet();
System.out.println(strings);
// 获取所有 value 值
Collection values = hashMap.values();
System.out.println(values);
// 根据 key 去除元素
Integer ww = hashMap.remove("王五");
System.out.println(ww);
// 根据 key-value 去除元素
boolean boole = hashMap.remove("李四", 28);
System.out.println(boole);
System.out.print(hashMap);
}
执行结果：
26
[李四, 张三, 王五]
[28, 26, 26]
26
true
{张三=26}
4.遍历 HashMap 集合 （较为重要）
public static void main(String[] args) {
// 创建 HashMap 集合,key 存储字符串类型，value 存储整数类型
Map map = new HashMap<>();
// 添加元素
map.put("李四",28);
map.put("张三",26);
map.put("王五",26);
//第一种：通过 keySet 遍历，普遍使用
for (String key : map.keySet()) {
System.out.println("key= "+ key + " and value= " + map.get(key));
System.out.println(----------);
}
//第二种:通过 entrySet 和迭代器遍历
Iterator> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
System.out.println(----------);
}
//第三种：通过 entrySet 和增强 for 循环遍历，推荐，尤其是容量大时
for (Map.Entry entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
System.out.println(----------);
}
}
执行结果 ：
key= 李四 and value= 28
key= 张三 and value= 26
key= 王五 and value= 26
----------
key= 李四 and value= 28
key= 张三 and value= 26
key= 王五 and value= 26
----------
key= 李四 and value= 28
key= 张三 and value= 26
key= 王五 and value= 26
标题五：Sting类：
public class StringDemo {
public static void main(String[] args) {
// 创建字符串对象
String str1 = "Hello";
String str2 = new String("World");
// 获取字符串长度
int length1 = str1.length();
int length2 = str2.length();
System.out.println("Length of str1: " + length1);
System.out.println("Length of str2: " + length2);
// 字符串拼接
String concatStr = str1.concat(str2);
System.out.println("Concatenated string: " + concatStr);
// 字符串比较
boolean isEqual = str1.equals(str2);
System.out.println("Are str1 and str2 equal? " + isEqual);
// 字符串截取
String substring = str1.substring(1, 3);
System.out.println("Substring of str1: " + substring);
// 字符串查找
int indexOf = str1.indexOf("l");
System.out.println("Index of 'l' in str1: " + indexOf);
// 字符串替换
String replacedStr = str1.replace("l", "L");
System.out.println("Replaced string: " + replacedStr);
// 字符串转换为字符数组
char[] charArray = str1.toCharArray();
System.out.print("Character array: ");
for (char c : charArray) {
System.out.print(c + " ");
}
}
}
输出结果：
Length of str1: 5
Length of str2: 5
Concatenated string: HelloWorld
Are str1 and str2 equal? false
Substring of str1: ell
Index of 'l' in str1: 2
Replaced string: HeLLo
Character array: H e l l o
在这个示例中，我们使用了 String 类的各种方法来展示其常见用法。首先，通过 length() 方法获取字符串的长度。然后，使用 concat() 方法将两个字符串进行拼接。使用 equals() 方法比较两个字符串是否相等。使用 substring() 方法截取子字符串。通过 indexOf() 方法查找指定字符在字符串中的索引位置。使用 replace() 方法替换字符串中的字符。最后，通过 toCharArray() 方法将字符串转换为字符数组，并使用循环遍历输出字符数组的内容。
其他方法总结：
标题六：日期类
1.Date类：构造方法
1.Date 类有如下两个构造方法。
-
Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可以获取本地的当前时间。
-
Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数。
这两个构造方法的使用示例如下：
Date date1 = new Date(); // 调用无参数构造函数
System.out.println(date1.toString()); // 输出：Wed May 18 21:24:40 CST 2016
Date date2 = new Date(60000); // 调用含有一个long类型参数的构造函数
System.out.println(date2); // 输出：Thu Jan 0108:01:00 CST 1970Date 类的无参数构造方法获取的是系统当前的时间，显示的顺序为星期、月、日、小时、分、秒、年。
Date 类带 long 类型参数的构造方法获取的是距离 GMT 指定毫秒数的时间，60000 毫秒是一分钟，而 GMT（格林尼治标准时间）与 CST（中央标准时间）相差 8 小时，也就是说 1970 年 1 月 1 日 00:00:00 GMT 与 1970 年 1 月 1 日 08:00:00 CST 表示的是同一时间。 因此距离 1970 年 1 月 1 日 00:00:00 CST 一分钟的时间为 1970 年 1 月 1 日 00:01:00 CST，即使用 Date 对象表示为 Thu Jan 01 08:01:00 CST 1970。
2.Date常用方法 :
2.SimpleDateFormat类
实例化：
// 空参构造器，采用默认格式
SimpleDateFormat sdf = new SimpleDateFormat();
// 带参指定格式的构造器
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
参数中对应字符意义如下：
y：年
M：月
d：日
h：时
m：分
s：秒EE：周几
格式化 ：
格式化指的是将储存日期的类转化为字符串
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MMM-dd hh:mm:ss");// 3*M
String format1 = sdf2.format(date);
System.out.println(format1); // 2020-六月-24 12:16:05
记录的日期的形式，这里主要指Date类转化为String类。
格式化主要靠调用format(Date date)方法，该方法按format指定的格式将Date对象转化为一个String对象，并返回这个String对象的引用。
Date date = new Date(); // 新建一个util.Date对象
System.out.println(date); // Wed Jun 24 11:48:10 CST 2020
String format = sdf.format(date); // 格式化：按默认的格式
System.out.println(format); // 20-6-24 上午11:48
String format1 = sdf1.format(date); // 格式化，按给定的格式
System.out.println(format1); // 2020-06-24 12:09:58
值得一提的是，MMM将以中文形式输出月份：
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MMM-dd hh:mm:ss");// 3*M
String format1 = sdf2.format(date);
System.out.println(format1); // 2020-六月-24 12:16:05
解析
解析是格式化的逆过程，指的是将表示日期的字符串转化为记载日期的类，这里指的是util.Date类。
解析主要依靠parse(String source)方法，返回一个Date对象的引用，同时会抛ParseException异常
// 空参构造器默认的格式是："20-6-24 上午11:48"，我们则必须使用与其相同的格式的字符串来表示日期
String str = "2020-6-22 下午1:21"; // 采取其默认格式化时的格式
Date date1 = sdf.parse(str); // 解析，获取一个Date类对象的引用
System.out.println(date1); // Mon Jun 22 13:21:00 CST 2020
3.综合应用 ：
import java.util.Date;
import java.text.SimpleDateFormat;
public class DateDemo {
public static void main(String[] args) {
// 创建当前日期对象
Date currentDate = new Date();
// 获取日期和时间信息
int year = currentDate.getYear() + 1900;
int month = currentDate.getMonth() + 1;
int day = currentDate.getDate();
int hours = currentDate.getHours();
int minutes = currentDate.getMinutes();
int seconds = currentDate.getSeconds();
// 格式化日期对象
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String formattedDate = dateFormat.format(currentDate);
// 输出日期信息
System.out.println("Year: " + year);
System.out.println("Month: " + month);
System.out.println("Day: " + day);
System.out.println("Hours: " + hours);
System.out.println("Minutes: " + minutes);
System.out.println("Seconds: " + seconds);
System.out.println("Formatted Date: " + formattedDate);
}
}
输出结果可能如下所示：
Year: 2023
Month: 6
Day: 2
Hours: 14
Minutes: 30
Seconds: 15
Formatted Date: 2023-06-02 14:30:15
在这个示例中，我们创建了一个当前日期对象 `currentDate`，然后使用各种方法获取日期和时间的信息，包括年、月、日、小时、分钟、秒。我们还使用 `SimpleDateFormat` 类将 `Date` 对象格式化为指定的日期字符串。
标题七：Integer类
Integer类在对象中包装了一个基本类型的int值。Integer类对象包含一个int类型的字段，此外，该类提供了多个方法，能在int类型和String类型之间相互转换，还提供了处理int类型时非常有用的其他的一些常量和方法
1.Integer类的构造方法
- Integer（int value）：构造一个新分配的Integer对象，它表示指定的int值。
- Integer（String s）：构造一个新分配的Integer对象，它表示String参数所指示的int值。
例如，以下代码分别使用以上两个构造方法来获取 Integer 对象：
Integer integer1=new Integer(100); //以 int 型变量作为参数创建 Integer 对象
Integer integer2=new Integer("100"); //以 String 型变量作为参数创建 Integer 对象2. Integer类常用方法
在实际的编码过程中，经常将字符串转换为int类型的数值，或者将int类型的数值转换为对应的字符串，一下代码演示如何实现这两种功能：
十分常用且好用*********
String str="456";
int num=Integer.parseInt(str); //将字符串转换为int类型的数值
int i=789;
String s=Integer.toString(i); //将int类型的数值转换为字符串标题八：文件操作
欢迎移步这个链接进步学习文件操作
http://t.csdn.cn/PUqla
非常感谢看到这里的读者们，感谢这段时间的支持，和你们自身的努力。最后祝愿大家逢考必过取得圆满成绩，下学期再见。拜拜喽
4