Java高级01-API

目录

一、API

1.什么是API

2.API文档的使用

二、Math

三、System

四、Object类

五、Objects类

六、BigDecimal（精确计算）

七、基本数据类型的包装类

八、String类

九、StringBuilder类

1.概述

2.作用

3.常用方法

4.StringBuilder提高效率原理

5.练习

（1）对称字符串判断

（2）字符串拼接

十、数组高级操作

（一）查找

1.基本查找

2.二分查找（前提：元素有大小顺序）

（二）排序

1.冒泡排序

（三）递归

十一、Arrays

十二、Throwable

n、练习：

1.有一个字符串:“91 274 6 38 50”把其中的每一个数存到int类型的数组中

2.键盘录入，限制范围1到100，超出范围/错误类型都不能赋值，需要重新录入，直到成功为止

---

一、API

1.什么是API

应用程序接口

简单来说就是Java已经写好的一些方法，直接拿过来用即可。

2.API文档的使用

二、Math

自行查阅api文档~

方法名（参数类型）	返回值类型	说明
abs(double/float/long/int)	double	绝对值
ceil（double）	double	向上取整
floor（double）	double	向下取整
round（double/float）	long/int	四舍五入
min（a，b）		俩数较小值
max（a，b）		俩数较大值
pow（double a，double b）	double	幂运算
random()	double	[0,1)

主要方法：绝对值，向上取整，向下取整，四舍五入，俩数最大值，俩数最小值，幂运算，随机数[0-1）

三、System

自行查阅api文档~

主要方法：终止当前运行的虚拟机，当前时间（毫秒），数组copy

四、Object类

自行查阅api文档~

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

主要：toString，equals（默认比较地址，重写后比内容【自动生成】）

构造方法：public Object{}

问题1：为什么子类的构造方法默认访问的是父类的无参构造方法？

答：顶级父类只有无参构造方法

问题：为什么直接输出实例化对象是地址值？怎么输出其属性值？

答：要输出其属性值，仅需重写Object类的toString方法

问题：为何都是false？怎么改才为true？

package api;
​
public class Student {
    String name;
    int age;
​
    public Student() {
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Application {
​
​
    public static void main(String[] args) {
        Student student1 = new Student("张三",20);
        Student student2 = new Student("张三",20);
        //false
        System.out.println(student1 == student2);
        //false
        System.out.println(student1.equals(student2));
    }
​
}

答：

== 比较的是地址值，student1和student2都是new出来的，地址值不一样，故为false

观察Student类可知，该类并没有重写Object的equals方法，而Object类的equals方法底层实现还是==，故为false

重写Object的equals方法

package api;
​
import java.util.Objects;
​
public class Student {
    String name;
    int age;
​
    public Student() {
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //可自动生成 alt + ins
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Student)) {
            return false;
        }
        Student student = (Student) o;
        return age == student.age && name.equals(student.name);
    }
    
}

五、Objects类

自行查阅api文档~

常用方法：toString，isNull，nonNull

package api;
​
import java.util.Objects;
​
public class Student {
    String name;
    int age;
​
    public Student() {
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}'+"检查是否运行";
    }
​
}
​

package api;
import java.util.Objects;
public class Application {
​
    public static void main(String[] args) {
        Student student1 = new Student("张三",20);
        final String s = Objects.toString(student1);
        System.out.println(s);
        
        Student student2 = new Student("张三",20);
        final String s = Objects.toString(student2, "随便写的");
        System.out.println(s);
  
    }
​
}

package api;
import java.util.Objects;
public class Application {
​
    public static void main(String[] args) {
​
        Student student2 = new Student("张三",20);
        student2 = null;
        final String s = Objects.toString(student2, "随便写的");
        System.out.println(s);
  
    }
​
}

六、BigDecimal（精确计算）

public class BigDecimal01 {
    public static void main(String[] args) {
        System.out.println(10.0/3.0);
    }
}
主要方法：add，subtract，multiply，divide

public class BigDecimal01 {
    public static void main(String[] args) {
        System.out.println(10.0/3.0);
        //如果要精确计算，请使用字符串的构造
        BigDecimal bigDecimal1 = new BigDecimal(0.1);
        BigDecimal bigDecimal2 = new BigDecimal(0.2);
        System.out.println(bigDecimal1);
        System.out.println(bigDecimal2);
​
        BigDecimal add = bigDecimal1.add(bigDecimal2);
        System.out.println(add);
        System.out.println(0.1+0.2);
​
    }
}

特殊：

public class BigDecimal01 {
    public static void main(String[] args) {
        System.out.println(10.0/3.0);
        //如果要精确计算，请使用字符串的构造
        BigDecimal bigDecimal1 = new BigDecimal(0.1);
        BigDecimal bigDecimal2 = new BigDecimal(0.2);
        System.out.println(bigDecimal1.divide(另一个bigDecimal对象,精确几位，舍入模式【进一法，去尾法，四舍五入法】));
        System.out.println(bigDecimal1.divide(bigDecimal2,5,BigDecimal.ROUND_UP));
​
​
    }
}

七、基本数据类型的包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

简单来说就是更好的操作数据！

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Byte，Short，Integer，Long，Float，Double常用方法：valueof，自动拆装箱

装箱：把一个基本数据类型转为对应的包装类

拆箱：把一个包装类转为对应的基本数据类型

自动：自动调用valueof方法

注意：在使用包装类类型进行操作的时候，最好先判断一下是否为null

Integer成员方法：parseInt-字符串转int类

int类转字符串的两种方法

• 1.直接+“”

• 2.使用String类的valueof方法

八、String类

常用方法：

方法名（参数类型）	返回类型	作用
length()	int	得到一个字符串的字符个数
getBytes()	byte[]	将一个字符串转换成字节数组
toCharArray()	char[]	将一个字符串转换成字符数组
split(String)	String[]	将一个字符串按照指定内容分割
equals(String)	boolean	判断两个字符串的内容是否一模一样
equalsIgnoreCase(String)	boolean	判断两个字符串的内容是否一模一样（忽略大小写）
contains(String)	boolean	判断一个字符串里面是否包含指定的内容
startsWith(String)	boolean	判断一个字符串是否以指定的内容开头
endsWith(String)	boolean	判断一个字符串是否以指定的内容结尾
toUpperCase()	String	将一个字符串全部转换成大写
toLowerCase()	String	将一个字符串全部转换成小写
replace(String ,String )	String	将某个内容全部替换成指定内容
replaceAll(String,String)	String	将某个内容全部替换成指定内容，支持正则
repalceFirst(String,String)	String	将第一次出现的某个内容替换成指定的内容
substring(int)	String	从指定下标开始一直截取到字符串的最后
substring(int ,int)	String	从下标x截取到下标y-1对应的元素
trim()	String	去除一个字符串的前后空格
charAt(int)	char	得到指定下标位置对应的字符
indexOf(String)	int	得到指定内容第一次出现的下标
lastIndexOf(String)	int	得到指定内容最后一次出现的下标

九、StringBuilder类

1.概述

StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器

2.作用

• 提高字符串的操作效率

3.常用方法

• 构造

方法名	说明
StringBuilder（）	创建一个空白可变字符串对象，不含有任何内容（空容器）
StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

• 方法

方法名	返回值类型	说明
append（任意数据类型）	StringBuilder	添加数据，并返回对象本身（可链式添加）
reverse（）	StringBuilder	返回相反的字符序列
length（）	int	返回长度(字符出现的个数)
toString（）	String	StringBuilder转换为String

4.StringBuilder提高效率原理

public class Test {
    public static void main(String[]args) {
        String s1 ="a";
        String s2 = s1 + "b";
        String s3 = s2 + "c";
        System.out.println(s3);
    }
  
}

• 字节码文件会先加载进方法区

• 其内有个main方法

• 虚拟机调用main方法进到栈内存，开始执行代码

• String s1 = “a”，使用双引号创建字符串对象，会先检查常量池中是否拥有，如果没有则创建一个，s1指向常量池中“a”的地址

• String s2 = s1 + "b";使用双引号创建字符串对象，会先检查常量池中是否拥有，如果没有则创建一个，往后出现字符串+号的字符串拼接，在Java中，只要出现+号的字符串拼接，系统底层就会自动在堆内存中创建一个StringBuilder对象，然后调用该对象的append方法完成拼接，拼接完成之后还会调用其toString方法转为String对象，之后s2的引用指向String对象的“ab”

• String s3 = s2 + "c";使用双引号创建字符串对象，会先检查常量池中是否拥有，如果没有则创建一个，再次出现+号拼接字符串，再次创建一个StringBuilder对象，然后调用该对象的append方法完成拼接，拼接完成之后还会调用其toString方法转为String对象，之后s2的引用指向String对象的“abc”

简单说：一个+号，堆中就会出现一个StringBuilder对象

用StringBuilder对象做拼接在堆中只会创建一个StringBuilder对象

5.练习

（1）对称字符串判断

如：abcba

反转相同即可

public class Test {
    public static void main(String[]args) {
        String s = "abcba";
        StringBuilder sb = new StringBuilder(s);
        if (s.equals(sb.reverse().toString())){
            System.out.println(true);
        }
    }

}

（2）字符串拼接

把int数组中的数据按照指定的格式拼接成一个字符审返回，并在控制台输出结果。

例如，数组为int[] arr ={1,2,3};，输出结果为:[1,2,3]

public class Test {
    public static void main(String[]args) {
        int[] arr = {1,2,3};
        //1
        StringBuilder sb = new StringBuilder(Arrays.toString(arr).replace(" ",""));
        System.out.println(sb);

        //2
        StringBuilder sb2 = new StringBuilder("[");
 
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length-1){
                sb2.append(arr[i]).append("]");
            }else {
                sb2.append(arr[i]).append(",");
            }

        }
     
        System.out.println(sb2.toString());
    }

}

十、数组高级操作

（一）查找

1.基本查找

2.二分查找（前提：元素有大小顺序）

步骤：

• 定义两个变量表示要查找的范围，min = 0，max = 最大下标

• 循环查找，但要满足 min <= max

• 计算mid的值（向下取整）

• 判断mid下标所对应的值是否与要查找的值相等，如果相等则返回下标，如果不等，判断是否比要查找的值大

• 如果大，则在左边min值不变，max = mid-1;

• 如果小，则在右边max值不变，min = mid+1

• 当min > max时，返回-1，表示不存在

package api;
​
import java.util.Arrays;
​
public class BinarySearch {
    public static void main(String[] args) {
        int[] nums = {  684, 789, 138, 938, 523, 583, 41, 143, 520, 665,
                        344, 749, 188, 142, 787, 760, 281, 461, 274, 796,
                        861, 539, 297, 386, 540, 462, 110, 469, 98, 186,
                        564, 744, 309, 170, 940, 334, 496, 572, 747, 45,
                        532, 753, 374, 159, 26, 855, 762, 863, 748, 301,
                        248, 437, 225, 859, 941, 894, 471, 244, 928, 955,
                        690, 241, 717, 59, 643, 963, 750, 688, 500, 332,
                        33, 619, 647, 18, 493, 381, 470, 713, 678, 636,
                        566, 124, 152, 966, 669, 344, 488, 556, 298,
                        157, 757, 350, 715, 714, 958, 431, 73, 244, 789, 237};
        int[] nums02 = new int[nums.length];
        //先将数组排序
        Arrays.sort(nums);
        System.out.println("排序后");
        System.out.println(Arrays.toString(nums));
        //数组复制
        System.arraycopy(nums,0,nums02,0,nums.length);
        //数组2
        System.out.println("数组2");
        System.out.println(Arrays.toString(nums02));
        //随机选一个数查找309
        int n = 1000;
​
        BinarySearch binarySearch = new BinarySearch();
        final int i = binarySearch.binarySearch(nums02,n);
        System.out.println("数字"+n+"在数组中的下标为"+i);
​
        final int j = binarySearch.generalSearch(nums02, n);
        System.out.println("数字"+n+"在数组中的下标为"+j);
​
    }
​
    public int binarySearch(int[] nums,int search){
        int min = 0;
        int max = nums.length-1;
        int mid = 0;
        final long start = System.currentTimeMillis();
        long end;
        while (min <= max){
            mid = (min+max)/2;
            if (nums[mid] == search){
                break;
​
            }else if (nums[mid] > search){
                max = mid-1;
            }else if (nums[mid] < search){
                min = mid+1;
            }
        }
        if (min>max){
            mid = -1;
        }
        end = System.currentTimeMillis();
        long time = end-start;
        System.out.println("二分查找用时："+time);
​
        return mid;
    }
​
    public int generalSearch(int[] nums,int search){
        int n = 0;
        final long start = System.currentTimeMillis();
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == search){
                n = i;
                break;
            }else {
                n = -1;
            }
        }
        final long end = System.currentTimeMillis();
        System.out.println("普通用时："+(end-start));
        return n;
    }
}

​

（二）排序

1.冒泡排序

前面写过，这里就写步骤了

• 相邻的元素两两比较，大的放右边，小的放左边，找到最大值

• 第一次循环结束后，最大值已经确定，放在了数组最右边

• 下一次循环只要从剩下的元素中重复第一二步即可

• 如果有n个数据需要排序，仅需比较n-1次

（三）递归

前面写过

十一、Arrays

常用方法：toString，sort，binarySearch（int[] a,int key）

注意：binarySearch

• 传入的数组必须有序

• 如果查找的元素存在，会返回该元素实际的下标/索引

• 如果不存在，返回的是（-插入点-1）

插入点：如果这个元素存在，它应该在哪个下标上？

如int[] nums = {1,2,3,4,5,6,7,8,9,10},

要查找11，因为不存在，则会返回（-10-1）/-11

要查找0，因为不存在，则会返回（0-1）/-1

十二、Throwable

常用成员方法：

成员方法	返回值类型	说明
getMessage（）	String	返回此throwable的详细消息字符串。
toString（）	String	返回此可抛出的简短描述
printStackTrace（）	void	把异常信息输出到控制台（红色字体）

n、练习：

1.有一个字符串:“91 274 6 38 50”把其中的每一个数存到int类型的数组中

public class Practice01 {
    public static void main(String[] args) {
        String s1 = "91 274 6 38 50";
        String[] strArr = s1.split(" ");
​
        int[] numArr = new int[strArr.length];
​
        for (int i = 0; i < strArr.length; i++) {
            numArr[i] = Integer.parseInt(strArr[i]);
        }
​
        for (int n: numArr) {
            System.out.println(n);
        }
    }
}

2.键盘录入，限制范围1到100，超出范围/错误类型都不能赋值，需要重新录入，直到成功为止

懒得写了，自己练吧~