Day01 Math,System,BigDecimal,Object,Objects,Integer类的常用API&&数组的二分排序&&数组的冒泡排序

Math数学类的常用方法

//Math 包含执行基本数字运算的方法
//方法都是静态修饰的 静态成员,类名直接调用
//取绝对值  abs()
System.out.println(Math.abs(-1));
System.out.println(Math.abs(1));
//两个整数中取较大值 max(int a , int b)
int max = Math.max(15, 20);
System.out.println(max);
//两个整数中取较小值 min(int a , int b)
int min = Math.min(15, 20);
System.out.println(min);
//结果强转为整数类型
//向上取整 ceil(1)  +1
double ceil = Math.ceil(1.5);
System.out.println((int)ceil);//2
//向下取整  floor() 本身
double floor = Math.floor(1.5);
System.out.println((int)floor);//1
//四舍五入   round()  不常用精确度不够好 后期使用BigDecimal类型
long round = Math.round(1.4);
System.out.println(round);//1
//返回a的b次方幂 pow()
double pow = Math.pow(1.1, 2.0);
System.out.println(pow);//1.2100000000000002
//返回范围在[0,1)之间的随机数  0=<a<1  注意括号
double s = Math.random();
System.out.println(s);

System类(和系统相关的类)的常用方法

//方法都是静态修饰的 类名直接调用
//结束当前运行的jvm虚拟机   System.exit(int status);
// 参数:int status 状态码
// 状态码为0是正常结束 非0为异常结束
//System.exit(0);
//垃圾回收机制  gc()  通知系统回收 使用完值为null或没作用的变量
//不建议频繁调用gc() 保护系统的健壮性
//System.gc();
/* 当前电脑的毫秒值(格林尼治时间开始于1970年1月1日 0时0分0秒) currentTimeMillis()
使用场景: 统计方法使用的时间  开始时间减去结束时间就是方法运行使用的时间
*/
/*   long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
long end= System.currentTimeMillis();
System.out.println(end-start);*/
//currentTimeMillis()的特殊情况  0/1毫秒 精确度不够
//此时就需要精确度更高的单位 纳秒
//获取当前系统纳秒值的方法  System.nanoTime()
long start = System.nanoTime();
// long start1 = System.currentTimeMillis();
Time(10000);
// long end1= System.currentTimeMillis();
long end = System.nanoTime();
System.out.println(end-start);
}

public static void Time(int count){
int j =0;
for (int i = 0; i < count; i++) {
j++;
}
System.out.println(j);
}

BigDecimal类的常用方法:可以用来进行精确计算

//构造方法  建议使用String的  double的过于精细 到了小数点后面很多位了
//new BigDecimal(int)   new BigDecimal(String)
BigDecimal bd = new BigDecimal("10");
BigDecimal bd1 = new BigDecimal("3");
//加法  add()
BigDecimal add = bd.add(bd1);
System.out.println(add);`
//减法   subtract()
BigDecimal subtract = bd.subtract(bd1);
System.out.println(subtract);
//乘法   multiply()
BigDecimal multiply = bd.multiply(bd1);
System.out.println(multiply);
//除法divide()可能出现除不尽异常ArithmeticException
//BigDecimal divide = bd.divide(bd1);
//System.out.println(divide);
//解决ArithmeticException
//参数1 ，表示参与运算的BigDecimal对象。
//参数2 ，表示小数点后面精确到多少位
//参数3 ，舍入模式BigDecimal.ROUND_HALF_UP 四舍五入
BigDecimal divide1 = bd.divide(bd1,3,BigDecimal.ROUND_HALF_UP);
System.out.println(divide1);

Object类:所有类都直接或间接继承Object类

(Object类是所有类的父类/基类/超类)

// equals()
Student s = new Student("张三", 18);
Student s2 = new Student("张三", 18);
//new了两个对象 在堆内存中开辟了两个空间  各自有不同的地址值
// ==引用数据类型比较的是地址值 基本数据类型比较的是值
System.out.println(s==s2);//false
//s.equals底层调用的还是== 所以比较的还是地址值  Ctrl+B 追底层源码
System.out.println(s.equals(s2));//false
//String类默认继承了Object类 重写了里面的toString方法 比较的是字符串里的内容区分大小写
String s1 ="abc";
String s3 ="Abc";
System.out.println(s1.equals(s3));//false
//String类中equalsIgnoreCase()  比较字符串内容 不区分大小写
System.out.println(s1.equalsIgnoreCase(s3));//true

关于Object的面试题

public class InterviewTest {
public static void main(String[] args) {
String s1 = “abc”;
StringBuilder sb = new StringBuilder(“abc”);
//1.此时调用的是String类中的equals方法.
//保证参数也是字符串,否则不会比较属性值而直接返回false
System.out.println(s1.equals(sb)); // false
//StringBuilder类中是没有重写equals方法,用的就是Object类中的.
System.out.println(sb.equals(s1)); // false
}

Objects类的常用方法

//toString()  返回参数中对象的字符串表示形式。
Student s = new Student("张三", 18);
String s1 = Objects.toString(s);
System.out.println(s);
System.out.println(s1);
// isNull(对象)判断对象是否为空
boolean aNull = Objects.isNull(s);
System.out.println(aNull);
// Boolean nonNull(对象)判断对象是否不为空
System.out.println(Objects.nonNull(s));

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200630215309281.bmp?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3cxMTUxNjc2OTk5,size_16,color_FFFFFF,t_70#pic_center)

包装类

//基本类型包装类的作用
//配合集合的使用   提供了一些转换的方法
//缺点 :相对于基本数据类型占用内存大
//常用的操作之一：用于基本数据类型与字符串之间的转换
/* 基本数据类型            引用数据类型
byte                  Byte
*   short                 Short
*   int                   Integer
*   long                  Long
*   double                Double
*   float                 Float
*   char                  Character
*   boolean               Boolean
自动装箱:将基本数据类型转为对应的引用数据类型
自动拆箱:将引用数据类型转为对应的基本数据类型

int类型对应的包装类Integer类型的常用方法

//将基本数据类型转为引用数据类型valueOf(int a)
Integer integer = Integer.valueOf(18);
//将String类型转为int类型再装箱为Integer类型
Integer integer1 = Integer.valueOf("18");
//将String类型的数字转为int类型的数字 parseInt() 便于计算
int i = Integer.parseInt("123");
//String转换为int
//转换方式
//1：先将字符串数字转成Integer，再调用valueOf()方法
Integer intg = new Integer("String");
Integer of = intg.valueOf(intg);
int te =of;
System.out.println(te);
System.out.println(of);
//2：通过Integer静态方法parseInt()进行转换
int i1 = Integer.parseInt(s1);
System.out.println(i1);

包装类的面试题

-128~12之间会预先生成这个范围内的Integer对象,超过此范围才会创建新的对象
Integer a= 100 Integer b= 100 ==true
Integer a= 200 Integer b= 200 ==false

练习题1

//案例需求
//​有一个字符串：“91 27 46 38 50”，
// 请写程序实现最终输出结果是：27 38 46 50 91
String s ="91 27 46 38 50";
String[] s1 = s.split(" ");
int [] arr = new int[s1.length];
for (int i = 0; i < s1.length; i++) {
arr[i]=Integer.parseInt(s1[i]) ;
}
Arrays.sort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}

二分查找法

Arrays中提供二分查找的方法
//因为存在0的情况 可能让人误解是0索引 所以当输入的值不存在时返回-输入值-1
int i = Arrays.binarySearch(arr[]:arr,key: 5);
System.out.println(i);

///前提是有大小序的
int []arr ={1,2,3,4,5,6,7,8,9,10};
int number=6;
int index=getIndex(arr,number);
System.out.println(index);
}

public static int getIndex(int[] arr, int number) {
int max=arr.length-1;
int min=0;
while(min<=max){
int mid= (min+max) >>1;
if (number<arr[mid]){
max=mid-1;
}else if (number>arr[mid]){
min=mid+1;
}else {
return mid;
}
}return -1;
}

冒泡排序

int []arr ={5,8,1,4,3,6,9,2,7,10};
//外层循环控制的是次数 比数组的长度少一次.
for (int i = 0;i < arr.length - 1; i++) {
//内存循环就是实际循环比较的
//-1 是为了让数组不要越界
//-i 每一轮结束之后,我们就会少比一个数字.
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}