常用类库API

本文最后更新于:1 年前

Java常用类库API

JDK1.8中文帮助文档

JDK1.8英文帮助文档

Object

概述

java.lang.Object类是Java语言的根类,是所有类的父类,所有类都可以使用它的方法

一个类如果没有显示的定义继承,那么就会默认继承Object类

1
2
3
public class Hello /*extend Object*/{
//...
}

所有对象(包括数组)都实现这个类的方法

这里我们重点掌握Object的两个方法:

  1. toString方法
  2. equals方法

toString方法

例如

我们先定义一个Person类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package object;
//我们先定义一个标准的类,这个类默认继承Object类
public class Person {
private int age;
private String name;

public Person() {
}

public Person(int age, String name) {
this.age = age;
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

然后实例化Person,调用person对象的方法toString

1
2
3
4
5
6
7
8
9
10
11
package object;

public class ObjectDemo01 {
public static void main(String[] args) {
Person p1 = new Person();
String s1 = p1.toString();
System.out.println(s1);//object.Person@4f3f5b24 打印的是这个对象的包名+类名+@地址值
System.out.println(p1);//object.Person@4f3f5b24 直接打印对象名就相当于调用了Object类的toString方法
}
}

重写toString方法

如果我们想要打印对象的属性

我们就必须重写对象的toString方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package object;
//我们先定义一个标准的类,这个类默认继承Object类
public class Person {
private int age;
private String name;

public Person() {
}

public Person(int age, String name) {
this.age = age;
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}

在运行下面这段代码,打印的就是重写的toString方法的内容

1
2
3
4
5
6
7
8
9
10
11
12
package object;

public class ObjectDemo01 {
public static void main(String[] args) {
Person p1 = new Person();
String s1 = p1.toString();
System.out.println(s1);//Person{age=0, name='null'}
System.out.println(p1);//Person{age=0, name='null'}

}
}

如何判断一个类有没有重写toString方法,直接打印这个类的名字就可以知道

  • 没有重写:打印的是这个对象的包路径加地址值
  • 重写:按照其重写的方法进行打印

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package object;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class ObjectDemo02 {
public static void main(String[] args) {
Random random = new Random();
System.out.println(random);//java.util.Random@4f3f5b24

Scanner scanner = new Scanner(System.in);
System.out.println(scanner);//java.util.Scanner[delimiters=\p{javaWhitespace}+][position=0][match valid=false][need input=false][source closed=false][skipped=false][group separator=\x{2c}][decimal separator=\x{2e}][positive prefix=][negative prefix=\Q-\E][positive suffix=][negative suffix=][NaN string=\QNaN\E][infinity string=\Q∞\E]

ArrayList<Object> objects = new ArrayList<>();
objects.add(1);
objects.add(2);
System.out.println(objects);//[1, 2]
}
}

equals方法

equals方法:比较两个对象的地址值是否相同

之前在toString那里定义了一个Person类,这里我们这里来new两个Person对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package object;

public class ObjectDemo03 {
public static void main(String[] args) {
Person p1 = new Person(10,"小明");
Person p2 = new Person(9, "小红");

//这里我们将Person类里面重写toString方法的代码注释掉
System.out.println(p1);//object.Person@4f3f5b24
System.out.println(p2);//object.Person@15aeb7ab

boolean equals = p1.equals(p2);
System.out.println(equals);//false
}
}

重写equals方法

我们想要比较两个对象的属性

就必须重写equals方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package object;

//我们先定义一个标准的类,这个类默认继承Object类
public class Person {
private int age;
private String name;

public Person() {
}

public Person(int age, String name) {
this.age = age;
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

/*@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}*/

@Override
public boolean equals(Object obj) {
/*
这里隐含着一个多态
equals方法的参数传递的是Object类型的参数,无法直接调用其子类对象的属性、方法
这里我们先要强转obj为Person类
*/
Person p = (Person) obj;
boolean b = this.name.equals(p.name) && this.age == p.age;
return b;
}
}

再运行以下代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package object;

public class ObjectDemo03 {
public static void main(String[] args) {
Person p1 = new Person(10,"小明");
Person p2 = new Person(9, "小红");
Person p3 = new Person(9, "小红");

//这里我们将Person类里面重写toString方法的代码注释掉
System.out.println(p2);//object.Person@4f3f5b24
System.out.println(p3);//object.Person@15aeb7ab

boolean equals = p2.equals(p3);
System.out.println(equals);//true
}
}

这里的p2.equals(p3)就比较的是其属性是否相同

我们重写的这个equals方法只能比较的是两个相同类型的对象的属性

不能比较的是两个不同类型的对象,否则会报一个异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package object;

import java.util.Random;

public class ObjectDemo03 {
public static void main(String[] args) {
Person p1 = new Person(10,"小明");
Person p2 = new Person(9, "小红");
Person p3 = new Person(9, "小红");

//这里我们将Person类里面重写toString方法的代码注释掉
System.out.println(p2);//object.Person@4f3f5b24
System.out.println(p3);//object.Person@15aeb7ab

boolean equals = p2.equals(p3);
System.out.println(equals);//true

Random r1 = new Random();
boolean b1 = p1.equals(r1);
System.out.println(b1);//java.lang.ClassCastException 类转换异常
}
}

所以要在重写的equals方法里加一个判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package object;

//我们先定义一个标准的类,这个类默认继承Object类
public class Person {
private int age;
private String name;

public Person() {
}

public Person(int age, String name) {
this.age = age;
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

/*@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}*/

@Override
public boolean equals(Object obj) {
/*
这里隐含着一个多态
equals方法的参数传递的是Object类型的参数,无法直接调用其子类对象的属性、方法
这里我们先要强转obj为Person类
*/

if (obj instanceof Person) {
Person p = (Person) obj;
boolean b = this.name.equals(p.name) && this.age == p.age;
return b;
}
//不是Person类型的就直接返回false
return false;
}
}

思考:如何进一步优化?

我们看Idea给我们重写的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Override
public boolean equals(Object o) {
if (this == o) return true;
//getClass这里用的是反射,之后在反射里面会学
if (o == null || getClass() != o.getClass()) return false;

Person person = (Person) o;

if (age != person.age) return false;
return name != null ? name.equals(person.name) : person.name == null;
}

@Override
public int hashCode() {
int result = age;
result = 31 * result + (name != null ? name.hashCode() : 0);
return result;
}

我们再看java7以后重写的equals方法

1
2
3
4
5
6
7
8
9
10
11
12
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);//这里比较两个对象的name直接用的Objects类的equals方法
}

@Override
public int hashCode() {
return Objects.hash(age, name);
}

Objects类

JDK7添加了一个Objects工具类,它提供了一些方法操作对象,它由一些静态的方法组成,这些方法是空指针安全的或容忍空指针的,它用于计算对象的hashCode,返回对象的字符串表示形式,比较两个对象。

比较两个对象

1
public static boolean equals(Object a, Object b); 

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package object;

import java.util.Objects;

public class ObjectsDemo01 {
public static void main(String[] args) {
String s1 = null;
String s2 = "abc";

/*boolean b1 = s1.equals(s2);//java.lang.NullPointerException 空指针异常
System.out.println(b1);*/

boolean b2 = Objects.equals(s1, s2);
System.out.println(b2);//false
}
}

Object总结

Object类

  1. 介绍
    1. Object类是所有类的父类(所有类都会直接或者间接继承Object类)
    2. Object类提供了一些方法
  2. toString方法
    1. 作用:打印对象的信息
    2. 重写前:打印的是包名+类名+@地址值
    3. 重写后:按重写的方法打印
  3. equals方法
    1. 作用:判断两个对象是否相同
    2. 重写前:比较的是两个对象的地址值
    3. 重写后:按重写的方法进行比较

Objects类

  1. equals方法
    1. 也是比较两个对象是否相同,添加了一个非空判断,防止空指针异常

Math

概述

java.lang.Math类包含用于执行基本数学运算的方法

其所有方法均是静态方法,可以直接类名.方法名调用

常用方法

1
public static double abs(double num);//绝对值
1
public static double ceil(double nun);//向上取整
1
public static double floor(double nun);//向下取整
1
public static long round(double num);//四舍五入

基本运算方法

绝对值

1
double d1 = Math.abs(-5);//5

向上取整

1
double d2 = Math.ceil(3.1)//4

向下取整

1
double d3 = Math.floor(1.9)//1

四舍五入

1
long l1 = Math.round(4.5)//5

练习

请使用Math相关的API,计算-10.8到5.9之间,绝对值大于6或者小于2.1的整数有多少个?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package math;

//请使用Math相关的API,计算-10.8到5.9之间,绝对值大于6或者小于2.1的整数有多少个?
public class MathDemo01 {
public static void main(String[] args) {
//定义一个最大值一个最小值
double max = 5.9;
double min = -10.8;

//定义一个数用于记数
int num = 0;

//外层for循环用于获-10.8————5.9的整数,内层if判断绝对值是否大于6或小于2.1
for (double i = Math.ceil(min); i <= max; i++) {
if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
//计数+1
num++;

}
}

//打印结果
System.out.println(num);

}
}

Random

概念

java.util.Random类用于生成随机数字

如何使用

构造方法

1
Random r = new Random();

使用

  • 获取一个随机的int数字
  • 获取指定范围的随机数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package random;

import java.util.Random;

public class RandomDemo01 {

public static void main(String[] args) {
//new一个Random
Random r1 = new Random();
//调用Random的nextInt()方法
int i = r1.nextInt();
System.out.println(i);

}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package random;

import java.util.Random;

public class RandomDemo02 {
public static void main(String[] args) {
Random r1 = new Random();

for (int i1 = 0; i1 < 10; i1++) {
int i = r1.nextInt(10);//[0,10)
System.out.println(i);
}
}
}

练习

根据给定的数字n,返回指定[1,n]之间的随机整数

1
2
3
4
5
6
7
```



猜数字小游戏:电脑生成一个指定范围的整数,用户来猜,才对结束程序

```java

File

简介

java.io.File类

文件和目录路径名的抽象表现形式

java把电脑的文件和文件夹封装成了一个File类,我们可以通过操作File类来使用文件和文件夹

File类的方法

  • 创建文件或文件夹
  • 删除文件或文件夹
  • 获取文件或文件夹
  • 对文件夹进行遍历
  • 获取文件大小

File类是一个与系统无关的类,任何操作系统都可以使用这个File类的方法

记住三个单词

  • file:文件
  • directory:文件夹
  • path:路径

File类的静态成员变量

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package file;

import java.io.File;

public class FileDemo01 {
public static void main(String[] args) {

/*
static String pathSeparator
与系统相关的路径分隔符字符,为方便起见,表示为字符串。
static char pathSeparatorChar
与系统相关的路径分隔符。
static String separator
与系统相关的默认名称 - 分隔符字符,以方便的方式表示为字符串。
static char separatorChar
与系统相关的默认名称分隔符。

以后要操作路径不能把路径写死
windows C:\a\a.txt
linux C:/a/a.txt
代码中 "C:"+File.separator+"a"+File.separator+"a.txt"
*/
String pathSeparator = File.pathSeparator;
System.out.println(pathSeparator);//; 路径分隔符 windows; linux:

String separator = File.separator;
System.out.println(separator);//\ 文件名称分隔符 windows\ linux/




}
}

绝对路径与相对路径

绝对路径:一个完整的路径

以盘符开始的路径

​ c:\a.txt

相对路径:一个简化的路径

相对于当前项目的根目录

​ b.txt

注:

  • 路径不区分大小写(windows),Linux区分大小写

  • 反斜杠表示转义字符,两个反斜杠表示一个普通的反斜杠

File类的构造方法

  • File(File parent, String child) :从父抽象路径名和子路径名字符串创建新的 File实例。
  • File(String pathname) :通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
  • File(String parent, String child) :从父路径名字符串和子路径名字符串创建新的 File实例。
  • File(URI uri) :通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
package file;

import java.io.File;

/*
File(File parent, String child)
从父抽象路径名和子路径名字符串创建新的 File实例。
File(String pathname)
通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File(String parent, String child)
从父路径名字符串和子路径名字符串创建新的 File实例。
File(URI uri)
通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

*/
public class FileDemo02 {
public static void main(String[] args) {
show01();

show02("C:\\", "a.txt");

show03();
}

/*
File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。
参数:
File parent 父路径
String child 子路径
好处:
父路径是File类,可以使用File类的方法进行操作
*/
private static void show03() {
File parent = new File("C:\\");
File file = new File(parent, "a.txt");
System.out.println(file);//C:\a.txt
}


/*
File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例。
参数:
String parent 父路径
String child 子路径
好处:
父路径和子路径可以单独书写,使用灵活
*/
private static void show02(String parent, String child) {
File file = new File(parent, child);
System.out.println(file);//C:\a.txt
}

/*
File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
参数:
String pathname 字符串的路径名称
路径名称可以是以文件结尾,也可以是以文件夹结尾
路径可以是相对路径,也可以是绝对路径
路径可以存在,也可以不存在
创建File类对象,只是把字符串路径封装为File对象,不考虑路径真实情况
*/
private static void show01() {
File f1 = new File("C:\\Users\\a.txt");
System.out.println(f1);//C:\Users\a.txt 重写了Object的toString方法

File f2 = new File("C:\\Users");
System.out.println(f2);//C:\Users

File f3 = new File("a.txt");
System.out.println(f3);//a.txt
}
}

常用方法

获取功能的方法

  • public String getAbsolutePath()//返回绝对路径名称字符串
  • public String getPath()//返回路径名称字符串
  • public String getName()//返回文件或目录名称
  • public Long length()//返回文件大小

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package file;

import java.io.File;
import java.sql.SQLOutput;

public class FileDemo03 {
public static void main(String[] args) {
show01();

show02();

show03();

show04();
}

/*
public Long length()//返回文件大小
获取的是构造方法指向的文件大小 以字节为单位


*/
private static void show04() {
File f1 = new File("C:\\Users\\MaLin\\Desktop\\JavaCode\\背景图片1.jpg");
long length = f1.length();
System.out.println(length);//450171
}

/*
public String getName()//返回文件或目录名称
获取构造方法中传递的路径的结尾部分(文件或文件夹)
*/
private static void show03() {
File f1 = new File("C:\\Users\\MaLin\\Desktop\\JavaCode\\a.txt");
String name1 = f1.getName();
System.out.println(name1);//a.txt

File f2 = new File("C:\\Users\\MaLin\\Desktop\\JavaCode");
String name2 = f2.getName();
System.out.println(name2);//JavaCode
}

/*
public String getPath()//返回路径名称字符串
获取构造方法中传递的路径

toString方法调用的就是getPath方法
源码:
public String toString() {
return getPath();
}
*/
private static void show02() {
File f1 = new File("C:\\Users\\MaLin\\Desktop\\JavaCode\\src");
File f2 = new File("a.txt");
String p1 = f1.getPath();
String p2 = f2.getPath();
System.out.println(p1);//C:\Users\MaLin\Desktop\JavaCode\src
System.out.println(p2);//a.txt

System.out.println(f1);//C:\Users\MaLin\Desktop\JavaCode\src
System.out.println(f1.toString());//C:\Users\MaLin\Desktop\JavaCode\src
}

/*
public String getAbsolutePath()//返回绝对路径名称字符串
获取构造方法中传递的绝对路径
*/
private static void show01() {
File f1 = new File("C:\\Users\\MaLin\\Desktop\\JavaCode\\src");
String absolutePath1 = f1.getAbsolutePath();
System.out.println(absolutePath1);//C:\Users\MaLin\Desktop\JavaCode\src

File f2 = new File("a.txt");
String absolutePath2 = f2.getAbsolutePath();
System.out.println(absolutePath2);//C:\Users\MaLin\Desktop\JavaCode\a.txt
}
}

判断功能的方法

  • public boolean exists():File类表示的文件或文件夹是否存在
  • public boolean isFile() :File类表示的是否是文件
  • public boolean isDirectory() :File类表示的是否是文件夹

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package file;

import java.io.File;

/*
File类的判断功能方法
public boolean exists()
public boolean isFile()
public boolean isDirectory()
注意事项
isFile()
isDirectory()
这两个方法使用前提:路径必须存在,否则都返回false
使用前最好用exists()方法判断一下路径是否存在

*/
public class FileDemo04 {
public static void main(String[] args) {
demo01();
}

private static void demo01() {
File file1 = new File("C:\\Users\\MaLin\\Desktop\\JavaCode");
System.out.println(file1.exists());//true

File file2 = new File("C:\\Users\\MaLin\\Desktop\\JavaCode\\背景图片1.jpg");
System.out.println(file2.exists());//true

System.out.println("=======================================");


if (file1.exists() && file2.exists()) {
System.out.println(file1.isFile());//false
System.out.println(file2.isFile());//ture
System.out.println(file1.isDirectory());//false
System.out.println(file2.isDirectory());//true
}
}
}


创建和删除功能的方法

  • public boolean createNewFile():当且仅当该名称文件不存在时,创建一个新的空的文件。
  • public boolean delete():删除由此File表示的文件或目录
  • public boolean mkdir():创建由此File表示的文件夹
  • public boolean mkdirs():创建由此File表示的目录,包括任何必须但不存在的父目录

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package file;

import java.io.File;
import java.io.IOException;

public class FileDemo05 {
public static void main(String[] args) throws IOException {
//show01();
//show02();
show03();

}

/*
public boolean delete()
删除构造方法中创建的文件或文件夹
返回值
false文件夹中有内容(文件或文件夹)不会删除文件夹 构造方法中不存在路径
true删除成功
注意事项
delete()方法会直接删除文件或文件夹,不会走回收站
*/
private static void show03() {
File f1 = new File("a.txt");
boolean b1 = f1.delete();
System.out.println(b1);

File f2 = new File("a");
boolean b2 = f2.delete();
System.out.println(b2);

File f3 = new File("111");
boolean b3 = f3.delete();
System.out.println(b3);
}

/*
public boolean mkdir()
public boolean mkdirs()
返回值
false
true
注意
此方法只能创建文件夹
*/
private static void show02() {

File f1 = new File("a");
boolean b1 = f1.mkdir();
System.out.println(b1);//true

File f2 = new File("111\\222\\333");
boolean b2 = f2.mkdirs();
System.out.println(b2);//true

}

/*
public boolean creatNewFile()
创建文件的路径和名称在构造方法中给出
返回值
false文件已存在,创建文件失败
true文件不存在,创建文件成功
注意事项
只能创建文件
创建文件的路径必须存在,否则会抛出异常
creatNewFile()这个方法声明抛出了IOException,我们调用这个方法要么throws这个异常,要么try catch这个异常

*/
private static void show01() throws IOException {

File f1 = new File("1.txt");
boolean b1 = f1.createNewFile();
System.out.println("b1:" + b1);


}
}

遍历目录的方法

  • public String[] list():返回一个String数组,表示该File类目录中的所有子文件或目录
  • public File[] listFile():返回一个File数组,表示该File类目录的所有子文件或目录

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package file;

import java.io.File;

/*
public String[] list():返回一个String数组,表示该File类目录中的所有子文件或目录
public File[] listFile():返回一个File数组,表示该File类目录的所有子文件或目录

list() listFile()方法遍历的是构造方法中传递的目录
如果构造方法中传递的目录不存在或者传递的不是一个目录路径,会报空指针异常
*/
public class FileDemo06 {

public static void main(String[] args) {
show01();
//show02();
}

private static void show02() {
File f1 = new File("C:\\Users\\MaLin\\Desktop\\JavaCode");
File[] files = f1.listFiles();
for (File fileList : files) {
System.out.println(fileList);/*
C:\Users\MaLin\Desktop\JavaCode\.idea
C:\Users\MaLin\Desktop\JavaCode\1.txt
C:\Users\MaLin\Desktop\JavaCode\JavaCode.iml
C:\Users\MaLin\Desktop\JavaCode\out
C:\Users\MaLin\Desktop\JavaCode\src
C:\Users\MaLin\Desktop\JavaCode\背景图片1.jpg
C:\Users\MaLin\Desktop\JavaCode\背景图片2.jpg
C:\Users\MaLin\Desktop\JavaCode\背景图片3.jpg
*/
}
}

private static void show01() {
File f1 = new File("C:\\Users\\MaLin\\Desktop\\JavaCode");
String[] fl1 = f1.list();
for (String fileList: fl1
) {
System.out.println(fileList);/*
.idea
1.txt
JavaCode.iml
out
src
背景图片1.jpg
背景图片2.jpg
背景图片3.jpg
*/

}
}



}

包装类

概念

基本数据类型的数据,使用起来很方便,但是没有对用的方法来操作这些数据,我们可以使用一个类,把基本数据类型包装起来,这个类叫包装类

在包装类中,我们可以定义一些方法来操作基本数据类型的数据

例如Integer类、Double类。。。位于Java.lang包下

基本数据类型 对应的包装类
byte Byte
short Short
int Interger
long Long
float Float
double Double
char Character
boolean Boolean

装箱与拆箱

装箱:把基本数据类型的数据,包装到包装类中

构造方法

1
Integer (int value)//构造一个新分配的Integer对象,它表示指定的int值
1
2
Integer (String s)//构造一个新分配的Integer对象,它表示String参数所指示的int值
//传递的字符串必须是基本类型的字符串,否则会抛出异常 "100"正确 "a"抛出异常

静态方法

1
static Integer valueOf(int i)//返回一个表示指定的int值的Interger实例
1
static Integer valueOf(String s)//返回保存指定的String的值的Integer对象

拆箱:取出包装类中的基本数据类型的数据

成员方法

1
int intValue()//以int类型返回该Integer的值

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package integer;

public class IntegerDemo01 {
public static void main(String[] args) {
//装箱
//构造方法
Integer in1 = new Integer(1);//该方法已经过时了
System.out.println(in1);//1 重写了toString方法

Integer in2 = new Integer("1");
System.out.println(in2);//1

//静态方法
Integer in3 = Integer.valueOf(1);
System.out.println(in3);

Integer in4 = Integer.valueOf("1");
//Integer in4 = Integer.valueOf("a");//Exception in thread "main" java.lang.NumberFormatException 数字格式化异常
System.out.println(in4);

//拆箱
int i = in1.intValue();
System.out.println(i);//1
}
}

自动装箱与自动拆箱

​ 基本数据类型和包装类之间可以自动的相互转换(JDK1.5以后)

自动装箱

直接把int类型的整数包装起来

1
Integer in1 = 1;//相当与Integer in1 = new Integer(1);

自动拆箱

如上面的in1是包装类,无法直接参与运算,可以自动转换为基本数据类型的数据在参与计算

1
2
3
4
5
/*
in + 2;相当于in.intValue() + 2;自动拆箱
in = in + 2;相当于in = new Integer(3);自动装箱
*/
in1 = in1 + 2

ArrayList集合无法直接存储整数,可以存储包装类

1
2
3
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
int i = list.get(0);

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package integer;

import java.util.ArrayList;

public class IntegerDemo02 {
public static void main(String[] args) {
//自动装箱
Integer in1 = 1;
//自动拆箱
in1 = in1 + 2;
System.out.println(in1);//3

ArrayList<Integer> list = new ArrayList<>();
list.add(1);//自动装箱,相当于list.add(new Integer(1));
//Integer integer = list.get(0);返回的是包装类Integer
int i = list.get(0);//自动拆箱,相当于list.get(0).intValue();
System.out.println(i);
}
}

基本数据类型与字符串相互转换

基本类型转为String

  1. 基本数据类型的值+””

    1
    String s = 100 + "";
  2. 使用包装类中的静态方法

    1
    static String toString(int i)//返回指定int类型数据的String对象
  3. 使用String类中的静态方法

    1
    static String valueOf(int i)//返回int类型的数据

String转为对应的基本类型

  1. 使用包装类的静态方法parseXX(“字符串”)

    1
    2
    3
    static int parseInt(String s);
    static double parseDouble(String s);
    ...

注:

字符串的形式必须为基本类型(char类型除外)否则会报java.lang.NumberFormatException数字格式化异常

1
int i =  Integer.parseInt("a");//java.lang.NumberFormatException 数字格式化异常

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package integer;

public class IntegerDemo03 {
public static void main(String[] args) {
//基本数据类型——>String
//基本数据类型的值+""
String s1 = 100 + "";
System.out.println(s1 + 100);//100100

//使用包装类的静态方法
String s2 = Integer.toString(100);
System.out.println(s2 + 100);//100100

//使用String类的valueOf方法
String s3 = String.valueOf(100);
System.out.println(s3 + 100);//100100

//字符串-->基本数据类型
//包装类的parseXX("s")方法
int i = Integer.parseInt("100");
System.out.println(i + 100);//200

//int i2 = Integer.parseInt("a");//java.lang.NumberFormatException 数字格式化异常

}
}

Date

概述

java.util.Date:表示日期、时间的类,精确到毫秒

毫秒值

1000毫秒 = 1秒

可以用于时间和日期的计算

  1. 把日期转换为毫秒进行计算

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    package date;

    /*
    时间原点
    19700101 00:00:00 (英国格林威治)
    19700101 08:00:00 (中国 东八区时间+8h)

    */
    public class DateDemo01 {
    public static void main(String[] args) {
    //获取当前系统时间到时间原点一共经历了多少毫秒
    System.out.println(System.currentTimeMillis());
    }
    }


  2. 把毫秒转换为日期

构造方法

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package date;

import java.util.Date;

public class DateDemo02 {
public static void main(String[] args) {
dateDemo01();//Thu May 13 15:44:39 CST 2021
dateDemo02(0L);//Thu Jan 01 08:00:00 CST 1970

}



private static void dateDemo01() {
Date date = new Date();
System.out.println(date);//直接打印调用的是date对象的toString方法,它重写了toString方法
}

private static void dateDemo02(Long l) {
Date date = new Date(l);
System.out.println(date);
}
}

成员方法

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package date;

import java.util.Date;

public class DateDemo03 {
public static void main(String[] args) {
dataDemo03();
}

private static void dataDemo03() {
Date date = new Date();
long time = date.getTime();//该成员方法返回的是一个long类型的数值 到时间原点有多少毫秒
System.out.println(time);
}
}

DateFormat类

java.text.DataFormat:时间日期的格式化子类的抽象类

作用:

  1. 格式化(日期–>文本)

  2. 解析(文本–>日期)

成员方法:

1
SimpleDateFormat(String pattern) //用于给定的模式和默认语言环境的日期格式符号构造

参数:String pattern用于指定模式

模式:区分大小写

simpleDataFormat

例如:

1
2
//"yyyy-MM-dd HH:mm:ss"
//"yyyy年MM月dd日 HH时mm分ss秒"

注:

模式中的字母不能改,连接模式的符号可以改变。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDataFormatDemo01 {
public static void main(String[] args) throws ParseException {
sdf1();
sdf2();

}


/*
使用DateFormat中的format方法把日期转换为文本
1.创建SimpleDataFormat对象并指定对应模式
2.调用对象的format(date)方法把传进来的date日期格式化为指定模式的文本
*/
private static void sdf1() {
//1.创建SimpleDataFormat对象并指定对应模式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//2.调用对象的format(date)方法把传进来的date日期格式化为指定模式的文本
Date date = new Date();
String text = sdf.format(date);
System.out.println(date);//Thu May 13 18:13:14 CST 2021
System.out.println(text);//20210513181314
}

/*
使用DataFormat中的parse方法把文本转换为日期
1.创建SimpleDataFormat对象并指定对应模式
2.调用对象的format(date)方法把传进来的date日期格式化为指定模式的文本

注:
public Date parse(String source) throws ParseException
parse方法声明了一个异常ParseException解析异常
如果字符串和构造方法中的模式不一样,就会抛出此异常
调用一个抛出异常的方法就必须处理这个异常
1.throws继续抛出异常
2.try...catch这个异常
*/
private static void sdf2() throws ParseException {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
Date date = sdf.parse("2021年05月13日 18时13分14秒");
System.out.println(date);

}
}

练习

计算一个人活了多少天

  1. Scanner获取这个人指定模式的出生日期,计算其对应的毫秒值
  2. 获取当前时间的毫秒值
  3. 两个毫秒值相减,把计算结果转换为天
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/*
计算一个人活了多少天

1. Scanner获取这个人指定模式的出生日期,计算其对应的毫秒值
2. 获取当前时间的毫秒值
3. 两个毫秒值相减,把计算结果转换为天
*/
public class Demo01 {
public static void main(String[] args) throws ParseException {
//新建Scanner对象用于获取用户输入
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的出生日期,格式为yyyy-MM-dd");

//把用户输入的日期转换为毫秒值
String birthDate = sc.next();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(birthDate);

//拿到两个毫秒值
long time1 = date.getTime();
long time2 = new Date().getTime();

//毫秒转换为日
System.out.println((time2-time1)/1000/60/60/24);
sc.close();

}
}

System

java.lang.System类提供了大量的静态方法,可以获取与系统相关的信息或系统级操作

常用方法

  • public static long currentTimeMillis():返回以毫秒只为单位的当前时间
  • public static void arraycopy(Object src, int srcPocs, Object dest, int destPos, int length):数组中指定的的数据拷贝到另一个数组中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package system;

import java.util.Arrays;

/*
- public static long currentTimeMillis() 返回以毫秒只为单位的当前时间
- public static void arraycopy(Object src, int srcPocs, Object dest, int destPos, int length)
数组中指定的的数据拷贝到另一个数组中
*/
public class SystemDemo01 {

public static void main(String[] args) {
//demo01();
demo02();
}

/*
public static void arraycopy(Object src, int srcPocs, Object dest, int destPos, int length)
数组中指定的的数据拷贝到另一个数组中
参数
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
练习
将src数组的前三个元素复制到dest数组的元素的前三个位置
src:[1, 2, 3, 4, 5]
dest:[6, 7, 8, 9, 10]
复制后
dest:[1, 2, 3, 9, 10]

*/
private static void demo02() {
int[] src = {1, 2, 3, 4, 5};
int[] dest = {6, 7, 8, 9, 10};
System.out.println("复制前:" + Arrays.toString(dest));//复制前:[6, 7, 8, 9, 10]
System.arraycopy(src, 0, dest, 0, 3);
System.out.println("复制后:" + Arrays.toString(dest));//复制后:[1, 2, 3, 9, 10]
}

/*
`public static long currentTimeMillis()`:返回以毫秒只为单位的当前时间
用来测试程序的效率
练习
用for循环打印1-999所需的毫秒值

*/
private static void demo01() {

long s = System.currentTimeMillis();
for (int i = 1; i <= 999; i++) {
System.out.println(i);
}
long e = System.currentTimeMillis();
System.out.println("程序共耗时:" + (e - s) + "毫秒");

}
}

String

概述

java.lang.String代表字符串,程序中的所有字符”abc”,都可以看为实现这个类的实例

使用步骤

常用方法

练习

StringBuffer

java.lang.StringBuffer

1
public final class StringBuffer

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区,但不能修改。虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。

构造方法

StringBuffer()
构造一个其中不带字符的字符串缓冲区,其初始容量为 16 个字符。
StringBuffer(CharSequence seq)
public java.lang.StringBuilder(CharSequence seq) 构造一个字符串缓冲区,它包含与指定的 CharSequence 相同的字符。
StringBuffer(int capacity)
构造一个不带字符,但具有指定初始容量的字符串缓冲区。
StringBuffer(String str)
构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容。

StringBuilder 字符串缓冲区

字符串缓冲区可以提高字符串的操作效率

底层也是一个数组,但是没有被final修饰,可以改变长度

byte[] byte = new byte[16]

StringBuilder在内存中始终是一个数组,占用空间小,效率高。

如果超出StringBuilder的容量,他会自动扩容

构造方法

  • public StringBuilder():构造一个空的StringBuilder容器
  • public StringBuilder(String str):构造一个StringBuilder容器,并将字符串添加进去
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package stringbuilder;
/*
java.lang.StringBuilder 字符串缓冲区可以提高字符串的操作效率
构造方法
public StringBuilder():构造一个空的StringBuilder容器
public StringBuilder(String str):构造一个StringBuilder容器,并将字符串添加进去
*/
public class StringBuilderDemo01 {
public static void main(String[] args) {
StringBuilder stringBuilder1 = new StringBuilder();
System.out.println("sbu1:" + stringBuilder1);

StringBuilder stringBuilder2 = new StringBuilder("abc");
System.out.println("sbu2:" + stringBuilder2);
}
}

成员方法

  • public StringBuilder append(...):添加任意类型的数据的字符串形式,并返回当前对象本身
  • public String toString():将StringBuilder对象转换为String对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package stringbuilder;

import java.util.Locale;

/*
- public StringBuilder append(...):添加任意类型的数据的字符串形式,并返回当前对象本身
- public String toString():将StringBuilder对象转换为String对象
*/
public class StringBuilderDemo02 {
public static void main(String[] args) {
StringBuilder sbu1 = new StringBuilder();
/*
sbu1.append("abc");
sbu1.append(true);
sbu1.append(1);
sbu1.append('a');
System.out.println(sbu1);*/

/*
链式编程:方法的返回值就是对象,可以根据对象继续调用方法
*/
System.out.println("abc".toUpperCase());//ABC 转换为大写字母
sbu1.append("abc").append(true).append(1).append('a');
System.out.println(sbu1);

}
}

1
2
3
4
5
6
7
8
9
10
11
package stringbuilder;

public class StringBuilderDemo03 {
public static void main(String[] args) {
//StringBuilder--->String
StringBuilder stringBuilder = new StringBuilder("hello");
String s1 = stringBuilder.toString();
System.out.println(s1);

}


博主码字不易,本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!