二〇二三·二·二十二——日报-常用API-二分查找-冒泡排序-快排

1. 手动结束Java虚拟机

   System.exit(0);
   

2. break 跳出当前循环

3. continue 跳过此次循环

4. return 跳出当前方法

5. 需要跳出所有方法时，结束Java虚拟机

常用API

1. Math

   - int max(int a,int b) //返回较大值
   - int min(int a,int b) //返回较小值
   - int abs(int a)//返回绝对值
   - double ceil (double a) //向上取整
   - System.out.println("请计算3.2向上取整的结果"+Math.ceil(3.2));
   - double floor(double a) //向下取整
   - System.out.println("请计算3.8向下取整的结果"+Math.floor(3.8));
   - int round(float a) //四舍五入
   - System.out.println("请计算5.6四舍五入取整的结果"+Math.round(5.6));
   - double pow(double a,double b) //返回a的b次幂
   - System.out.println("请计算3的5次幂 "+Math.pow(3,5));
   - double random() //返回值为double的正值
   

2. System：System不能被实例化

   - void exit(int status) //终止Java虚拟机，非零表示异常终止
   - long currentTimeMillis() //返回当前时间(以毫秒为单位)
   - arraycopy(数据源数组,起始索引,目的地数组,起始索引,拷贝个数) //数组copy
   

3. Object：每个类都可以将Object作为父类。所有类都直接或间接的继承自该类

   public Object() //构造方法
       //为什么子类的构造方法默认访问的是父类的无参构造父方法？
       //因为他们的顶级父类（Object）只有无参构造方法
   - String toString() //返回对象的字符串表示形式，建议所有子类重写该方法
   - boolean equals(另一个对象) //比较对象是否相等。默认比较地址，重写可以比较内容
   

   • Object是所有类的直接或间接父类
   • 直接打印一个对象就是打印这个对象的toString方法的返回值
   • Object类的toString方法得到的是对象的地址值
   • 我们一般会对toString方法进行重写

4. Objects

   static String toString(对象) //对象字符串形式
   static String toString(对象, 默认字符串) 
   static Boolean isNull(对象) //对象是否为空
   static Boolean nonNull(对象) //对象是否不为空
   

5. BigDecimal

   //构造方法
   	BigDecimal(double val)
   	BigDecimal(String val)
   //常用方法
   	BigDecimal add(另一个BigDecimal对象) //加法
   	Bigdecimal subtract(另一个BigDecimal对象) //减法
       Bigdecimal multiply(另一个BigDecimal对象) //乘法
       Bigdecimal divide(另一个BigDecimal对象) //除法
       Bigdecimal divide(另一个BigDecimal对象,精确几位，舍入模式) //除法
   

   1. BigDecimal是用来进行精确计算的
   2. 创建BigDecimal的对象，构造方法使用参数类型为字符串的。
   3. 四则运算中的除法，如果除不尽请使用divide的三个参数的方法。

   • 舍入模式

     //进一法
     - BigDecimal.ROUND_UP  	
     //去尾法
     - BigDecimal.ROUND_FLOOR 	
     //四舍五入
     - BigDecimal.ROUND_HALF_UP 	
     

基本类型包装类

1. Integer

   //返回表示指定的 int 值的 Integer 实例
   public static Integer valueOf(int i)
   //返回一个保存指定值的 Integer 对象 String
   public static Integer valueOf(String s)
       //成员方法
   //将字符串类型的整数变成int类型的整数
   static int parseInt(String s)
   

   2. int 和String 的相互转换

      1. int 转换为 String

      方式一：加双引号即可
      方式二：public static String valueOf(int i)：返回 int 参数的字符串表示形式。该方法是 String 类中的方法
      

      2. String 转换为 int

      public static int parseInt(String s)：将字符串解析为 int 类型。该方法是 Integer 类中的方法
      

   Arrays 类的概述和常用方法

       public static String toString(int[] a) //返回指定数组的内容的字符串表示形式
       public static void sort(int[] a) //按照数字顺序排列指定的数组
       public static int binarySearch(int[] a, int key) //利用二分查找返回指定元素的索引
   

查找算法

1. 二分查找实现

   //    非递归二分查找
       public static int binarySearch(int[] ints, int target) {
           int low = 0;
           int height = ints.length - 1;
           while (low <= height) {
               int mid = (low + height) / 2;
               if (target < ints[mid]) {
                   height = mid - 1;
               } else if (target > ints[mid]) {
                   low = mid + 1;
               } else if (target == ints[mid]) {
                   return mid;
               }
           }
           return -1;
       }
   
   
   //    递归二分查找
       public static int binarySearch(int[] ints, int low, int height, int target) {
           if (low <= height) {
               if (target < ints[(low + height) / 2]) {
                   height = (low + height) / 2 - 1;
                   return binarySearch(ints, low, height, target);
               } else if (target > ints[(low + height) / 2]) {
                   low = (low + height) / 2 + 1;
                   return binarySearch(ints, low, height, target);
               } else if (target == ints[(low + height) / 2]) {
                   return (low + height) / 2;
               }
           }
           return -1;
       }
   

排序算法

1. 冒泡排序实现

   public static void bubbleSort(int[] ints) {
           for (int i = 0; i < ints.length - 1; i++) {
               for (int j = 0; j < ints.length - 1 - i; j++) {
                   if (ints[j] > ints[j + 1]) {
                       int term = ints[j + 1];
                       ints[j + 1] = ints[j];
                       ints[j] = term;
                   }
               }
           }
       }
   

2. 快速排序实现

   public static void quickSort(int[] ints, int left, int right) {
           if (left > right) {
               return;
           }
           int i;   //左哨兵
           int j;  //右哨兵
           int term;   //基准
           int t;  //临时值
           term = ints[left];
           i = left;
           j = right;
           while (i != j) {
               while (ints[j] >= term && i < j) {   //找到左边的数
                   j--;
               }
               while (ints[i] <= term && i < j) {   //找到右边的数
                   i++;
               }
               //交换
               t = ints[i];
               ints[i] = ints[j];
               ints[j] = t;
           }
           t = ints[left];
           ints[left] = ints[i];
           ints[i] = t;
   
           quickSort(ints,left,i-1);
           quickSort(ints,i+1,right);
       }