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 {@Overridevoid eat() {System.out.println("狗吃骨头");}
}// 创建子类对象并调用重写的方法
Dog dog = new Dog();
dog.eat(); // 重写的方法
在上述示例中,`Dog`类重写了父类`Animal`的方法`eat()`,并重新定义了狗吃骨头的行为。
3. 接口(Interface):
接口是一种定义了一组抽象方法和常量的类型,它没有实现的方法体。类可以实现(implement)一个或多个接口,并实现接口中定义的所有方法。接口提供了一种规范,以确保实现类具有特定的行为。
示例代码:
interface Drawable {void draw();
}class Circle implements Drawable {@Overridepublic 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); // 当前对象的nameSystem.out.println(super.name); // 父类的namesuper.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 {@Overridevoid 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 {@Overridevoid sound() {System.out.println("狗在叫");}
}class Cat extends Animal {@Overridevoid 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]); // 输出第三个元素,结果为3String[] 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<Integer> numbers = new ArrayList<>(); // 声明一个整数类型的 ArrayList
ArrayList<String> names = new ArrayList<>(); // 声明一个字符串类型的 ArrayList
2. 添加和访问元素:
ArrayList<String> 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<String> 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<String> 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<String> 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<String> 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")); // 输出 falseset.remove("Banana");
System.out.println(set); // 输出 [Apple, Orange]
迭代遍历:
- 使用增强的 for 循环遍历 HashSet 中的元素。
- 使用迭代器(Iterator)遍历 HashSet 中的元素。
示例:
HashSet<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");// 使用增强的 for 循环遍历
for (String fruit : set) {System.out.println(fruit);
}// 使用迭代器遍历
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {String fruit = iterator.next();System.out.println(fruit);
}
4.set接口实现交集并集差集运算:
在 Java 中,集合的差集、交集和并集可以使用 Set 接口的实现类来实现。下面是对这些运算的详细讲解:
1. 差集(Difference):
差集是指两个集合中不相同的元素组成的集合。在 Java 中,可以使用 Set 接口的 `removeAll()` 方法来实现差集运算。
示例:
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));Set<Integer> difference = new HashSet<>(set1);
difference.removeAll(set2);System.out.println(difference); // 输出 [1, 2, 3]
2. 交集(Intersection):
交集是指两个集合中共有的元素组成的集合。在 Java 中,可以使用 Set 接口的 `retainAll()` 方法来实现交集运算。
示例:
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));Set<Integer> intersection = new HashSet<>(set1);
intersection.retainAll(set2);System.out.println(intersection); // 输出 [4, 5]
3. 并集(Union):
并集是指两个集合中所有元素的集合,不包含重复的元素。在 Java 中,可以使用 Set 接口的 `addAll()` 方法来实现并集运算。
示例:
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));Set<Integer> 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<String, Integer> hashMap = new HashMap<>();}
3.HashMap 集合常用方法
常用方法示例:
public static void main(String[] args) {// 创建 HashMap 集合,key存储字符串类型,value存储整数类型Map<String, Integer> hashMap = new HashMap<>();// 添加元素hashMap.put("李四",28);hashMap.put("张三",26);hashMap.put("王五",26);// 根据 key 获取 value 值Integer zs = hashMap.get("张三");System.out.println(zs);// 获取所有 key 值Set<String> strings = hashMap.keySet();System.out.println(strings);// 获取所有 value 值Collection<Integer> 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<String, Integer> 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<Map.Entry<String, Integer>> it = map.entrySet().iterator();while (it.hasNext()) {Map.Entry<String, Integer> entry = it.next();System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());System.out.println(----------);}//第三种:通过 entrySet 和增强 for 循环遍历,推荐,尤其是容量大时for (Map.Entry<String, Integer> 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 1970
Date 类的无参数构造方法获取的是系统当前的时间,显示的顺序为星期、月、日、小时、分、秒、年。
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*MString 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 2020String format = sdf.format(date); // 格式化:按默认的格式System.out.println(format); // 20-6-24 上午11:48String 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*MString 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
java期末考试知识点复习总结相关推荐
- 数据库期末考试知识点复习(1~7章)
数据库总复习 绪论 1.1数据库系统概述 1.1.1数据库的四个基本概念 数据:数据是数据库中存储的基本对象. 定义:描述事物的符号记录称为数据: 数据的含义称为数据的语义,数据与其语义是不可分的. ...
- java期末考试复习题_JAVA期末考试复习试题
JAVA期末考试复习试题 1.使用Java语言编写的源程序保存时的文件扩展名是( ). (A).class (B).java (C).cpp (D).txt 2.设int a=-2,则表达式a> ...
- JAVA习题大全之java期末考试复习预测题一
JAVA习题大全 目录 JAVA习题大全 java期末考试复习预测题A java期末考试复习预测题B java期末考试复习预测题C java期末考试复习预测题D java期末考试复习预测题E java ...
- [知识点整理]中科院/国科大 自然语言处理nlp 期末考试知识点整理
本文为2022秋网安学院的自然语言处理课程期末复习知识点整理,水平有限,整理的答案可能有错误或遗漏,欢迎大家指正. 文章的第二部分内容参考了学校学姐的文章,文章写的很好,大家可以关注她:(133条消息 ...
- 某大学2021秋季学期Java期末考试范围概述
某大学2021秋季学期Java期末考试范围概述 Scope of inspection Not test Edition Scope of inspection 第四章 类与对象(三大特征必须掌握,以 ...
- java期末判断题题库_(java期末考试选择题题库.doc
(java期末考试选择题题库 1.分析以下程序: 1)public class x{ 2)public static void main(String[]args){ 3)String ol=new ...
- java期末考试复习题_java期末考试复习题库 试题题库.doc
java期末考试复习题库 试题题库 1 Java中对数据库查询结果集进行操作的对象是() ( A:Connection对象 B:Statement对象 C:DriverManager对象 D:Resu ...
- java期末考试试卷及答案文库_Java期末考试试卷答案A
Java期末考试试卷答案A JAVA程序设计试卷库(第5套)一.单选题(每小题 2 分,共 20 分)1.Java Application源程序的主类是指包含有( A )方法的类.A. main方法 ...
- java程序设计基础 期末试卷_(程序设计基础JAVA)期末考试试卷.doc
(程序设计基础JAVA)期末考试试卷 <程序设计基础(java)> 试题B卷 题号一二三四五六七八九总分得分 试卷说明:闭卷考试,时间120分钟. 一. 填空(本题共15空,每空2分,共3 ...
最新文章
- 【干货】Github标星1.2K,Visual Transformer 最全最新资源,包含期刊、顶会论文
- WCF服务端调用client.
- 计算机视觉与深度学习 | 几种常见的卡尔曼滤波算法理论
- 阿里云ECS官网域名映射及Tomcat配置调整,最终使用HTTPS和域名直接访问
- vi 编辑意外中断处理办法
- 用 50 年前 NASA 送阿波罗上天的计算机挖矿是什么体验?
- 谷歌Apps vs.微软Office
- 个推 Spark实践教你绕过开发那些“坑”
- Java多窗口编程示例
- 台式计算机怎么连手机热点,台式电脑怎么连接手机热点进行上网
- axure制作表单查询
- 甘超波:NLP五步觉察法
- linux signal
- 破解 excel 表格加密 高版本不行
- 关于BIRT的一些认识
- 第三章微分中值定理与导数应用
- 读,写,删,复集合脚本
- 重复性工作再也不用做啦?机器人自动化迎难而上
- Tesla数据标注系统解析
- ArcEngine根据属性分割要素类的实现方法