1.API

1.1 API概述【理解】

  • 什么是API
    API (Application Programming Interface) ：应用程序编程接口
  • Java中的API
    指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

1.2 如何使用API帮助文档【应用】

  • 打开帮助文档
  • 找到索引选项卡中的输入框
  • 在输入框中输入Random
  • 看类在哪个包下
  • 看类的描述
  • 看构造方法
  • 看成员方法

2.常用API

2.1 Math（应用）

  • Math类概述
    • Math 包含执行基本数字运算的方法
  • Math中方法的调用方式
    • Math类中无构造方法，但内部的方法都是静态的，则可以通过 类名.进行调用
    • 工作中定义一个工具类，方法是静态的，提供一个private的空构造
  • Math类的常用方法 | 方法名 方法名 | 说明 | | —- | —- | | public static int abs(int a) | 返回参数的绝对值 | | public static double ceil(double a) | 返回大于或等于参数的最小double值，等于一个整数 | | public static double floor(double a) | 返回小于或等于参数的最大double值，等于一个整数 | | public static int round(float a) | 按照四舍五入返回最接近参数的int | | public static int max(int a,int b) | 返回两个int值中的较大值 | | public static int min(int a,int b) | 返回两个int值中的较小值 | | public static double pow (double a,double b) | 返回a的b次幂的值 | | public static double random() | 返回值为double的正值，[0.0,1.0) |

  • 示例代码

    1. /**
    2. * Math类的使用
    3. */
    4. public class MainClass {
    5.   public static void main(String[] args) {
    6.       //public static int abs(int a)        返回参数的绝对值
    7.       int abs = Math.abs(-1);
    8.       System.out.println(abs);
    10.       //public static double ceil(double a)    向上取整
    11.       double ceil = Math.ceil(10.1);
    12.       System.out.println(ceil);
    14.       //public static double floor(double a)    向下取整
    15.       double floor = Math.floor(10.1);
    16.       System.out.println(floor);
    18.       //public static int round(float a)    四舍五入
    19.       int round1 = Math.round(1.9F);
    20.       System.out.println(round1);
    21.       int round2 = Math.round(1.3F);
    22.       System.out.println(round2);
    24.       //public static int max(int a,int b)    返回两个int值中的较大值
    25.       int max = Math.max(10,20);
    26.       System.out.println(max);
    28.       //public static int min(int a,int b)    返回两个int值中的较小值
    29.       int min = Math.min(10, 20);
    30.       System.out.println(min);
    32.       //public static double pow(double a,double b)返回a的b次幂的值
    33.       double pow = Math.pow(2, 4);
    34.       System.out.println(pow);
    36.       System.out.println("---------------------------");
    37.       //public static double random()        返回值为double的正值，[0.0,1.0)
    38.       for (int i = 0; i < 10 ; i++) {
    39.           double random = Math.random()*100;
    40.           System.out.println(random);
    41.       }
    43.       //System.out.println((int)((Math.random()*9+1)*10000));
    44.   }
    45. }

2.2 System（应用）

  • System类的常用方法 | 方法名 | 说明 | | —- | —- | | public static void exit(int status) | 终止当前运行的 Java 虚拟机，非零表示异常终止 | | public static long currentTimeMillis() | 返回当前时间(以毫秒为单位) | | Public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) | 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束 |

  • 示例代码

    1. /**
    2. * System类的使用
    3. */
    4. public class MainClass {
    5.   public static void main(String[] args) {
    6.       //public static void exit(int status)    终止当前运行的 Java 虚拟机，非零表示异常终止
    7.       System.out.println("开始");
    8.       //System.exit(0);
    9.       System.out.println("结束");
    10.       System.out.println("-----------------------");
    12.       //public static long currentTimeMillis()  返回当前时间(以毫秒为单位)
    13.       long start = System.currentTimeMillis();
    14.       for (int i = 0; i < 100000; i++) {
    15.           System.out.println(i);
    16.       }
    17.       long end = System.currentTimeMillis();
    18.       System.out.println("运行时间:" + (end - start));
    19.       System.out.println("-----------------------");
    21.       //arraycopy(数据源数组, 起始索引, 目的地数组, 起始索引, 拷贝个数)    数组copy
    22.       int[] arr1 = {1,2,3,4,5};
    23.       int[] arr2 = new int[10];
    25.       System.arraycopy(arr1,0,arr2,0,2);
    26.       for (int i = 0; i < arr2.length; i++) {
    27.           System.out.println(arr2[i]);
    28.       }
    29.       System.out.println("-----------------------");
    31.       System.arraycopy(arr1,2,arr2,7,3);
    32.       for (int i = 0; i < arr2.length; i++) {
    33.           System.out.println(arr2[i]);
    34.       }
    35.   }
    36. }

2.3 Object类的toString方法（应用）

  • Object类概述
    • Object 是类层次结构的根，每个类都可以将 Object 作为超类。
    • 所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份
    • Object类的toString方法得到的是对象的地址值
    • 直接打印一个对象就是打印这个对象的toString方法的返回值
    • 我们一般会对Object类的toString方法进行重写
  • 查看方法源码的方式
    • 选中方法，按下Ctrl + B
  • 重写toString方法的方式
    • Alt + Insert 选择toString
    • 在类的空白区域，右键 -> Generate -> 选择toString
  • toString方法的作用：
    • 以良好的格式，更方便的展示对象中的属性值

  • 示例代码：

    1. class Student extends Object {
    2.   private String name;
    3.   private int age;
    5.   public Student() {
    6.   }
    8.   public Student(String name, int age) {
    9.       this.name = name;
    10.       this.age = age;
    11.   }
    13.   public String getName() {
    14.       return name;
    15.   }
    17.   public void setName(String name) {
    18.       this.name = name;
    19.   }
    21.   public int getAge() {
    22.       return age;
    23.   }
    25.   public void setAge(int age) {
    26.       this.age = age;
    27.   }
    29.   @Override
    30.   public String toString() {
    31.       return "Student{" +
    32.               "name='" + name + '\'' +
    33.               ", age=" + age +
    34.               '}';
    35.   }
    36. }
    37. public class ObjectDemo {
    38.   public static void main(String[] args) {
    39.       Student s = new Student();
    40.       s.setName("林青霞");
    41.       s.setAge(30);
    42.       System.out.println(s); 
    43.       System.out.println(s.toString()); 
    44.   }
    45. }

  • 运行结果：

    1. Student{name='林青霞', age=30}
    2. Student{name='林青霞', age=30}

2.4 Object类的equals方法（应用）

  • equals方法的作用
    • 用于比较两个对象的地址值是否相等
  • 重写equals方法的场景
    • 不希望比较对象的地址值，想要结合对象属性进行比较的时候。
  • 重写equals方法的方式
    • alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
    • 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。

  • 示例代码： ```java public class Student { private String name; private int age;

    public Student() { }

    public Student(String name, int age) {

    1.   this.name = name;
    2.   this.age = age;

    }

    public String getName() {

    1.   return name;

    }

    public void setName(String name) {

    1.   this.name = name;

    }

    public int getAge() {

    1.   return age;

    }

    public void setAge(int age) {

    1.   this.age = age;

    }

    @Override public String toString() {

    1.   return "Student{" +
    2.           "name='" + name + '\'' +
    3.           ", age=" + age +
    4.           '}';

    }

    @Override public boolean equals(Object o) {

    1.   if (this == o) return true;
    2.   if (o == null || getClass() != o.getClass()) return false;
    4.   Student student = (Student) o;
    6.   if (age != student.age) return false;
    7.   return name != null ? name.equals(student.name) : student.name == null;

    }

}

/**

  • Object-equals方法的重写 */ public class MainClass { public static void main(String[] args) {
    1.  Student student1 = new Student("张三",22);
    2.  Student student2 = new Student("张三",22);
    3.  System.out.println(student1 == student2);
    4.  System.out.println(student1.equals(student2));
    } } ```

2.5 Object-面试题

  • 试题

    1. // 看程序,分析结果
    2. String s = “abc”;
    3. StringBuilder sb = new StringBuilder(“abc”);
    4. s.equals(sb); 
    5. sb.equals(s);

  • 解析

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

2.6 Objects (应用)

  • 常用方法 | 方法名 | 说明 | | —- | —- | | public static String toString(对象) | 返回参数中对象的字符串表示形式。 | | public static String toString(对象, 默认字符串) | 返回对象的字符串表示形式。 | | public static Boolean isNull(对象) | 判断对象是否为空 | | public static Boolean nonNull(对象) | 判断对象是否不为空 |

  • 示例代码
    学生类

    1. class Student {
    2.     private String name;
    3.     private int age;
    5.     public Student() {
    6.     }
    8.     public Student(String name, int age) {
    9.         this.name = name;
    10.         this.age = age;
    11.     }
    13.     public String getName() {
    14.         return name;
    15.     }
    17.     public void setName(String name) {
    18.         this.name = name;
    19.     }
    21.     public int getAge() {
    22.         return age;
    23.     }
    25.     public void setAge(int age) {
    26.         this.age = age;
    27.     }
    29.     @Override
    30.     public String toString() {
    31.         return "Student{" +
    32.                 "name='" + name + '\'' +
    33.                 ", age=" + age +
    34.                 '}';
    35.     }
    36. }

  • 测试类

    1. /**
    2. * Objects的使用
    3. */
    4. public class MainClass {
    5.   public static void main(String[] args) {
    6.       //public static String toString(对象)  返回参数中对象的字符串表示形式。
    7.       Student student1 = new Student("林青霞",22);
    8.       String s = Objects.toString(student1);
    9.       System.out.println(s);
    11.       //public static String toString(对象, 默认字符串)
    12.       Student student2 = null;
    13.       String ss = Objects.toString(student2, "默认null");
    14.       System.out.println(ss);
    16.       //public static Boolean isNull(对象)         判断对象是否为空
    17.       Student student3 = null;
    18.       boolean result = Objects.isNull(student3);
    19.       System.out.println(result);
    21.       //public static Boolean nonNull(对象)         判断对象是否不为空
    22.       result = Objects.nonNull(student3);
    23.       System.out.println(result);
    24.   }
    25. }

2.7 BigDecimal (应用)

  • 作用
    可以用来进行精确计算

  • 常用构造方法 | 方法名 | 说明 | | —- | —- | | BigDecimal(double val) | 参数为double | | BigDecimal(String val) | 参数为String |

  • 注意：如果想要进行精确运算,那么请使用字符串的构造

2.8 BigDecimal-四则运算

  • 常用方法 | 方法名 | 说明 | | —- | —- | | public BigDecimal add(另一个BigDecimal对象) | 加法 | | public BigDecimal subtract (另一个BigDecimal对象) | 减法 | | public BigDecimal multiply (另一个BigDecimal对象) | 乘法 | | public BigDecimal divide (另一个BigDecimal对象) | 除法 | | public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式) | 除法 |

  • 示例代码

    1. /**
    2. * BigDecimal的四则运算
    3. * 如果想要进行精确运算,那么请使用字符串的构造
    4. */
    5. public class Test02 {
    6.   public static void main(String[] args) {
    7.       BigDecimal bd1 = new BigDecimal("0.1");
    8.       BigDecimal bd2 = new BigDecimal("0.2");
    10.       //public BigDecimal add(另一个BigDecimal对象)     加法
    11.       BigDecimal add = bd1.add(bd2);
    12.       System.out.println("和：" + add);
    14.       //public BigDecimal subtract (另一个BigDecimal对象)  减法
    15.       BigDecimal subtract = bd1.subtract(bd2);
    16.       System.out.println("差：" + subtract);
    18.       //public BigDecimal multiply (另一个BigDecimal对象)  乘法
    19.       BigDecimal multiply = bd1.multiply(bd2);
    20.       System.out.println("积：" + multiply);
    22.       //public BigDecimal divide (另一个BigDecimal对象)    除法
    23.       BigDecimal divide = bd1.divide(bd2);
    24.       System.out.println("商：" + divide);
    25.   }
    26. }

2.10 BigDecimal-特殊方法

  • public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式)

    1. BigDecimal divide = bd1.divide(参与运算的对象,小数点后精确到多少位,舍入模式);
    2. 参数1 ，表示参与运算的BigDecimal 对象。
    3. 参数2 ，表示小数点后面精确到多少位
    4. 参数3 ，舍入模式  
    5. BigDecimal.ROUND_UP  进一法
    6. BigDecimal.ROUND_FLOOR 去尾法
    7. BigDecimal.ROUND_HALF_UP 四舍五入

  • 示例代码

    1. /**
    2. * BigDecimal-特殊方法
    3. */
    4. public class Test03 {
    5.   public static void main(String[] args) {
    6.       BigDecimal bd1 = new BigDecimal("0.3");
    7.       BigDecimal bd2 = new BigDecimal("4"); //0.075
    9.       //进一法
    10.       BigDecimal divide1 = bd1.divide(bd2, 2, BigDecimal.ROUND_UP);
    11.       System.out.println(divide1);
    12.       //去尾法
    13.       BigDecimal divide2 = bd1.divide(bd2, 2, BigDecimal.ROUND_FLOOR);
    14.       System.out.println(divide2);
    15.       //四舍五入
    16.       BigDecimal divide3 = bd1.divide(bd2,2,BigDecimal.ROUND_HALF_UP);
    17.       System.out.println(divide3);
    18.   }
    19. }

  • 总结

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

3.包装类

3.1 基本类型包装类（记忆）

  • 基本类型包装类的作用
    将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
    常用的操作之一：用于基本数据类型与字符串之间的转换
  • 基本类型对应的包装类 | 基本数据类型 | 包装类 | | —- | —- | | byte | Byte | | short | Short | | int | Integer | | long | Long | | float | Float | | double | Double | | char | Character | | boolean | Boolean |

3.2 Integer类（应用）

  • Integer类概述
    包装一个对象中的原始类型 int 的值

  • Integer获得对象

    • 通过构造方法直接创建对象—过时
    • 通过静态方法valueOf()获取—推荐 | 方法名 | 说明 | | —- | —- | | public Integer(int value) | 根据 int 值创建 Integer 对象(过时) | | public Integer(String s) | 根据 String 值创建 Integer 对象(过时) | | public static Integer valueOf(int i) | 返回表示指定的 int 值的 Integer实例 | | public static Integer valueOf(String s) | 返回一个保存指定值的 Integer 对象 String |

  • 示例代码

    1. /**
    2. * 通过构造方法直接创建对象
    3. * 通过静态方法valueOf()获取
    4. */
    5. public class MainClass {
    6.   public static void main(String[] args) {
    7.       //通过构造方法直接创建对象
    8.       Integer integer1 = new Integer(10);
    9.       Integer integer2 = new Integer("10");
    11.       System.out.println(integer1);
    12.       System.out.println(integer2);
    14.       System.out.println("----------------------");
    16.       //通过静态方法valueOf()获取
    17.       Integer integer3 = Integer.valueOf(10);
    18.       Integer integer4 = Integer.valueOf("10");
    19.       System.out.println(integer3);
    20.       System.out.println(integer4);
    21.   }
    22. }

3.3 自动拆箱和自动装箱（理解）

  • 自动装箱
    把基本数据类型转换为对应的包装类类型
  • 自动拆箱
    把包装类类型转换为对应的基本数据类型
  • 注意：包装类在使用前最好进行非空的判断
  • 示例代码
    1. Integer i = 100;  // 自动装箱
    2. i += 200;         // i = i + 200;  i + 200 自动拆箱；i = i + 200; 是自动装箱

3.4 int和String类型的相互转换（记忆）

  • int转换为String

    • 转换方式
      • 方式一：直接在数字后加一个空字符串
      • 方式二：通过String类静态方法valueOf()

    • 示例代码

      1. public class IntegerDemo {
      2. public static void main(String[] args) {
      3.    //int --->String
      4.    //方式一: +""
      5.    int i = 100;
      6.    String str1 = i + "";
      7.    System.out.println(str1 + 100);
      9.    //方式二: 可以调用String类中valueof方法
      10.    String str2 = String.valueOf(100);
      11.    System.out.println(str2 + 100);
      12. }
      13. }

  • String转换为int

    • 转换方式
      • 方式：通过Integer静态方法parseInt()进行转换
    • 示例代码
      1. public class IntegerDemo {
      2. public static void main(String[] args) {
      3.    //方式：通过Integer静态方法parseInt()进行转换
      4.    String str4 = "200";
      5.    int num2 = Integer.parseInt(str4);
      6.    System.out.println(num2 + 100);
      7. }
      8. }

3.5 字符串数据排序案例（应用）

  • 案例需求
    有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：27 38 46 50 91

  • 代码实现

    1. /**
    2. *  需求：
    3. *  有一个字符串：“91 27 46 38 50”，把其中的每一个数存到int类型的数组中
    4. *  步骤:
    5. *    定义一个字符串
    6. *    把字符串中的数字数据存储到一个int类型的数组中
    7. *    遍历数组输出结果
    8. */
    9. public class MainClass {
    10.   public static void main(String[] args) {
    11.       String s = "91 27 46 38 50";
    12.       //获取字符串中的每一个数字.
    13.       String[] strArr = s.split(" ");
    15.       //创建一个int类型的数组.
    16.       int[] numberArr = new int[strArr.length];
    18.       //把strArr中的数据进行类型转换并存入到int数组中
    19.       for (int i = 0; i < strArr.length; i++) {
    20.           int number = Integer.parseInt(strArr[i]);
    21.           numberArr[i] = number;
    22.       }
    24.       //遍历int类型的数组
    25.       for (int i = 0; i < numberArr.length; i++) {
    26.           System.out.println(numberArr[i]);
    27.       }
    28.   }
    29. }

4.数组的高级操作

4.1 二分查找 (理解)

  • 二分查找概述
    • 查找指定元素在数组中的位置时,以前的方式是通过遍历，逐个获取每个元素,看是否是要查找的元素,这种方式当数组元素较多时,查找的效率很低
    • 二分查找也叫折半查找，每次可以去掉一半的查找范围，从而提高查找的效率

2020-07-10_081255.png

  • 需求
    在数组{1,2,3,4,5,6,7,8,9,10}中,查找某个元素的位置
  • 实现步骤
    1. 定义两个变量，表示要查找的范围。默认min = 0 ，max = 最大索引
    2. 循环查找，但是min <= max
    3. 计算出mid的值 （min+max）>>1
    4. 判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
    5. 如果要查找的值在mid的左半边，那么min值不变，max = mid -1.继续下次循环查找
    6. 如果要查找的值在mid的右半边，那么max值不变，min = mid + 1.继续下次循环查找
    7. 当min > max 时，表示要查找的元素在数组中不存在，返回-1.

  • 代码实现 ```java public class MyBinarySearchDemo { public static void main(String[] args) {

    1.   int [] arr = {1,2,3,4,5,6,7,8,9,10};
    2.   int number = 11;
    4.   //1.我现在要干嘛? --- 二分查找
    5.   //2.我干这件事情需要什么? --- 数组 元素
    6.   //3.我干完了,要不要把结果返回调用者 --- 把索引返回给调用者
    7.   int index = binarySearchForIndex(arr,number);
    8.   System.out.println(index);

    }

    private static int binarySearchForIndex(int[] arr, int number) {

    1.   //1,定义查找的范围
    2.   int min = 0;
    3.   int max = arr.length - 1;
    4.   //2.循环查找 min <= max
    5.   while(min <= max){
    6.       //3.计算出中间位置 mid
    7.       int mid = (min + max) >> 1;
    8.       //mid指向的元素 > number
    9.       if(arr[mid] > number){
    10.           //表示要查找的元素在左边.
    11.           max = mid -1;
    12.       }else if(arr[mid] < number){
    13.           //mid指向的元素 < number
    14.           //表示要查找的元素在右边.
    15.           min = mid + 1;
    16.       }else{
    17.           //mid指向的元素 == number
    18.           return mid;
    19.       }
    20.   }
    21.   //如果min大于了max就表示元素不存在,返回-1.
    22.   return -1;

    }

}

  2. - 注意事项
  3.    - **有一个前提条件，数组内的元素一定要按照大小顺序排列，如果没有大小顺序，是不能使用二分查找法的**
  5. <a name="f375b024"></a>
  6. ### 4.2 冒泡排序 (理解)
  8. - 冒泡排序概述<br />一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序<br />如果有n个数据进行排序，总共需要比较n-1次<br />每一次比较完毕，下一次的比较就会少一个数据参与
  9. - 代码实现
  10. ```java
  11. public class MyBubbleSortDemo2 {
  12.     public static void main(String[] args) {
  13.         int[] arr = {3, 5, 2, 1, 4};
  14.         //1 2 3 4 5
  15.         bubbleSort(arr);
  16.     }
  18.     private static void bubbleSort(int[] arr) {
  19.         //外层循环控制的是次数 比数组的长度少一次.
  20.         for (int i = 0; i < arr.length -1; i++) {
  21.             //内存循环就是实际循环比较的
  22.             //-1 是为了让数组不要越界
  23.             //-i 每一轮结束之后,我们就会少比一个数字.
  24.             for (int j = 0; j < arr.length - 1 - i; j++) {
  25.                 if (arr[j] > arr[j + 1]) {
  26.                     int temp = arr[j];
  27.                     arr[j] = arr[j + 1];
  28.                     arr[j + 1] = temp;
  29.                 }
  30.             }
  31.         }
  33.         printArr(arr);
  34.     }
  36.     private static void printArr(int[] arr) {
  37.         for (int i = 0; i < arr.length; i++) {
  38.             System.out.print(arr[i] + " ");
  39.         }
  40.         System.out.println();
  41.     }
  43. }

4.3 递归【应用】

  • 递归的介绍
    • 以编程的角度来看，递归指的是方法定义中调用方法本身的现象
    • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
    • 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

  • 递归的基本使用

    1. public class MyFactorialDemo2 {
    2.   public static void main(String[] args) {
    3.       int sum = getSum(100);
    4.       System.out.println(sum);
    5.   }
    7.   private static int getSum(int i) {
    8.       //1- 100之间的和
    9.           //100 + (1-99之间的和)
    10.                   // 99 + (1- 98之间的和)
    11.                       //....
    12.                           //1
    13.       //方法的作用: 求 1- i 之间和
    14.       if(i == 1){
    15.           return 1;
    16.       }else{
    17.           return i + getSum(i -1);
    18.       }
    19.   }
    20. }

  • 递归的注意事项

    • 递归一定要有出口。否则内存溢出
    • 递归虽然有出口，但是递归的次数也不宜过多。否则内存溢出

4.4 递归求阶乘【应用】

  • 案例需求
    用递归求5的阶乘，并把结果在控制台输出

  • 代码实现

    1. public class DiGuiDemo01 {
    2.   public static void main(String[] args) {
    3.       //调用方法
    4.       int result = jc(5);
    5.       //输出结果
    6.       System.out.println("5的阶乘是：" + result);
    7.   }
    9.   //定义一个方法，用于递归求阶乘，参数为一个int类型的变量
    10.   public static int jc(int n) {
    11.       //在方法内部判断该变量的值是否是1
    12.       if(n == 1) {
    13.           //是：返回1
    14.           return 1;
    15.       } else {
    16.           //不是：返回n*(n-1)!
    17.           return n*jc(n-1);
    18.       }
    19.   }
    20. }

  • 内存图
    08_递归内存图.png

4.5 快速排序 (理解)

  • 快速排序概述
    冒泡排序算法中,一次循环结束,就相当于确定了当前的最大值,也能确定最大值在数组中应存入的位置
    快速排序算法中,每一次递归时以第一个数为基准数,找到数组中所有比基准数小的.再找到所有比基准数大的.小的全部放左边,大的全部放右边,确定基准数的正确位置
  • 核心步骤
    1. 从右开始找比基准数小的
    2. 从左开始找比基准数大的
    3. 交换两个值的位置
    4. 红色继续往左找，蓝色继续往右找，直到两个箭头指向同一个索引为止
    5. 基准数归位

  • 代码实现

    1. public class MyQuiteSortDemo2 {
    2.   public static void main(String[] args) {
    3. //        1，从右开始找比基准数小的
    4. //        2，从左开始找比基准数大的
    5. //        3，交换两个值的位置
    6. //        4，红色继续往左找，蓝色继续往右找，直到两个箭头指向同一个索引为止
    7. //        5，基准数归位
    8.       int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};
    10.       quiteSort(arr,0,arr.length-1);
    12.       for (int i = 0; i < arr.length; i++) {
    13.           System.out.print(arr[i] + " ");
    14.       }
    15.   }
    17.   private static void quiteSort(int[] arr, int left, int right) {
    18.        // 递归结束的条件
    19.       if(right < left){
    20.           return;
    21.       }
    23.       int left0 = left;
    24.       int right0 = right;
    25.       //计算出基准数
    26.       int baseNumber = arr[left0];
    28.       while(left != right){
    29. //        1，从右开始找比基准数小的
    30.           while(arr[right] >= baseNumber && right > left){
    31.               right--;
    32.           }
    33. //        2，从左开始找比基准数大的
    34.           while(arr[left] <= baseNumber && right > left){
    35.               left++;
    36.           }
    37. //        3，交换两个值的位置
    38.           int temp = arr[left];
    39.           arr[left] = arr[right];
    40.           arr[right] = temp;
    41.       }
    42.       //基准数归位
    43.       int temp = arr[left];
    44.       arr[left] = arr[left0];
    45.       arr[left0] = temp;
    47.       // 递归调用自己,将左半部分排好序
    48.       quiteSort(arr,left0,left-1);
    49.         // 递归调用自己,将右半部分排好序
    50.       quiteSort(arr,left +1,right0);
    51.   }
    52. }

4.6 Arrays (应用)

  • Arrays的常用方法 | 方法名 | 说明 | | —- | —- | | public static String toString(int[] a) | 返回指定数组的内容的字符串表示形式 | | public static void sort(int[] a) | 按照数字顺序排列指定的数组 | | public static int binarySearch(int[] a, int key) | 利用二分查找返回指定元素的索引 |

  • 示例代码

    1. public class MyArraysDemo {
    2.     public static void main(String[] args) {
    3. //        public static String toString(int[] a)    返回指定数组的内容的字符串表示形式
    4. //        int [] arr = {3,2,4,6,7};
    5. //        System.out.println(Arrays.toString(arr));
    7. //        public static void sort(int[] a)      按照数字顺序排列指定的数组
    8. //        int [] arr = {3,2,4,6,7};
    9. //        Arrays.sort(arr);
    10. //        System.out.println(Arrays.toString(arr));
    12. //        public static int binarySearch(int[] a, int key) 利用二分查找返回指定元素的索引
    13.         int [] arr = {1,2,3,4,5,6,7,8,9,10};
    14.         int index = Arrays.binarySearch(arr, 0);
    15.         System.out.println(index);
    16.         //1,数组必须有序
    17.         //2.如果要查找的元素存在,那么返回的是这个元素实际的索引
    18.         //3.如果要查找的元素不存在,那么返回的是 (-插入点-1)
    19.             //插入点:如果这个元素在数组中,他应该在哪个索引上.
    20.     }
    21. }

  • 工具类设计思想

    1. 构造方法用 private 修饰
    2. 成员用 public static 修饰