Java第五章常用API

最新推荐文章于 2023-08-10 00:19:22 发布

与君随

最新推荐文章于 2023-08-10 00:19:22 发布

阅读量297

点赞数

本文链接：https://blog.csdn.net/weixin_52138829/article/details/117369115

版权

JAVA 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

API

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

Scanner键盘输入

Scanner类的功能:可以实现键盘输入数据，到程序当中。
引用类型的一般使用步骤;
1．导包
import包路径.类名称;
如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
只有java.lang包下的内容不需要导包，其他的包都需要import语句。
2．创建
类名称  对象名= new  类名称();
3.使用
对象名.成员方法名()

获取键盘输入的一个int数字: int num=sc.nextInt();
获取键盘输入的一个字符串:String str = sc.next();

import java.util.Scanner; // 1．导包
public static void main(String[] args) {
	//2．创建
	//备注:System.in代表从键盘进行输入
	Scanner sc = new Scanner(System.in );
	//3．获取键盘输入的int数字
	int num = sc.nextInt();
	System.out.println("输入的int数字是:" + num) ;
	//4．获取键盘输入的字符串
	String str = sc.next();
	System.out.println("输入的字符串是:" + str);
}

练习

键盘输入2个值并相加

package com.one;

import java.util.Scanner;

public class  Card{
	public static void main(String[] args) {
		Scanner one=new Scanner(System.in);
		int a=one.nextInt();
		int b=one.nextInt();
		int c=a+b;
		System.out.println(c);
	}
}

匿名对象

创建对象的标准格式:
类名称对象名= new 类名称();
匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
new类名称();
注意事项:匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
使用建议:如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。

public static void main(String[]args) {
//左边的one就是对象的名字
	Person one = new Person();
	one.name ="高圆圈";
	one. showName(); //我叫高圆圆
	//匿名对象
	new Person().name ="赵又廷";
	new Person().showName(); //我叫:nulL
}

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

package cn.itcast.day87.demo02;
import java.util.Scanner;
public class Demoe2Anonymous {
	public static void main(String[] args) {
	//昔通使用方式
	/*Scanner sc = new Scanner(System.in) ;
	int num = sc.nextInt();*/
	//匿名对象的方式
/*	int num = new Scanner( System.in ) .nextInt( );
	System.out.println("输入的是:"+ num) ;*/
	//使用一般写法传入参数
	/*Scanner sc = new Scanner( System.in);
	methodParam(sc);*/
	//使用匿名对象来进行传参
	//methodParam( new Scanner(System.in) );
	
	Scanner sc=methodReturn();
	int num = sc.nextInt();
	System.out.println("输入的是:"+num) ;
	}
	
	public static void methodParam(Scanner sd ){
		int num = sc.nextInt();
		System.out.println("输入的是:" +num) ;
	}
	//一般情况下的返回值
	public static Scanner methodReturn() {
		Scanner sc = new Scanner(System.in);
		return sc;
	}
	public static Scanner methodReturn() {
		return new Scanner(System.in);
	}
}

Random产生随机数

Random类用来生成随机数字。使用起来也是三个步骤:
1．导包
import java.util. Random;
2．创建
Random r = new Random(); //小括号当中留空即可
3．使用
获取一个随机的int数字（没有参数范围是int所有范围，有正负两种）: int num = r.nextInt()

public class Demo01Random {
	public static void main(String[] args) {
	Random r = new Random( );
	int num = r.nextInt();//不用输入也能输出一个数
	System.out.println("随机数是:" + num) ;
	}
}
获取一个随机的int数字（有参数代表了范围，左闭右开区间): 
int num = r.nextInt(3);
实际上代表的含义是:[0,3)，也就是0~2

对象数组

题目:
定义一个数组，用来存储3个Person对象。

package cn.itcast.day87.demo04;
public class Person {
	private String name;
	private int age;
	public Person() {
	}
	public Person(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 Demo01Array {
public static void main(String[]args) {
	//首先创建一个长度为3的数组，里面用来存放Person类型的对象
	Person[] array = new Person[3];
	Person one = new Person("迪田热巴",18);
	Person two = new Person("古力娜扎", 28);
	Person three = new Person("玛尔扎哈",38);
	//将one当中的地址值赋值到数组的0号元素位置
	array[0] = one;
	array[1] = two;
	array[2] = three;
	System.out.println(array[0]);//输出的是地址
	System.out.println( array[1]);
	System.out.println(array[2]);
	System.out.println(array[1].getName());//古力娜扎
	}
}
输出：
com.one.Person@6a5fc7f7
com.one.Person@3b6eb2ec
com.one.Person@1e643faf
古力娜扎

ArrayList集合

API中显示：
java.util
类ArrayList
导包：import java.util.ArrayList;
数组的长度不可以发生改变。
但是Arraylist集合的长度是可以随意变化的。
对于ArrayList来说，有一个尖括号代表泛型。
泛型:也就是装在集合当中的所有元素，全都是统一的什么类型。
注意:泛型只能是引用类型，不能是基本类型。

注意事项:
对于Arraylist集合来说，直接打印得到的不是地址值，而是内容。如果内容是空，得到的是空的中括号:[ ]

public class Demo02ArrayList {
public static void main(string[] args) {
	//创建了一个ArrayList集合，集合的名称是list，里面装的全都是string字符串类型的数据
	//备注:从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
	ArrayList<String> list = new ArrayList<>();
	System.out.println(list); // []
	//向集合当中添加一些数据，需要用到add方法。
	list.add("赵丽颖");
	System.out.println(list); //[赵丽颖]
	list.add("迪田热巴");
	list.add("古力娜扎");
	list.add("玛尔扎哈");
	System.out.println(list);//[赵丽颖，迪丽热巴，古力娜扎，玛尔扎哈]
	list.add(100);//错误写法!因为创建的时候尖括号泛型已经说了是字符串，添加进去的元素就必须都是字符串才行

}

常用方法和遍历

ArrayList当中的常用方法有:

public boolean add(E e):向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
备注:对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
但是对于其他集合(今后学习)来说，add添加动作不一定成功。
public E get(int index):从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int index):从集合当中删除元素，参数是索引编号，返回值就是被珊除掉的元素。
public int size():获取集合的尺寸长度，返回值是集合中包含的元素个数。

package com.one;

import java.util.ArrayList;

public class  Card{
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		System.out.println(list); // []
		//向集合中添加元素: add
		boolean success = list.add("柳岩");
		System.out.println(list);//[柳岩]
		System.out.println("添加的动作是否成功:" + success); // true
		list.add("高圆圆");
		list.add("赵又廷");
		list.add("李小璐");
		list.add("贾乃亮");
		System.out.println(list); //[柳岩,高圆圆,赵又廷,李小璐,贾乃亮]
		//从集合中获取元素:get。索引值从0开始
		//返回类型和泛型一致,都是String
		String name=list.get(2);
		System.out.println("第2号索引位置:" +name);//第2号索引位置:赵又廷
		String whoRemoved = list.remove(3);
		System.out.println("被删除的人是:" + whoRemoved);//被删除的人是:李小璐
		System.out.println(list);//[柳岩, 高圆圆, 赵又廷, 贾乃亮]
		int longth=list.size();
		System.out.println("集合的长度是:"+longth);//集合的长度是:4
	}
}

遍历：

package com.one;

import java.util.ArrayList;

public class  Card{
	public static void main(String[] args) {
			ArrayList<String> list = new ArrayList<>();
			list.add("迪田热巴");
			list.add("古力娜扎");
			list.add("玛尔扎哈");
			//遍历集合
			for (int i = 0; i < list.size(); i++) {
				System.out.println(list.get(i));
			}
	}
}

想存储基本数据类型

如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。

基本类型   包装类(引用类型，包装类都位于java.Lang包下)
byte       Byte
short      Short
int  	   Integer【特殊】
long	   Long
float	   FLoat
double	   DoubLe
char	   Character【特殊】
booLean	   BooLean
从JDK 1.5+开始，支持自动装箱、自动拆箱。
全动装箱:基本类型自动变成包装类型
自动拆箱:包装类型自动拆成基本类型

package com.one;
import java.util.ArrayList;
public class  Card{
	public static void main(String[] args) {
		ArrayList<String> listA = new ArrayList<>();
		//错误写法!泛型只能是引用类型，不能是基本类型
		//ArrayList<int> listB = new ArrayList<>();
		ArrayList<Integer> listC = new ArrayList<>();
		listC.add(100) ;
		listC.add(200);
		System.out.println(listC); // [100,200]
		int num = listC.get(1);
		System.out.println("第1号元素是:" + num);//第1号元素是:200
	}
}

练习1

题目:
生成6个1~33之间的随机整数，添加到集合，并遍历集合。
思路:
1．需要存储6个数字，创建一个集合，<Integer>
2.产生随机数，需要用到Random
3.用循环6次，来产生6个随机数字:for循环
4、循环内调用r.nextInt(int n)，参数是33，0~32，整体+1才是1~335．把数字添加到集合中: add
6．遍历集合:for、 size、 get
package com.one;
import java.util.Random;
import java.util.ArrayList;

public class  Card{
	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));
		}
	}
}

练习2

题目:
自定义4个学生对象，添加到集合,并遍历。
思路:
1.自定义Student学生类，四个部分。
2．创建—个集合,用来存储学生对象。泛型:<Student>
3．根据类，创建4个学生对象。
4、将4个学生对象添加到集合中: add
5．遍历集合:for、 size、get
package com.one;

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;
	}
	public void setName(String name) {
	this.name = name;
	}
	public int getAge() {
	return age;
	}
	public void setAge(int age) {
	this.age = age;
	}
}

package com.one;
import java.util.ArrayList;
public class Demo2 {
	public static void main(String[] args) {
		ArrayList<Student> list = new ArrayList<>();
		Student one = new Student( "洪七公", 20);
		Student two = new Student( "欧阳锋", 21);
		Student three = new Student( "黄药师",22);
		Student four = new Student( "段智兴", 23);
		list.add(one);
		list.add(two) ;
		list.add(three);
		list.add(four);
		
		//遍历集合
		for (int i = 0; i < list.size(); i++) {
			Student stu = list.get(i);
			System.out.println("姓名:" + stu.getName() + "，年龄" + stu.getAge());
		}
	}
}

字符串

java.Lang. String类代表子符串。
API当中说: Java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。
其实就是说:程序当中所有的双引号字符串，都是String类的对象。(就算没有new，也照样是。)
字符串的特点:
1.字符串的内容永不可变。【重点】
2.正是因为字符串不可改变，所以字符串是可以共享使用的。
3.字符串效果上相当于是char[ ]字符数组，但是底层原理是byte[ ]字节数组。

构造方法和直接创建

创建字符串的常见3+1种方式。
三种构造方法:
public String():创建一个空白字符串，不含有任何内容。
public String(char[ ] array):根据字符数组的内容，来创建对应的字符串。public String(byte[ ] array):根据字节数组的内容，来创建对应的字符串。
一种直接创建:
String str = "HeLlo"; //右边直接用双引号
package com.one;
public class Demo2 {
	public static void main(String[] args) {
		//使用空参构造
		String str1 = new String();//小括号留空，说明字符串什么内容都没有
		System.out.println("第1个字符串:"+ str1);
		//根据字符数组创建字符串
		char[]charArray = { 'A','B', 'C'};
				String str2 = new String(charArray);
		System.out.println("第2个字符串:" + str2);//根据字节数组创建字符串
		byte[]byteArray = { 97,98,99 };
		String str3 = new String(byteArray ) ;
		System.out. println("第3个字符串:" + str3);
		//直接创建
		String str4 = "He11o" ;
		System.out.println("第4个字符串:" + str4);
	}
}
输出：
第1个字符串:
第2个字符串:ABC
第3个字符串:abc
第4个字符串:He11o

常量池

字符串常量池:程序当中直接写上的双引号字符串，就在字符串常量池中。
对于基本类型来说，==是进行数值的比较。
对于引用类型来说,==是进行地址值的比较。
package com.one;
public class Demo2 {
	public static void main(String[] args) {
		String str1 = "abc" ;
		String str2 = "abc";
		char[] charArray = {'a', 'b', 'c'};
		String str3 = new String(charArray) ;
		System.out.println(str1 == str2); //true
		System.out.println(str1 == str3); // false创建方法不一样
		System.out.println(str2 ==str3); // false
	}
}

比较方法

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法:
public boolean equals(Object obj);参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true，否则返回false
备注:任何对象都能用Object进行接收。

`注意事项:`
1.任何对象都能用Object进行接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3．如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
推荐:"abc".equals(str)
不推荐:str.equals( "abc")
因为：
String str5 = null;
System.out.println("abc".equals(str5));//推荐:false
//System.out.println(str5.equals("abc"));//不推荐，报错，空指针异常NulLPointerException

public boolean equalsIgnoreCase(String str);忽略大小写，进行内容比较
举例：
package com.one;
public class Demo2 {
	public static void main(String[] args) {
		String strA = "Java" ;
		String strB = "java" ;
		System.out.println(strA.equals(strB));// false，严格区分大小写
		System.out.println(strA.equalsIgnoreCase(strB)); // true，忽略大小写
		//注意,只有英文字母区分大小写，其他都不区分大小写
		System.out.println("abc—123".equalsIgnoreCase( "abc壹123"));// false
	}
}


package com.one;
public class Demo2 {
	public static void main(String[] args) {
		String str1 = "Hello";
		String str2 = "Hello" ;
		char[] charArray = {'H', 'e', 'l','l', 'o'};
		String str3 = new String(charArray ) ;
		System.out.println(str1.equals(str2));//  true
		System.out.println(str2.equals(str3)); // true
	}
}

获取方法

String当中与获取相关的常用方法有:
public int length():获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str):将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index):获取指定索引位置的单个字符。（索引从o开始)
public int indexOf(String str):查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

代码：
package com.one;
public class Demo2 {
	public static void main(String[] args) {
		//获取字符串的长度
		 int length = "asdasfeutrvauevbueyvb" .length();
		 System.out.println("字符串的长度是:" + length) ;//拼接字符串
		 String str1 = "He11o";
		 String str2 = "wor1d";
		 String str3 = str1.concat(str2);
		 System.out.println(str1); // Hello，原封不动
		 System.out.println(str2);//world，原封不动
		 System.out.println(str3); // HelLolworld，新的字符串
		 
		 //获取指定索引位置的单个字符
		 char ch = "Hello".charAt(1);
		 System.out.println("在1号索引位置的字符是:" + ch);

		//查找参数字符串在本来字符串当中出现的第一次索引位置如果根本没有，返回-1值
		 String original = "HelloworldHelloworld" ;
		 int index = original.indexOf("llo");
		 System.out.println("第一次索引值是:" + index);// 2
	}
}

截取方法

public String substring(int index):截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin，int end):截取从begin开始，一直到end结束，中间的字符串。
备注:[begin , end)，包含左边,不包含右边。

package com.one;
public class Demo2 {
	public static void main(String[] args) {
		String str1 = "Helloworld";
		String str2 = str1.substring(5);
		System.out.println(str1);//Helloworld，原封不动
		System.out.println(str2); // world，新字符串
	
		String str3 = str1.substring(4,7);
		System.out.println(str3); //owo

		//下面这种写法,字符串的内容仍然是没有改变的
		//下面有两个字符串:"HeLlo"，"Java"
		//strA当中保存的是地址值。
		//本来地址值是Hello的0x666
		//后来地址值变成了Java的0x999看是用那个地址值的内容了
		String strA = "Hello";
		System.out.println(strA); // Hello
		strA = "Java";
		System.out.println(strA); // Java
	}
}

转换相关方法

public char[ ] toCharArray():将当前字符串拆分成为字符数组作为返回值。
public byte[]getBytes():获得当前字符串底层的字节数组。
public String replace(CharSequence oldString，CharSequence newString);将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
代码：
package com.one;
public class Demo2 {
	public static void main(String[] args) {
		//转换成为字符数组
		char[]chars = "He11o".toCharArray();
		System.out.println(chars[0]);// H
		System.out.println(chars. length); //5
		//转换成为字节数组
		byte[] bytes = "abc".getBytes();
		for (int i = 0; i < bytes.length; i++) {
			System.out.println(bytes[i]);//97 98 99
		}
		
		//字符串的内容替换
		String str1 ="How do you do?" ;
		String str2 = str1.replace(  "o", "*");
		System.out.println(str1); // How do you do?
		System.out.println(str2); // H*w d* y*u d*?
	}
}

分割方法

public String[] split(String regex):按照参数的规则，将字符串切分成为若干部分。
package com.one;
public class Demo2 {
	public static void main(String[] args) {
		String str1 = "aaa,bbb,ccc";
		String[] array1 = str1.split(",");
		for (int i = 0; i < array1. length; i++) {//按，号分割
			System.out.println(array1[i]);
		}
		//注意事项:
		//split方法的参数其实是一个“正则表达式”,今后学习。
		//今天要注意:如果按照英文句点“.”进行切分必须写"\\."(两个反斜杠)
		String str3 ="xxx.yyy.zzz";
		String[]array3 = str3.split(".");
		System.out.println(array3.length); // 0
		for (int i = 0; i < array3. length; i++){
			System.out.println(array3[i]);//没有输出
		}
	}
}

练习

题目:
定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。格式参照如下:[word1#word2#word3]。
分析:
1.首先准备一个int[]数组,内容是:1、2、3
2.定义一个方法,用来将数组变成字符串
三要素
返回值类型:String
方法名称:fromArrayToString
参数列表:int[]
3．格式:[word1#wword2#word3]
用到。for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个
4、调用方法，得到返回值，并打印结果字符串

package com.one;
public class Demo2 {
	public static void main(String[] args){
		int[] array = {1,2,3};
		String result = fromArrayToString(array );
		System.out.println(result);
	}
	
	public static String fromArrayToString(int[] array) {
		String str = "[";
		for (int i = 0; i < array.length; i++) {
			if (i == array . length - 1) {
				str += "word" +array[i] +"]";
			}
			else {
				str +="word" + array[i] +"#";
			}
		}
		return str;
	}
}

static关键字

要改教室的话只用修改一次就好了，不用每个人都修改在这里插入图片描述

修饰成员变量

static String room;//所在教室
one .room = "101教室";
则one.room和two.room的值一样

修饰成员方法

一旦使用static`修饰成员方法`，那么这就`成为了静态方法`。静态方法不属于对象，而是`属于类的`。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量:类名称.静态变量
静态方法:类名称.静态方法()

`注意事项:`
1．静态不能直接访问非静态。
原因:因为在内存当中是`【先】`有的静态内容，`【后】`有的非静态内容。
“先人不知道后人，但是后人知道先人。”
2.静态方法当中不能用this。
原因: this代表当前对象，通过谁调用的方法，谁就是当前对象。

代码：
package com.one;

public class MyClass {
	int num; //成员变量
	static int numStatic; //静态变量
	//成员方法
	public void method() {
		System.out.println("这是一个成员方法。");
		//成员方法可以访间成员变量
		System.out.println( num) ;//0
		//成员方法可以访问静态变量
		System.out.println(numStatic);//0
	}
	
	//静态方法
	public static void methodStatic() {
	System.out.println("这是一个静态方法。");
	//静态方法可以访问静态变量
	System.out.println(numStatic);
	//静态不能直接访问非静态【重点】
	//System.out.println(num); 错误写法!会报错
	
	//静态方法中不能使用this关键字。
	//System.out.println(this); 谙误写法!

	}
}

package com.one;
public class Demo2 {
	public static void main(String[] args){
		MyClass obj = new MyClass();
		//首先创建对象门然后才能使用没有static关键字的内容
		obj.method();  //这是一个成员方法。
		//对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
		obj.methodStatic(); //正确，不推荐,这种写法在编译之后也会被javac翻译成为"类名称.静态方法名"
		MyClass.methodStatic();//正确，推荐,这是一个静态方法。
		
		//对于本类当中的静态方法，可以省略类名称
		myMethod();//自己的方法! 
		Demo2.myMethod() ;//完全等效
	}
	public static void myMethod(){
		System.out. println("自己的方法! ");
	}

}

静态代码块

静态代码块的格式是:
public class类名称{
static {
//静态代码块的内容
}
特点:当第一次用到本类时，静态代码块执行唯一的一次。
`注意：`静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途:
用来—次性地对静态成员变量进行赋值。

代码：
package com.one;

public class MyClass {
	public MyClass() {
		System.out.println("构造方法执行!");
	}
	static {
		System.out.println("静态代码块执行!");
	}
}
package com.one;
public class Demo2 {
	public static void main(String[] args){
		MyClass one = new MyClass();
		MyClass two= new MyClass();
	}
}
输出：
静态代码块执行!
构造方法执行!
构造方法执行!

数学工具类Math

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
public static double abs ( double num):获取绝对值。
public static double ceil ( double num):向上取整。值会变多
public static double floor( double num):向下取整。值会变少
public static long round ( double num):四舍五入。
Math.PI代表近似的圆周率常量。
public static final double PI = 3.14159265358979323846;(double)

绝对值：
System.out.println(Math.abs( 3.14));// 3.14
System.out.println(Math.abs(0)); // 0
System.out.println(Math.abs( -2.5)); //2.5

//向上取整
System.out.print1n(Math.ceil(3.9));// 4.0
System.out.println(Math.ceil(3.1)); // 4.0
System.out.println(Math.ceil(3.0)); // 3.0

//向下取整，抹零
System.out.println(Math.floor( 30.1)); // 30.0
System.out.print1n(Math.floor( 30.9)); // 30.0
System.out.println(Math.floor( 31.0)); // 31.0

System.out.println(Math .round( 20.4)); // 20
System.out.println(Math.round( 10.5));  // 11

与君随

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
Java第五章常用API

Java APIAPIScanner键盘输入练习匿名对象匿名对象作为方法的参数和返回值Random产生随机数对象数组ArrayList基本使用常用方法和遍历存储基本数据类型练习APIAPI(Application Programming Interface)，应用程序编程接口。Java APl是一本程序员的字典，是JDK中提供给我们使用的类的说明文榜。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的
复制链接

扫一扫