JavaSE个人复习式整理知识点之面向对象二（static关键字）以及常用API[一]

最新推荐文章于 2024-01-07 15:46:09 发布

扯淡吧 Pino曹

最新推荐文章于 2024-01-07 15:46:09 发布

阅读量212

点赞数 1

分类专栏：初学Java

本文链接：https://blog.csdn.net/qq_44980917/article/details/118916102

版权

初学Java 专栏收录该内容

32 篇文章 1 订阅

订阅专栏

常用API[一]、static关键字

1 API

概述

API(Application Programming Interface)，应⽤程序编程接⼝。Java API是⼀本程序员的“字典”，是JDK提供给我们使⽤的类的说明⽂档。这些类将底层的代码实现封装了起来，我们不需要关⼼这些类是如何实现的，只需要学习这些类如何使⽤即可。所以我们可以通过查询API的⽅式，来学习Java提供的类，并得知如何使⽤它们。

JDK包结构

为了便于使⽤和维护，JDK类库按照包结构划分，不同功能的类划分在不同的包中；
经常使⽤的包如下表所示：

包	功能
java.lang	Java程序的基础类，如字符串、多线程等，该包中的类使⽤的频率⾮常⾼，不需要import，可以直接使⽤
java.util	常⽤⼯具类，如集合、随机数产⽣器、⽇历、时钟等
java.io	⽂件操作、输⼊/输出操作
java.net	⽹络操作
java.math	数学运算相关操作
java.sql	数据库访问
java.text	处理⽂字、⽇期、数字、信息的格式

API使⽤步骤

打开帮助⽂档。
点击显示，找到索引，看到输⼊框。
你要找谁？在输⼊框⾥输⼊，然后回⻋。
看包。java.lang下的类不需要导包，其他需要。
看类的解释和说明。
学习构造⽅法。
使⽤成员⽅法。

2 Scanner类

了解了API的使⽤⽅式，我们通过Scanner类，熟悉⼀下查询API，并使⽤类的步骤。

2.1 什么是Scanner类

⼀个可以解析基本类型和字符串的简单⽂本扫描器。例如，以下代码使⽤户能够从System.in中
读取⼀个数：

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

备注：System.in 系统输⼊指的是通过键盘录⼊数据。

2.2 引⽤类型使⽤步骤

导包

使⽤import关键字导包，在类的所有代码之前导包，引⼊要使⽤的类型，java.lang包下的所有类⽆需导⼊。格式：

import 包名.类名;

举例：

java.util.Scanner;

创建对象

使⽤该类的构造⽅法，创建⼀个该类的对象。格式：

数据类型 变量名 = new 数据类型(参数列表);

举例：

Scanner sc = new Scanner(System.in);

调⽤⽅法

调⽤该类的成员⽅法，完成指定功能。格式：

变量名.⽅法名();

举例：

int i = sc.nextInt(); // 接收⼀个键盘录⼊的整数

2.3 Scanner使⽤步骤

查看类

java.util.Scanner ：该类需要import导⼊后使⽤。

查看构造⽅法

public Scanner(InputStream source) ：构造⼀个新的 Scanner ，它⽣成的值是从指定的输⼊流扫描的。

查看成员⽅法

public int nextInt() ：将输⼊信息的下⼀个标记扫描为⼀个 int 值。

使⽤Scanner类，完成接收键盘录⼊数据的操作，代码如下：

//1. 导包
import java.util.Scanner;
public class Demo01_Scanner {
public static void main(String[] args) {
	//2. 创建键盘录⼊数据的对象
	Scanner sc = new Scanner(System.in);
	//3. 接收数据
	System.out.println("请录⼊⼀个整数:");
	int i = sc.nextInt();
	//4. 输出数据
	System.out.println("i:" + i);
 }
}

2.4 匿名对象

概念

创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法，但是应⽤场景⾮常有限。

匿名对象：没有变量名的对象。
格式：

new 类名(参数列表);

举例：

new Scanner(System.in);

应⽤场景

1.创建匿名对象直接调⽤⽅法，没有变量名。

new Scanner(System.in).nextInt();

2.⼀旦调⽤两次⽅法，就是创建了两个对象，造成浪费，请看如下代码。

new Scanner(System.in).nextInt();
new Scanner(System.in).nextInt();

⼩贴⼠：⼀个匿名对象，只能使⽤⼀次。

3.匿名对象可以作为⽅法的参数和返回值。

作为参数：

class Test {
public static void main(String[] args) {
	// 普通⽅式
	Scanner sc = new Scanner(System.in);
	input(sc);
	// 匿名对象作为⽅法接收的参数
	input(new Scanner(System.in));
 }
public static void input(Scanner sc) {
	System.out.println(sc);
 }
}

作为返回值

class Test2 {
public static void main(String[] args) {
	// 普通⽅式
	Scanner sc = getScanner();
 }
public static Scanner getScanner() {
	// 普通⽅式
	// Scanner sc = new Scanner(System.in);
	// return sc;
	// 匿名对象作为⽅法返回值
	return new Scanner(System.in);
 }
}

3 Random类

3.1 什么是Random类

此类的实例⽤于⽣成伪随机数。
例如，以下代码使⽤户能够得到⼀个随机数：

Random r = new Random();
int i = r.nextInt();

3.2 Random使⽤步骤

查看类

java.util.Random ：该类需要import导⼊使后使⽤。

查看构造⽅法

public Random() ：创建⼀个新的随机数⽣成器。

查看成员⽅法

public int nextInt(int n) ：返回⼀个伪随机数，范围在 0 （包括）和指定值n （不包括）之间的 int 值。

使⽤Random类，完成⽣成3个10以内的随机整数的操作，代码如下：

// 1. 导包
import java.util.Random;
public class Demo01_Random {
public static void main(String[] args) {
	// 2. 创建键盘录⼊数据的对象
	Random r = new Random();
	for (int i = 0; i < 3; i++) {
		// 3. 随机⽣成⼀个数据
		int number = r.nextInt(10);
		// 4. 输出数据
		System.out.println("number:" + number);
	 }
 }
}

备注：创建⼀个 Random 对象，每次调⽤ nextInt() ⽅法，都会⽣成⼀个随机数。(注意区别和Scanner类的nextInt()方法)

4 String类

4.1 String类概述

概述

java.lang.String 类代表字符串。Java程序中所有的字符串⽂字（例如 “abc” ）都可以被看作是实现此类的实例。
String类中包括⽤于检查各个字符串的⽅法，⽐如⽤于⽐较字符串，搜索字符串，提取⼦字符串以及创建具有翻译为⼤写或⼩写的所有字符的字符串的副本。

特点

1.字符串不变：字符串的值在创建后不能被更改。

String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

2.因为String对象是不可变的，所以它们可以被共享。

String s1 = "abc";
String s2 = "abc";
// 内存中只有⼀个"abc"对象被创建，同时被s1和s2共享。

3.“abc” 等效于 char[] data = {‘a’ , ‘b’ , ‘c’} 。

String str = "abc";
char data[] = {'a', 'b', 'c'};
String str = new String(data);
// String底层是靠字符数组实现的。

4.2 使⽤步骤

查看类
- java.lang.String ：此类不需要导⼊。
查看构造⽅法
- public String() ：初始化新创建的String对象，以使其表示空字符序列。
- public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
- public String(byte[] bytes) ：通过使⽤平台的默认字符集解码当前参数中的字节数组来构造新的String。

构造举例，代码如下：

// ⽆参构造
String str = new String();
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = {97, 98, 99};
String str3 = new String(bytes);

4.3 常⽤⽅法

判断功能的⽅法

public boolean equals(Object anObject) ：将此字符串与指定对象进⾏⽐较。
public boolean equalsIgnoreCase(String anotherString) ：将此字符串与指定对象进⾏⽐较，忽略⼤⼩写。
- ⽅法演示，代码如下：

public class String_Demo01 {
public static void main(String[] args) {
	// 创建字符串对象
	String s1 = "hello";
	String s2 = "hello";
	String s3 = "HELLO";
	// boolean equals(Object obj):⽐较字符串的内容是否相同
	System.out.println(s1.equals(s2)); // true
	System.out.println(s1.equals(s3)); // false
	System.out.println("-----------");
	// boolean equalsIgnoreCase(String str):⽐较字符串的内容是否相同,忽略⼤⼩写
	System.out.println(s1.equalsIgnoreCase(s2)); // true
	System.out.println(s1.equalsIgnoreCase(s3)); // true
	System.out.println("-----------");
 } 
}

Object 是“对象”的意思，也是⼀种引⽤类型。作为参数类型，表示任意对象都可以传递到⽅法中。

获取功能的⽅法

public int length() ：返回此字符串的⻓度。
public String concat(String str)：将指定的字符串连接到该字符串的末尾。
public char charAt(int index) ：返回指定索引处的char值。
public int indexOf(String str) ：返回指定⼦字符串第⼀次出现在该字符串内的索引。
public String substring(int beginIndex) ：返回⼀个⼦字符串，从beginIndex开始截取字符串到字符串结尾。
public String substring(int beginIndex, int endIndex) ：返回⼀个⼦字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

⽅法演示，代码如下：

    public static void main(String[] args) {
        // 创建字符串对象
        String s = "helloworld";
        // int length():获取字符串的⻓度，其实也就是字符个数
        System.out.println(s.length());// 10
        System.out.println("--------");
        // String concat (String str):将将指定的字符串连接到该字符串的末尾
        s = "helloworld";
        String s2 = s.concat("**hello world");
        System.out.println(s2); // helloworld**hello world
        // char charAt(int index):获取指定索引处的字符
        System.out.println(s.charAt(0));// h
        System.out.println(s.charAt(1));// e
        System.out.println("--------");
        // int indexOf(String str):获取str在字符串对象中第⼀次出现的索引,没有返回 - 1
        System.out.println(s.indexOf("l"));// 2
        System.out.println(s.indexOf("owo"));// 4
        System.out.println(s.indexOf("ak"));// -1
        System.out.println("--------");
        // String substring(int start):从start开始截取字符串到字符串结尾
        System.out.println(s.substring(0));// helloworld
        System.out.println(s.substring(5));// world
        System.out.println("--------");
        // String substring(int start, int end):从start到end截取字符串。含start，不含end。
        System.out.println(s.substring(0, s.length()));// helloworld
        System.out.println(s.substring(3, 8));// lowor
    }

转换功能的⽅法

public char[] toCharArray() ：将此字符串转换为新的字符数组。
public byte[] getBytes() ：使⽤平台的默认字符集将该String编码转换为新的字节数组。
public String replace(CharSequence target, CharSequence replacement) ：将与target匹配的字符串使⽤replacement字符串替换。

⽅法演示，代码如下：

    public static void main(String[] args) {
        // 创建字符串对象
        String s = "abcde";
        // char[] toCharArray():把字符串转换为字符数组
        char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);// a↙b↙c↙d↙e↙
        }
        System.out.println("-----------");
        // byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes = s.getBytes();// 97↙98↙99↙100↙101↙
        for (int x = 0; x < bytes.length; x++) {
            System.out.println(bytes[x]);
        }
        System.out.println("-----------");
        // 将"-"字符串替换为空字符串
        String str = "H-E-L-L-O-W-O-R-L-D";
        String replace = str.replace("-", "");
        System.out.println(replace); // HELLOWORLD
        System.out.println("-----------");
    }

CharSequence 是⼀个接⼝，也是⼀种引⽤类型。作为参数类型，可以把String对象传递到⽅法中。

分割功能的⽅法

public String[] split(String regex) ：将此字符串按照给定的regex(规则)拆分为字符串数组。
⽅法演示，代码如下：

public class String_Demo03 {
public static void main(String[] args) {
	// 创建字符串对象
	String s = "aa|bb|cc";
	String[] strArray = s.split("|"); // ["aa","bb","cc"]
	for (int x = 0; x < strArray.length; x++) {
		System.out.println(strArray[x]); // aa bb cc
	 }
 } 
}

4 ArrayList类

4.1 引⼊ – 对象数组

使⽤学⽣数组，存储三个学⽣对象，代码如下：

class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

public class Test01StudentArray {
    public static void main(String[] args) {
        // 创建学⽣数组
        Student[] students = new Student[3];
        // 创建学⽣对象
        Student s1 = new Student("张三", 40);
        Student s2 = new Student("李四", 35);
        Student s3 = new Student("王五", 30);
        // 把学⽣对象作为元素赋值给学⽣数组
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
        // 遍历学⽣数组
        for (int x = 0; x < students.length; x++) {
            Student s = students[x];
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

到⽬前为⽌，我们想存储对象数据，选择的容器，只有对象数组。⽽数组的⻓度是固定的，⽆法适应数据变化的需求。为了解决这个问题，Java提供了另⼀个容器 java.util.ArrayList 集合类，让我们可以更便捷的存储和操作对象数据。

4.2 什么是ArrayList类

java.util.ArrayList 是⼤⼩可变的数组的实现，存储在内的数据称为元素。此类提供⼀些⽅法来操作内部存储的元素。ArrayList 中可不断添加元素，其⼤⼩也⾃动增⻓。

4.3 ArrayList使⽤步骤

查看类

java.util.ArrayList < E > ：该类需要import导⼊使后使⽤。

< E >，表示⼀种指定的数据类型，叫做泛型。 E ，取⾃Element（元素）的⾸字⺟。在出现 E 的地⽅，我们使⽤⼀种引⽤数据类型将其替换即可，表示我们将存储哪种引⽤类型的元素。代码如下：

ArrayList<String>，ArrayList<Student>

查看构造⽅法

public ArrayList() ：构造⼀个内容为空的集合。

基本格式：

ArrayList<String> list = new ArrayList<String>();

在JDK 7后，右侧泛型的尖括号之内可以留空，但是<>仍然要写。简化格式：

ArrayList<String> list = new ArrayList<>();

查看成员⽅法

public boolean add(E e) ：将指定的元素添加到此集合的尾部。
参数 E e ，在构造ArrayList对象时， < E > 指定了什么数据类型，那么add(E e) ⽅法中，只能添加什么数据类型的对象。

使⽤ArrayList类，存储三个学生元素，代码如下：

class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

public class Test02StudentArray {
    public static void main(String[] args) {
        // 创建学⽣数组
        ArrayList<Student> list = new ArrayList<>();
        // 创建学⽣对象
        Student s1 = new Student("张三",40);
        Student s2 = new Student("李四",35);
        Student s3 = new Student("王五",40);
        // 把学⽣对象作为元素添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);
        // 打印学⽣ArrayList集合
        System.out.println(list);
    }
}

4.4 常⽤⽅法和遍历

对于元素的操作，基本体现在 – 增、删、查。
常⽤的⽅法有：

public boolean add(E e) ：将指定的元素添加到此集合的尾部。
public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防⽌越界。
这些都是最基本的⽅法，操作⾮常简单，代码如下：

public class Demo01ArrayListMethod {
public static void main(String[] args) {
	// 创建集合对象
	ArrayList<String> list = new ArrayList<String>();
	// 添加元素
	list.add("hello");
	list.add("world");
	list.add("java");
	// public E get(int index):返回指定索引处的元素
	System.out.println("get:" + list.get(0));
	System.out.println("get:" + list.get(1));
	System.out.println("get:" + list.get(2));
	// public int size():返回集合中的元素的个数
	System.out.println("size:" + list.size());
	// public E remove(int index):删除指定索引处的元素，返回被删除的元素
	System.out.println("remove:" + list.remove(0));
	// 遍历输出
	for(int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
 	}
 }
}

4.5 如何存储基本数据类型

ArrayList对象不能存储基本类型，只能存储引⽤类型的数据。类似不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写，转换写法如下：

基本类型	基本类型包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

我们发现，只有 Integer 和 Character 需要特殊记忆，其他基本类型只是⾸字⺟⼤写即可。那么存储基本类型数据，代码如下：

public class Demo02ArrayListMethod {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		System.out.println(list);
 }
}

5 static关键字

5.1 概述

关于 static 关键字的使⽤，它可以⽤来修饰成员变量和成员⽅法，被修饰的成员是属于类的，⽽不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调⽤了。

5.2 定义和使⽤格式

类变量

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同⼀个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进⾏操作。

类变量：使⽤static关键字修饰的成员变量。

定义格式：

static 数据类型 变量名;

举例：

static int numberID;

⽐如说，基础班新班开班，学员报到。现在想为每⼀位新来报到的同学编学号（sid），从第⼀名同学开始，sid为1，以此类推。学号必须是唯⼀且连续的，并且与班级的⼈数相符，这样以便知道，要分配给下⼀名新同学的学号是多少。这样我们就需要⼀个变量，与单独的每⼀个学⽣对象⽆关，⽽是与整个班级同学数量有关。所以，我们可以这样定义⼀个静态变量numberOfStudent，代码如下：

public class Student {
	private String name;
	private int age;
	// 学⽣的id
	private int sid;
	// 类变量，记录学⽣数量，分配学号
	public static int numberOfStudent = 0;
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
		// 通过 numberOfStudent 给学⽣分配学号
		this.sid = ++numberOfStudent;
	 }
	// 打印属性值
	public void show() {
		System.out.println("Student : name=" + name + ", age=" + age + ", sid=" + sid);
	 }
}
	public class StuDemo {
		public static void main(String[] args) {
			Student s1 = new Student("张三", 23);
			Student s2 = new Student("李四", 24);
			Student s3 = new Student("王五", 25);
			Student s4 = new Student("赵六", 26);
			s1.show(); // Student : name=张三, age=23, sid=1
			s2.show(); // Student : name=李四, age=24, sid=2
			s3.show(); // Student : name=王五, age=25, sid=3
			s4.show(); // Student : name=赵六, age=26, sid=4
	}
}

静态⽅法

当 static 修饰成员⽅法时，该⽅法称为类⽅法。静态⽅法在声明中有 static ，建议使⽤类名来调⽤，⽽不需要创建类的对象。调⽤⽅式⾮常简单。

类⽅法：使⽤static关键字修饰的成员⽅法，习惯称为静态⽅法。

定义格式：

修饰符 static 返回值类型 ⽅法名 (参数列表) {
	// 执⾏语句
}

举例：在Student类中定义静态⽅法

public static void showNum() {
	System.out.println("num:" + numberOfStudent);
}

静态⽅法调⽤的注意事项：
- 静态⽅法可以直接访问类变量和静态⽅法。
- 静态⽅法不能直接访问普通成员变量或成员⽅法。反之，成员⽅法可以直接访问类变量或静态⽅法。
- 静态⽅法中，不能使⽤this关键字。

⼩贴⼠：静态⽅法只能访问静态成员。

调⽤格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于⼀个类，共享使⽤同⼀个静态成员，但是不建议，会出现警告信息。
格式：

类名.类变量名;
// 调⽤静态⽅法
类名.静态⽅法名(参数);

调⽤演示，代码如下：

public class StuDemo2 {
	public static void main(String[] args) {
		// 访问类变量
		System.out.println(Student.numberOfStudent);
		// 调⽤静态⽅法
		Student.showNum();
 	}
}

5.3 静态原理图解

static 修饰的内容：

是随着类的加载⽽加载的，且只加载⼀次。
存储于⼀块固定的内存区域（静态区），所以，可以直接被类名调⽤。
它优先于对象存在，所以，可以被所有对象共享。

5.4 静态代码块

静态代码块：定义在成员位置，使⽤static修饰的代码块{ }。
- 位置：类中⽅法外。
- 执⾏：随着类的加载⽽执⾏且执⾏⼀次，优先于main⽅法和构造⽅法的执⾏。

格式：

public class ClassName {
static {
	// 执⾏语句
 }
}

作⽤：给类变量进⾏初始化赋值。⽤法演示，代码如下：

public class Game {
public static int number;
static {
	// 给类变量赋值
	number = 2;
 }
}

⼩贴⼠： static 关键字，可以修饰变量、⽅法和代码块。在使⽤的过程中，其主要⽬的还是想在不创建对象的情况下，去调⽤⽅法。下⾯将介绍两个⼯具类，来体现static⽅法的便利。

6 Arrays类

6.1 概述

java.util.Arrays 此类包含⽤来操作数组的各种⽅法，⽐如排序和搜索等。其所有⽅法均为静态⽅法，调⽤起来⾮常简单。

6.2 操作数组的⽅法

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。

public static void main(String[] args) {
	// 定义int 数组
	int[] arr = {2, 34, 35, 4, 657, 8, 69, 9};
	// 打印数组,输出地址值
	System.out.println(arr); // [I@2ac1fdc4
	// 数组内容转为字符串
	String s = Arrays.toString(arr);
	// 打印字符串,输出内容
	System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9]
}

public static void sort(int[] a) ：对指定的 int 型数组按数字升序进⾏排序。

public static void main(String[] args) {
	// 定义int 数组
	int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
	System.out.println("排序前:" + Arrays.toString(arr)); // 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6, 2]
	// 升序排序
	Arrays.sort(arr);
	System.out.println("排序后:" + Arrays.toString(arr)); // 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46, 48]
}

public static int[] copyOf(int[] original, int newLength) ：复制指定的数组，如有必要，⽤零填充。

public static void main(String[] args) {
	int[] arr = {1, 3, 5, 7, 9};
	// 数组扩容，⻓度 + 1
	arr = Arrays.copyOf(arr, 6);
	System.out.println("新数组:" + Arrays.toString(arr)); // 复制后，新数组内容为:[1, 3, 5, 7, 9, 0]，新增位置填充0
	// 数组缩容，⻓度 - 1
	arr = Arrays.copyOf(arr, 4);
	System.out.println("新数组:" + Arrays.toString(arr)); // 复制后，新数组
	内容为:[1, 3, 5, 7]
}

7 Math类

7.1 概述

java.lang.Math 类包含⽤于执⾏基本数学运算的⽅法，如初等指数、对数、平⽅根和三⻆函数。类似这样的⼯具类，其所有⽅法均为静态⽅法，并且不会创建对象，调⽤起来⾮常简单。

7.2 基本运算的⽅法

public static double abs(double a) ：返回 double 值的绝对值。

double d1 = Math.abs(-5); // d1的值为5
double d2 = Math.abs(5); // d2的值为5

public static double ceil(double a) ：返回⼤于等于参数的最⼩的整数。

double d1 = Math.ceil(3.3); // d1的值为 4.0
double d2 = Math.ceil(-3.3); // d2的值为 -3.0
double d3 = Math.ceil(5.1); // d3的值为 6.0

public static double floor(double a) ：返回⼩于等于参数最⼤的整数。

double d1 = Math.floor(3.3); // d1的值为3.0
double d2 = Math.floor(-3.3); // d2的值为-4.0
double d3 = Math.floor(5.1); // d3的值为 5.0

public static long round(double a) ：返回最接近参数的 long。（相当于四舍五⼊⽅法）

long d1 = Math.round(5.5); // d1的值为6
long d2 = Math.round(5.4); // d2的值为5

8 System类

java.lang.System 类中提供了⼤量的静态⽅法，可以获取与系统相关的信息或系统级操作，在System类的API⽂档中，常⽤的⽅法有：

public static long currentTimeMillis() ：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将数组中指定的数据拷⻉到另⼀个数组中。

8.1 currentTimeMillis⽅法

实际上，currentTimeMillis⽅法就是获取当前系统时间与1970年01⽉01⽇00:00点之间的毫秒差值

import java.util.Date;
public class SystemDemo {
	public static void main(String[] args) {
		//获取当前时间毫秒值
		System.out.println(System.currentTimeMillis()); // 1516090531144
 	}
}

8.2 arraycopy⽅法

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将数组中指定的数据拷⻉到另⼀个数组中。

数组的拷⻉动作是系统级的，性能很⾼。System.arraycopy⽅法具有5个参数，含义分别为：

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

扯淡吧 Pino曹

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JavaSE个人复习式整理知识点之面向对象二（static关键字）以及常用API[一]

常用API[一]、static关键字1 API概述JDK包结构API使⽤步骤2 Scanner类2.1 什么是Scanner类2.2 引⽤类型使⽤步骤导包创建对象调⽤⽅法2.3 Scanner使⽤步骤查看类查看构造⽅法查看成员⽅法2.5 匿名对象概念应⽤场景3 Random类3.1 什么是Random类3.2 Random使⽤步骤查看类查看构造⽅法查看成员⽅法4 String类4.1 String类概述概述特点4.2 使⽤步骤1 API概述API(Application Programming Int
复制链接

扫一扫