java常用的API(四)：Math类，Random类，Integer类，BigInteger类，BigDecimal类

最新推荐文章于 2022-08-02 16:31:54 发布

lituxiu

最新推荐文章于 2022-08-02 16:31:54 发布

阅读量445

点赞数 1

分类专栏： java学习文章标签： java api

本文链接：https://blog.csdn.net/lituxiu/article/details/120614675

版权

java学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本章主要总结的是java中与数字相关的常用API，包括Math类、Random类、Integer类、BigInteger类和BigDecimal类，主要涉及到了数字的运算和数字类型。

1、Math类

Math用于数学运算的类，常用的Math类的成员如下：

成员变量：

public static final double PI

public static final double E

成员方法：

public static int abs(int a)：绝对值

public static double ceil(double a):向上取整

public static double floor(double a):向下取整

public static int max(int a,int b):最大值 (min自学)

public static double pow(double a,double b):a的b次幂

public static double random():随机数 [0.0,1.0)

public static int round(float a) 四舍五入(参数为double的自学)

public static double sqrt(double a):正平方根

public class TestDemo {
	public static void main(String[] args) {
		// public static final double PI
		System.out.println("PI:" + Math.PI);
		// public static final double E
		System.out.println("E:" + Math.E);
		System.out.println("--------------");

		// public static int abs(int a)：绝对值
		System.out.println("abs:" + Math.abs(10));
		System.out.println("abs:" + Math.abs(-10));
		System.out.println("--------------");

		// public static double ceil(double a):向上取整
		System.out.println("ceil:" + Math.ceil(12.34));
		System.out.println("ceil:" + Math.ceil(12.56));
		System.out.println("--------------");

		// public static double floor(double a):向下取整
		System.out.println("floor:" + Math.floor(12.34));
		System.out.println("floor:" + Math.floor(12.56));
		System.out.println("--------------");

		// public static int max(int a,int b):最大值
		System.out.println("max:" + Math.max(12, 23));
		// 需求：我要获取三个数据中的最大值
		// 方法的嵌套调用
		System.out.println("max:" + Math.max(Math.max(12, 23), 18));
		// 需求：我要获取四个数据中的最大值
		System.out.println("max:"
				+ Math.max(Math.max(12, 78), Math.max(34, 56)));
		System.out.println("--------------");

		// public static double pow(double a,double b):a的b次幂
		System.out.println("pow:" + Math.pow(2, 3));
		System.out.println("--------------");

		// public static double random():随机数 [0.0,1.0)
		System.out.println("random:" + Math.random());
		// 获取一个1-100之间的随机数
		System.out.println("random:" + ((int) (Math.random() * 100) + 1));
		System.out.println("--------------");

		// public static int round(float a) 四舍五入(参数为double的自学)
		System.out.println("round:" + Math.round(12.34f));
		System.out.println("round:" + Math.round(12.56f));
		System.out.println("--------------");
		
		//public static double sqrt(double a):正平方根
		System.out.println("sqrt:"+Math.sqrt(4));
	}
}

1.1、Math.Random()案例

//案例：实现获取任意范围内的随机数

//public static double random():随机数 [0.0,1.0)
public class MathDemo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入开始数：");
		int start = sc.nextInt();
		System.out.println("请输入结束数：");
		int end = sc.nextInt();

		for (int x = 0; x < 100; x++) {
			// 调用功能
			int num = getRandom(start, end);
			// 输出结果
			System.out.println(num);
		}
	}

	/*
	 * 写一个功能 两个明确： 返回值类型：int 参数列表：int start,int end
	 */
	public static int getRandom(int start, int end) {
		// 回想我们讲过的1-100之间的随机数
		// int number = (int) (Math.random() * 100) + 1;
		// int number = (int) (Math.random() * end) + start; 
		// 200，300发现有问题了，怎么办呢?
		int number = (int) (Math.random() * (end - start + 1)) + start;
		return number;
	}
}

2、Random类

Random意思是任意的、随机的。在java中是作为用来生成随机数的类。常用Random类的成员如下：

Random()构造方法：

public Random():没有给种子，用的是默认种子，是当前时间的毫秒值

public Random(long seed):给出指定的种子

给定种子后，每次得到的随机数是相同的。

成员方法：

public int nextInt()：返回的是int范围内的随机数

public int nextInt(int n):返回的是[0,n)范围的内随机数

public class TestDemo {
	public static void main(String[] args) {
		// 创建对象
		// Random r = new Random();
		Random r = new Random(1111); //Random(long seed)给出指定种子后，每次运行的结果都一样了

		for (int x = 0; x < 10; x++) {
			// int num = r.nextInt();
			int num = r.nextInt(100) + 1;
			System.out.println(num);
		}
	}
}

3、Integer类

Integer类包装一个对象中的原始类型int的值。类型为Integer的对象包含一个单一字段，其类型为int 。此外，该类还提供了一些将int转换为String和String转换为int ，以及在处理int时有用的其他常量和方法。

3.1、Integer的构造方法

/*
 * Integer的构造方法：
 * public Integer(int value)
 * public Integer(String s)  注意：这个字符串必须是由数字字符组成
 * 		
 */
public class IntegerDemo {
	public static void main(String[] args) {
		// 方式1
		int i = 100;
		Integer ii = new Integer(i);
		System.out.println("ii:" + ii);

		// 方式2
		String s = "100";
		// NumberFormatException
		// String s = "abc";
		Integer iii = new Integer(s);
		System.out.println("iii:" + iii);
	}
}

3.2、Integer和String类型相互转换

int转换为String

String.valueOf(number)

String转换为int

Integer.parseInt(s)

public class TestDemo {
	public static void main(String[] args) {
		// int -- String
		int number = 100;
		// 方式1
		String s1 = "" + number;
		System.out.println("s1:" + s1);
		// 方式2
		String s2 = String.valueOf(number);
		System.out.println("s2:" + s2);
		// 方式3
		// int -- Integer -- String
		Integer i = new Integer(number);
		String s3 = i.toString();
		System.out.println("s3:" + s3);
		// 方式4
		// public static String toString(int i)
		String s4 = Integer.toString(number);
		System.out.println("s4:" + s4);
		System.out.println("-----------------");

		// String -- int
		String s = "100";
		// 方式1
		// String -- Integer -- int
		Integer ii = new Integer(s);
		// public int intValue()
		int x = ii.intValue();
		System.out.println("x:" + x);
		//方式2
		//public static int parseInt(String s)
		int y = Integer.parseInt(s);
		System.out.println("y:"+y);
	}
}

3.3、Integer进制的转换

int类型转二、八、十六进制，返回字符串表示

public static String toBinaryString(int i) 返回字符串的二进制

public static String toOctalString(int i) 返回字符串的八进制

public static String toHexString(int i) 返回字符串的十六进制

int类型灵活转换其它进制，返回字符串表示

public static String toString(int i,int radix) 把int类型的i值，转换为radix进制数，并返回字符串形式

其它进制灵活转换为int类型

public static int parseInt(String s,int radix) 把由radix进制数对应字符串的数字，返回等值的int类型字数。

public class TestDemo {
	public static void main(String[] args) {
		// 十进制到二进制，八进制，十六进制
		System.out.println(Integer.toBinaryString(100));
		System.out.println(Integer.toOctalString(100));
		System.out.println(Integer.toHexString(100));
		System.out.println("-------------------------");

		// 十进制到其他进制
		System.out.println(Integer.toString(100, 10));
		System.out.println(Integer.toString(100, 2));
		System.out.println(Integer.toString(100, 8));
		System.out.println(Integer.toString(100, 16));
		System.out.println(Integer.toString(100, 5));
		System.out.println(Integer.toString(100, 7));
		System.out.println(Integer.toString(100, -7));
		System.out.println(Integer.toString(100, 70));
		System.out.println(Integer.toString(100, 1));
		System.out.println(Integer.toString(100, 17));
		System.out.println(Integer.toString(100, 32));
		System.out.println(Integer.toString(100, 37));
		System.out.println(Integer.toString(100, 36));
		System.out.println("-------------------------");
		
		//其他进制到十进制
		System.out.println(Integer.parseInt("100", 10));
		System.out.println(Integer.parseInt("100", 2));
		System.out.println(Integer.parseInt("100", 8));
		System.out.println(Integer.parseInt("100", 16));
		System.out.println(Integer.parseInt("100", 23));
		//NumberFormatException
		//System.out.println(Integer.parseInt("123", 2));
	}
}

3.4、Integer的数据在-128到127范围直接赋值

直接赋值就是Integer i7 = 127的形式，

注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据

public class IntegerDemo {
	public static void main(String[] args) {
		Integer i1 = new Integer(127);
		Integer i2 = new Integer(127);
		System.out.println(i1 == i2);
		System.out.println(i1.equals(i2));
		System.out.println("-----------");

		Integer i3 = new Integer(128);
		Integer i4 = new Integer(128);
		System.out.println(i3 == i4);
		System.out.println(i3.equals(i4));
		System.out.println("-----------");

		Integer i5 = 128;
		Integer i6 = 128;
		System.out.println(i5 == i6);
		System.out.println(i5.equals(i6));
		System.out.println("-----------");

		Integer i7 = 127;
		Integer i8 = 127;
		System.out.println(i7 == i8);
		System.out.println(i7.equals(i8));

		// 通过查看源码，我们就知道了，针对-128到127之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间
		// Integer ii = Integer.valueOf(127);
	}
}
/* 执行结果如下
false    //这是因为new新的对象，对象的引用是先引用堆对象的地址再引用字符常量池的地址
true
-----------
false
true
-----------
false
true
-----------
true
true
*/

4、BigInteger类

BigInteger可以让超过Integer范围内的数据进行运算。

4.1、BigInteger类构造方法

BigInteger(String val)

import java.math.BigInteger; //要导包

public class TestDemo {
	public static void main(String[] args) {
		// 这几个测试，是为了简单超过int范围内，Integer就不能再表示，所以就更谈不上计算了。
		// Integer i = new Integer(100);
		// System.out.println(i);
		// // System.out.println(Integer.MAX_VALUE);
		// Integer ii = new Integer("2147483647");
		// System.out.println(ii);
		// // NumberFormatException
		// Integer iii = new Integer("2147483648");
		// System.out.println(iii);

		// 通过大整数来创建对象
		BigInteger bi = new BigInteger("2147483648");
		System.out.println("bi:" + bi);
	}
}

4.2、BigInteger的加减乘除

public BigInteger add(BigInteger val):加

public BigInteger subtract(BigInteger val):减

public BigInteger multiply(BigInteger val):乘

public BigInteger divide(BigInteger val):除

public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组

import java.math.BigInteger;

public class TestDemo {
	public static void main(String[] args) {
		BigInteger bi1 = new BigInteger("100");
		BigInteger bi2 = new BigInteger("50");

		// public BigInteger add(BigInteger val):加
		System.out.println("add:" + bi1.add(bi2));
		// public BigInteger subtract(BigInteger val):加
		System.out.println("subtract:" + bi1.subtract(bi2));
		// public BigInteger multiply(BigInteger val):加
		System.out.println("multiply:" + bi1.multiply(bi2));
		// public BigInteger divide(BigInteger val):加
		System.out.println("divide:" + bi1.divide(bi2));

		// public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组
		BigInteger[] bis = bi1.divideAndRemainder(bi2);
		System.out.println("商：" + bis[0]);
		System.out.println("余数：" + bis[1]);
	}
}

5、BigDecimal类

由于在运算的时候，float类型和double很容易丢失精度。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal，BigDecimal类是不可变的、任意精度的有符号十进制数,可以解决数据丢失问题。

5.1、BigDecimal类的构造方法和加减乘除

public BigDecimal(String val) 构造方法

public BigDecimal add(BigDecimal augend)

public BigDecimal subtract(BigDecimal subtrahend)

public BigDecimal multiply(BigDecimal multiplicand)

public BigDecimal divide(BigDecimal divisor)

public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode):商，几位小数，如何舍取

import java.math.BigDecimal;

public class TestDemo {
	public static void main(String[] args) {
		// System.out.println(0.09 + 0.01);
		// System.out.println(1.0 - 0.32);
		// System.out.println(1.015 * 100);
		// System.out.println(1.301 / 100);

		BigDecimal bd1 = new BigDecimal("0.09");
		BigDecimal bd2 = new BigDecimal("0.01");
		System.out.println("add:" + bd1.add(bd2));
		System.out.println("-------------------");

		BigDecimal bd3 = new BigDecimal("1.0");
		BigDecimal bd4 = new BigDecimal("0.32");
		System.out.println("subtract:" + bd3.subtract(bd4));
		System.out.println("-------------------");

		BigDecimal bd5 = new BigDecimal("1.015");
		BigDecimal bd6 = new BigDecimal("100");
		System.out.println("multiply:" + bd5.multiply(bd6));
		System.out.println("-------------------");

		BigDecimal bd7 = new BigDecimal("1.301");
		BigDecimal bd8 = new BigDecimal("100");
		System.out.println("divide:" + bd7.divide(bd8));
		System.out.println("divide:"
				+ bd7.divide(bd8, 3, BigDecimal.ROUND_HALF_UP));
		System.out.println("divide:"
				+ bd7.divide(bd8, 8, BigDecimal.ROUND_HALF_UP));
	}
}

lituxiu

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
java常用的API(四)：Math类，Random类，Integer类，BigInteger类，BigDecimal类

本章主要总结的是java中与数字相关的常用API，包括Math类、Random类、Integer类和BigInteger类，主要涉及到了数字的运算和数字类型。1、Math类 Math用于数学运算的类，常用的Math类的成员如下：成员变量： public static final double PI public static final double E 成员方法： public...
复制链接

扫一扫