一、Math
Math：帮助我们进行数学计算的工具类
（1）私有化构造方法（不让外界创建它的对象）
（2）所有的方法都是静态的（可以通过类名直接调用）
public class demo1 {
/*
* public static int abs(int a) 获取参数绝对值
* public static double ceil(double a) 向上取整
* public static double floor(double a) 向下取整
* public static int round(float a) 四舍五入
* public static int max(int a,int b) 获取两个int值中的较大值
* public static double pow(double a,double b) 返回a的b次幂的值
* public static double sqrt(double a) 返回a的平方根
* public static double cbrt(double a) 返回a的立方根
* public static double random() 返回值为double的随机值，范围[0.0，1.0)
*/
public static void main(String[] args) {
//abs 获取参数绝对值
System.out.println(Math.abs(88));//88
System.out.println(Math.abs(-88));//88
//bug:
//以int类型为例，取值范围:-2147483648~2147483647
//如果没有正数与负数对应，那么传递负数结果有误
//-2147483648 没有正数与之对应，所以abs结果产生bug
//system.out.println(Math.abs(-2147483648));//-2147483648
//System.out.println(Math.absExact(-2147483648));JDK15以后才有
System.out.println("------------------------");
//进一法，往数轴的正方向进一
System.out.println(Math.ceil(12.34));//13.0
System.out.println(Math.ceil(12.54));//13.0
System.out.println(Math.ceil(-12.34));//-12.0
System.out.println(Math.ceil(-12.54));//-12.0
System.out.println("------------------------");
//去尾法
System.out.println(Math.floor(12.34));//12.0
System.out.println(Math.floor(12.54));//12.0
System.out.println(Math.floor(-12.34));//-13.0
System.out.println(Math.floor(-12.54));//-13.0
System.out.println("------------------------");
// 四舍五入
System.out.println(Math.round(12.34));//12
System.out.println(Math.round(12.54));//13
System.out.println(Math.round(-12.34));//-12
System.out.println(Math.round(-12.54));//-13
System.out.println("------------------------");
//获取两个整数的较大值
System.out.println(Math.max(20, 30));//30
//获取两个整数的较小值
System.out.println(Math.min(20, 30));//20
// 获取a的b次幂
System.out.println(Math.pow(2, 3));//8
//细节:
// 如果第二个参数 0 ~ 1之间的小数
// system.out.println(Math.pow(4,0.5));//2.0
// system.out.println(Math.pow(2,-2));//0.25
//建议:
//第二个参数:一般传递大于等于1的正整数。
System.out.println("------------------------");
System.out.println(Math.sqrt(4));//2.0
System.out.println(Math.cbrt(8));//2.0
System.out.println("------------------------");
System.out.println(Math.floor(Math.random() * 100 + 1));//打印语句快捷方式最后面.sout
}
}
两道数学题
（1）判断一个数是不是质数
public class demo1_test1 {
public static void main(String[] args) {
System.out.println(isPrime(100));
}
public static boolean isPrime(double number){
for (int i = 2; i <= Math.sqrt(number); i++) {
if(number % i != 0){
return false;
}
}
return true;
}
}
（2）水仙花数
public class demo1_test2 {
public static void main(String[] args) {
for (int i = 100; i <= 999; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
//判断
//每一位的三次方之和跟自身比较
double sum = Math.pow(ge,3) + Math.pow(shi,3) + Math.pow(bai, 3);
if(sum==i){
System.out.println(i);
}
}
}
}
二、System
public static void exit(int status)终止当前运行的 Java 虚拟机
public static long currentTimeMillis()返回当前系统的时间毫秒值形式
public static void arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数)数组拷贝
计算机中的时间原点：
1970年1月1日 00：00：00
1、
0:表示当前虚拟机是正常停止
非0:表示当前虚拟机异常停止
system.exit(0);
2、当前时间到时间原点的时间间隔（单位：毫秒）
long l = system.currentTimeMillis();
3、
参数一:数据源，要拷贝的数据从哪个数组而来
参数二:从数据源数组中的第几个索引开始拷贝
参数三:目的地，我要把数据拷贝到哪个数组中
参数四:目的地数组的索引
参数五:拷贝的个数
System.arraycopy(arr1,0,arr2,0,10);
细节:
1.如果数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错
2.在拷贝的时候需要考虑数组的长度，如果超出范围也会报错
3.如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型
三、Runtime
//1、获取Runtime的对象
//Runtime r1 = Runtime.getRuntime();
//2、exit 停止虚拟机
//r1.exit(0);
//3、获得CPU的线程数
System.out.println(Runtime.getRuntime().availableProcessors());
//4.总内存大小,单位byte字节
System.out.println(Runtime.getRuntime().maxMemory()/1024 / 1024);//3156
//5.已经获取的总内存大小,单位byte字节
System.out.println(Runtime.getRuntime().totalMemory()/1024 /1024);//213
//6.剩余内存大小
System.out.println(Runtime.getRuntime().freeMemory()/1024 / 1024);//208
//7.运行cmd命令
Runtime.getRuntime().exec("notepad");
四、Object
1、toString
//object 没有成员变量，所以只有空参构造
Object obj = new Object();
String str1 = obj.toString();
System.out.println(str1);
Student stu = new Student();
String str2 = stu.toString();
System.out.println(str2);
//当我们打印一个对象的时候，底层会调用对象的tostring方法，把对象变成字符串。
//然后再打印在控制台上，打印完毕换行处理。
System.out.println(stu);
//如果我们打印一个对象，想要看到属性值的话，那么就重写tostring方法就可以了。
//在重写的方法中，把对象的属性值进行拼接。
student类
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;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
2、equal
Student s1 = new Student();
Student s2 = new Student();
boolean result1 = s1.equals(s2);
System.out.println(result1);
//结论:
//1.如果没有重写equa1s方法，那么默认使用object中的方法进行比较，比较的是地址值是否相等
//2.一般来讲地址值对于我们意义不大，所以我们会重写，重写之后比较的就是对象内部的属性值了。
String s = "abc";
StringBuilder sb = new StringBuilder("abc");
System.out.println(s.equals(sb));
System.out.println(sb.equals(s));
// 字符串中的equals方法，先判断参数是否为字符串
// 如果是字符串，再比较内部的属性//
// 但是如果参数不是字符串，直接返回false
// 在object当中默认是使用==号比较两个对象的地址值
// 而这里的s和sb记录的地址值是不一样的
3、clone
细节:
方法在底层会帮我们创建一个对象，并把原对象中的数据拷贝过去。
书写细节:
（1）.重写object中的clone方法。
（2）.让javabean类实现Cloneable接口。
（3）.创建原对象并调用clone就可以了。
4、浅克隆
5、深克隆
6、总结
object中的克隆是浅克隆。
五、Objects
1、equals
细节:
1.方法的底层会判断s1是否为nu11，如果为nu11，直接返回false
2.如果s1不为nu11，那么就利用s1再次调用equals方法
3.此时s1是student类型，所以最终还是会调用student中的equals方法。
4.如果没有重写，比较地址值，如果重写了，就比较属性值。
//1.创建学生类的对象
Student s1 = null;
Student s2= new student("zhangsan",23);
boolean result = objects.equals(s1,s2);
System.out.println(result);
2、isNull and nonNull
Student s3 = new student();
Student s4 = null;
System.out.println(objects.isNull(s3));//false
system.out.println(objects.isNull(s4));//true
System.out.println(objects.nonNull(s3);//true
System.out.println(Objects.nonNull(s4));//false
六、BigInteger
1、获取随机大整数
BigInteger bi = new BigInteger(4,new Random());//[0~2^4-1]
2、获取指定大整数
BigInteger bi2 = new BigInteger("999999999")//只接受字符串数字
3、静态方法获取BigInteger的对象，内部有优化
细节:
（1）能表示范围比较小，只能在long的取值范围之内，如果超出long的范围就不行了。
（2）在内部对常用的数字:-16~16 进行了优化。
（3）提前把-16~16 先创建好BigInteger的对象，如果多次获取不会重新创建新的。
BigInteger bi3 = BigInteger.valueOf(16);
4、小结
如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取
如果BigInteger表示的超出long的范围，可以用构造方法获取。
对象一旦创建，BigInteger内部记三的值不能发生改变。只要进行计算都会产生一个新的BigInteger对象。
5、常用方法
（1）add 加 subtract 减 multiply 乘 divide 除
（2）
//1.创建两个BigInteger对象
BigInteger bd1= BigInteger.value0f(10);
BigInteger bd2=BigInteger.valueOf(3);
//2.加法
BigInteger bd3= bd1.add(bd2);
System.out.println(bd3);
//3.除法
BigInteger[] arr = bd1.divideandremainder(bd2);
System.out.println(arr[0]);
System.out.println(arr[1]);
//4.比较是否相同
boolean result = bd1.equals(bd2);
System.out.println(result);
//5.次幂
BigIntrger bd4 = bd1.pow(2);
system.out.println(bd4);
//6.max
BigInteger bd5 = bd1.max(bd2);
//7.转为int类型整数
BigInteger bd6 = BigInteger.valueOf(1000);
int i = bd6.intValue();
七、BigDecimal
1、由于计算机底层存储原理，表示的小数会不精确。所以使用BigDecimal精确表示小数和进行精确运算。
2、创建小数对象
//1.通过传递字符串表示的小数来创建对象
BigDecimal bd1 = new BigDecimal("0.01");
BigDecimal bd2 = new BigDecimal("0.09");
BigDecimal bd3 = bd1.add(bd2);
System.out.println(bd1);
System.out.println(bd2);
System.out.println(bd3);
//2.通过静态方法获取对象
BigDecimal bd6 = BigDecimal.value0f(10);//10.0
System.out.println(bd6);
//细节:
//1.如果要表示的数字不大，没有超出double的取值范围，建议使用静态方法
//2.如果要表示的数字比较大，超出了double的取值范围，建议使用构造方法
//3.如果我们传递的是0~10之间的整数，包含0，包含10，那么方法会返回已经创建好的对象，不会重新new
3、常用方法（和BigInteger类似）
小数保留方式
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
