2021年最新Java基础入门篇(4)

最新推荐文章于 2022-10-09 00:57:24 发布

zhangyuxin0326

最新推荐文章于 2022-10-09 00:57:24 发布

阅读量545

点赞数

分类专栏：个人学习笔记文章标签： java 后端

本文链接：https://blog.csdn.net/her_mia/article/details/115599791

版权

笔记同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

个人学习

14 篇文章 0 订阅

订阅专栏

2021年最新Java基础入门篇(4)

第四篇来了来了~~~，上一篇文章被说和别人的高度相似，无语死…所以这一篇就也先发了吧

前言

今天内容有点多，希望能够耐心看下去哦

话不多说直接上干货

一、API

概述

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

API使用步骤

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

想要API的可以直接百度搜索 JavaAPI 进行下载

二、Scanner类

2.1 什么是Scanner类

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

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

tips:
	System.in 系统输入指的是通过键盘录入数据

2.2 引用类型使用步骤

导包
使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。

格式：

import 包名.类名;
// 导入 Scanner 
import java.util.Scanner;

创建对象

使用该类的构造方法，创建一个该类的对象。

格式：

	数据类型 变量名 = new 数据类型(参数列表);
	// 创建 Scanner 类
	Scanner sc = new Scanner(System.in);

调用方法

调用该类的成员方法，完成指定功能。

格式：

变量名.方法名();

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

2.3 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);
	}
}

练习：
求和
键盘录入两个数据并求和，代码如下：

import java.util.Scanner;
public class Test01Scanner {
	public static void main(String[] args) {
		// 创建对象
		Scanner sc = new Scanner(System.in);
		// 接收数据
		System.out.println("请输入第一个数据：");
		int a = sc.nextInt();
		System.out.println("请输入第二个数据：");
		int b = sc.nextInt();
		// 对数据进行求和
		int sum = a + b;
		System.out.println("sum ：" + sum );
	}
}

2.4 匿名对象【了解】

概念

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

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

//	new 类名(参数列表)；
new Scanner(System.in)；

应用场景

创建匿名对象直接调用方法，没有变量名。

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

一旦调用两次方法，就是创建了两个对象，造成浪费，请看如下代码。

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

tips:
	一个匿名对象，只能使用一次。

匿名对象可以作为方法的参数和返回值
作为参数：

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);
	}
}

三、Random类

3.1 什么是Random类

此类的实例用于生成伪随机数。

例如，以下代码使用户能够得到一个随机数：

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

3.2 Random使用步骤

//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);
		}
	}
}

tips:
	创建一个 Random 对象，每次调用 nextInt() 方法，都会生成一个随机数

练习：

游戏开始时，会随机生成一个1-100之间的整数 number 。玩家猜测一个数字 guessNumber ，会与 number 作比较，系统提示大了或者小了，直到玩家猜中，游戏结束。

// 导包
import java.util.Random;
public class Test02Random {
	public static void main(String[] args) {
		// 系统产生一个随机数1‐100之间的。
		Random r = new Random();
		int number = r.nextInt(100) + 1;
		while(true){
			// 键盘录入我们要猜的数据
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入你要猜的数字(1‐100)：");
			int guessNumber = sc.nextInt();
			// 比较这两个数据(用if语句)
			if (guessNumber > number) {
				System.out.println("你猜的数据" + guessNumber + "大了");
			} else if (guessNumber < number) {
				System.out.println("你猜的数据" + guessNumber + "小了");
			} else {
				System.out.println("恭喜你,猜中了");
				break;
			}
		}
	}
}

四、ArrayList类

4.1 引入–>对象数组

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

public 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;
	}
	publicvoid setName(String name) {
		this.name = name;
	}
	publicint getAge() {
		return age;
	}
	publicvoid 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使用步骤

public class Test02StudentArrayList {
	public static void main(String[] args) {
		//创建学生数组
		ArrayList<String> list = new ArrayList<>();
		//创建学生对象
		String s1 = "曹操";
		String s2 = "刘备";
		String s3 = "孙权";
		//打印学生ArrayList集合
		System.out.println(list);
		//把学生对象作为元素添加到集合
		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对象不能存储基本类型，只能存储引用类型的数据。类似<int>不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据，<>中的数据类型，必须转换后才能编写，转换写法如下：

在这里插入图片描述

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);
	}
}

练习

数值添加到集合
生成6个1~33之间的随机整数,添加到集合,并遍历

public class Test01ArrayList {
	public static void main(String[] args) {
		// 创建Random 对象
		Random random = new Random();
		// 创建ArrayList 对象
		ArrayList<Integer> list = new ArrayList<>();
		// 添加随机数到集合
		for (int i = 0; i < 6; i++) {
			int r = random.nextInt(33) + 1;
			list.add(r);
		}
		// 遍历集合输出
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
}

对象添加到集合
自定义4个学生对象,添加到集合,并遍历

public class Test02ArrayList {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList<Student> list = new ArrayList<Student>();
		//创建学生对象
		Student s1 = new Student("赵丽颖",18);
		Student s2 = new Student("唐嫣",20);
		Student s3 = new Student("景甜",25);
		Student s4 = new Student("柳岩",19);
		//把学生对象作为元素添加到集合中
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		//遍历集合
		for(int x = 0; x < list.size(); x++) {
			Student s = list.get(x);
			System.out.println(s.getName()+"‐‐‐"+s.getAge());
		}
	}
}

获取集合方法

public class Test04ArrayList {
	public static void main(String[] args) {
		// 创建Random 对象
		Random random = new Random();
		// 创建ArrayList 对象
		ArrayList<Integer> list = new ArrayList<>();
		// 添加随机数到集合
		for (int i = 0; i < 20; i++) {
			int r = random.nextInt(1000) + 1;
			list.add(r);
		}
		// 调用偶数集合的方法
		ArrayList<Integer> arrayList = getArrayList(list);
		System.out.println(arrayList);
	}
	public static ArrayList<Integer> getArrayList(ArrayList<Integer> list) {
		// 创建小集合,来保存偶数
		ArrayList<Integer> smallList = new ArrayList<>();
		// 遍历list
		for (int i = 0; i < list.size(); i++) {
			// 获取元素
			Integer num = list.get(i);
			// 判断为偶数,添加到小集合中
			if (num % 2 == 0){
				smallList.add(num);
			}
		}
		// 返回小集合
		return smallList;
	}
}

五、String类

5.1 String类概述

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实例。
类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。
特点

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

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

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

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

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

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

在这里插入图片描述

5.2 使用步骤

// 无参构造
String str = new String();	// 初始化新创建的 String对象，以使其表示空字符序列。
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);	// 通过当前参数中的字符数组来构造新的String
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);	//通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String

5.3 常用方法

判断功能的方法

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("‐‐‐‐‐‐‐‐‐‐‐");
	}
}

tips:
	Object 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。

获取功能的方法

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

转换功能的方法

public class String_Demo03 {
	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]);
		}
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
		// byte[] getBytes ():把字符串转换为字节数组
		byte[] bytes = s.getBytes();
		for(int x = 0; x < bytes.length; x++) {
		System.out.println(bytes[x]);
		}
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
		// 替换字母it为大写IT
		String str = "hello hello";
		String replace = str.replace("he", "HE");
		System.out.println(replace); // HEllo HEllo
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
	}
}

tips:
	CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

分割功能的方法

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
		}
	}
}

练习

统计字符个数
键盘录入一个字符，统计字符串中大小写字母及数字字符个数

public class StringTest2 {
	public static void main(String[] args) {
		//键盘录入一个字符串数据
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串数据：");
		String s = sc.nextLine();
		//定义三个统计变量，初始化值都是0
		int bigCount = 0;
		int smallCount = 0;
		int numberCount = 0;
		//遍历字符串，得到每一个字符
		for(int x=0; x<s.length(); x++) {
			char ch = s.charAt(x);
			//拿字符进行判断
			if(ch>='A'&&ch<='Z') {
				bigCount++;
			}else if(ch>='a'&&ch<='z') {
				smallCount++;
			}else if(ch>='0'&&ch<='9') {
				numberCount++;
			}else {
				System.out.println("该字符"+ch+"非法");
			}
		}
		//输出结果
		System.out.println("大写字符："+bigCount+"个");
		System.out.println("小写字符："+smallCount+"个");
		System.out.println("数字字符："+numberCount+"个");
	}
}

六、static关键字

6.1 概述

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

6.2 定义和使用格式

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

// 定义格式
// static 数据类型 变量名；
// 举例：
static int numberID；

比如说，基础班新班开班，学员报到。现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为1，以此类推。学号必须是唯一的，连续的，并且与班级的人数相符，这样以便知道，要分配给下一名新同学的学号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。

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 返回值类型 方法名 (参数列表){
	// 执行语句
}
*/
public static void showNum() {
	System.out.println("num:" + numberOfStudent);
}

静态方法调用的注意事项：

静态方法可以直接访问类变量和静态方法。
静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
静态方法中，不能使用this关键字。

tips:
	静态方法只能访问静态成员。

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

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

6.3 静态原理图解

在这里插入图片描述

6.4 静态代码块

静态代码块：定义在成员位置，使用static修饰的代码块{ }。
位置：类中方法外。
执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行

格式：

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

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

public class Game {
	public static int number;
		public static ArrayList<String> list;
		static {
		// 给类变量赋值
		number = 2;
		list = new ArrayList<String>();
		// 添加元素到集合中
		list.add("张三");
		list.add("李四");
	}
}

tips:
	static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。下面将介绍两个工具类，来体现static 方法的便利。

七、Arrays类

7.1 概述

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

7.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]
}

练习

请使用 Arrays 相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。

public class ArraysTest {
	public static void main(String[] args) {
		// 定义随机的字符串
		String line = "ysKUreaytWTRHsgFdSAoidq";
		// 转换为字符数组
		char[] chars = line.toCharArray();
		// 升序排序
		Arrays.sort(chars);
		// 反向遍历打印
		for (int i = chars.length‐1; i >= 0 ; i‐‐) {
		System.out.print(chars[i]+" "); // y y t s s r q o i g e d d a W U T S R K H F A
		}
	}
}

八、 Math类

8.1 概述

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

8.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.0
long d2 = Math.round(5.4); //d2的值为5.0

练习

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

public class MathTest {
	public static void main(String[] args) {
		// 定义最小值
		double min = ‐10.8;
		// 定义最大值
		double max = 5.9;
		// 定义变量计数
		int count = 0;
		// 范围内循环
		for (double i = Math.ceil(min); i <= max; i++) {
			// 获取绝对值并判断
			if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
			// 计数
			count++;
			}
		}
		System.out.println("个数为: " + count + " 个");
	}
}

总结

持续更新中，求关注，如有错误请在评论区指正，谢谢各位。

zhangyuxin0326

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
2021年最新Java基础入门篇(4)

2021年最新Java基础入门篇(4)第四篇来了来了~~~文章目录2021年最新Java基础入门篇(4)前言一、API概述API使用步骤二、Scanner类2.1 什么是Scanner类2.2 引用类型使用步骤2.3 Scanner使用步骤2.4 匿名对象【了解】三、Random类3.1 什么是Random类3.2 Random使用步骤四、ArrayList类4.1 引入-->对象数组4.2 什么是ArrayList类4.3 ArrayList使用步骤4.4 常用方法和遍历4.5 如何存储基本
复制链接

扫一扫