Java基础 - 7 - 常用API（二）

学习ing小白

已于 2024-04-08 16:01:28 修改

阅读量868

点赞数 23

分类专栏： Java学习文章标签： java 开发语言

于 2024-03-01 23:22:05 首次发布

本文链接：https://blog.csdn.net/qq_50755868/article/details/136378454

版权

Java学习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

API（全称 Application Programming Interface：应用程序编程接口）

API就是Java帮我们已经写好的一些程序，如类、方法等，可以直接拿过来用

JDK8 API文档：Java Platform SE 8

一. Object

Object类的作用

Object类是Java中所有类的祖宗类，因此，Java中所有类的对象都可以直接使用Object类中提供的一些方法

Object类的常见方法

方法名	说明
public String toString()	返回对象的字符串表示形式
public boolean equals(Object o)	判断两个对象是否相等
protected Object clone()	对象克隆

toString存在的意义：toString()方法存在的意义就是为了被子类重写，以便返回对象具体的内容

equals存在的意义：直接比较两个对象的地址是否相同完全可以用==代替equals，equals存在的意义就是为了被子类重写，以便子类自己来定制比较规则（比如比较对象内容）

clone()方法

当某个对象调用这个方法时，这个方法会复制一个一模一样的新对象返回

clone()方法分为浅克隆和深克隆

浅克隆：拷贝出的新对象，与原对象中的数据一模一样（引用类型拷贝的只是地址）

深克隆：对象中基本类型的数据直接拷贝，字符串数据拷贝的还是地址，对象中还包含的其他对象，不会拷贝地址，会创建新对象

//demo
public class demo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student("小美",20,new double[]{99,100,90});
        System.out.println(s1);  //默认输出s1就是输出s1.toString()
        System.out.println(s1.toString());  //不重写toString方法的话返回的是s的地址

        Student s2 = new Student("小美",20,new double[]{99,100,90});
//        //不重写equals方法
//        System.out.println(s2.equals(s1));  // false  equals方法判断两个对象的地址是否相等
//        System.out.println(s2 == s1);  // false 比较两个对象地址是否一样，可以直接用==
//        Student s3 = s1;
//        System.out.println(s3.equals(s1));  // true   equals方法判断两个对象的地址是否相等

        System.out.println(s2.equals(s1));  //true 重写了equals方法

        //s1.clone(); //因为clone()方法是protected的，因此不能直接使用，需要重写clone()方法
        Student s4 = (Student) s1.clone(); //重写后
        System.out.println(s4.getName());  //小美
        System.out.println(s4.getAge());  //20
        System.out.println(s4.getScore());
        System.out.println(s4 == s1);  //false，克隆后s4和s1的地址不一样（克隆只是复制内容）
        System.out.println(s4.equals(s1));  //true（重写后的equals方法比较内容是否相同）

    }
}

//Student
//Cloneable是一个标记接口（实现Cloneable接口，才能使用clone()方法）
public class Student implements Cloneable {  //extends Object
    private String name;
    private int age;
    private double[] score;  //学生成绩数组（如语数英三门成绩）

    public Student() {
    }

    public Student(String name, int age, double[] score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //通过super调用父类Object中的clone方法
        //浅克隆
        //return super.clone();  //等同于 Student s = (Student) super.clone(); return s;

        //深克隆
        Student s = (Student) super.clone();
        s.score = s.score.clone(); //对象中基本类型的数据直接拷贝，字符串数据拷贝的还是地址，对象中还包含的其他对象，不会拷贝地址，会创建新对象 
        return s;
    }

    //重写toString方法，得到对象内容（自动生成）
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + Arrays.toString(score) +
                '}';
    }

    //重写equals方法，比较两个对象的内容是否一致（自动生成）
    //比较者：s2 == this
    //被比较者；s1 == o
    @Override
    public boolean equals(Object o) {
        //判断两个对象地址是否一致，一致直接返回true
        if (this == o) return true;
        //判断o是否是null，o是null直接返回false
        //判断比较者和被比较者的类型是否一致，不一致直接返回false
        //这里的getClass()相当于this.getClass()
        if (o == null || getClass() != o.getClass()) return false;
        //因为接收的时候是Object类型，这里需要进行强转为Student
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name) &&
                Arrays.equals(score, student.score);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, 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;
    }

    public double[] getScore() {
        return score;
    }

    public void setScore(double[] score) {
        this.score = score;
    }
}

二. Objects

Objects

Objects是一个工具类，提供了很多操作对象的静态方法给我们使用

（静态方法可以直接用类名.静态方法）

Objects类的常见方法

方法名	说明
public static boolean equals(Object a,Object b)	先做非空判断，再比较两个对象
public static boolean isNull(Object obj)	判断对象是否为null，为null返回true，反之返回false
public static boolean nonNull(Object obj)	判断对象是否不为null，不为null返回true，反之返回false

//demo
public class demo {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = "zhang";
        //System.out.println(s1.equals(s2)); //如果s1是null，这种比较方法会报错（空指针异常 NullPointerException）
        System.out.println(Objects.equals(s1, s2)); //更安全

        System.out.println(Objects.isNull(s1));  //true
        System.out.println(s1 == null);  //true
        System.out.println(Objects.isNull(s2));  //false
        System.out.println(s2 == null);  //false

        System.out.println(Objects.nonNull(s1));  //false
        System.out.println(Objects.nonNull(s2));  //true

    }
}

三. 包装类

Java的思想是万物皆对象，但是Java基本类型的数据（byte short int long char float double boolean）不是对象，因此引入了包装类

包装类

包装类就是把基本类型的数据包装成对象

基本数据类型	对应的包装类（引用数据类型）
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

包装类的其他常见操作

· 可以把基本类型的数据转换成字符串类型（toString()）

· 可以把字符串类型的数值转换成数值本身对应的数据类型（valueOf()更推荐）

//demo
public class demo {
    public static void main(String[] args) {
        //Integer a = new Integer(12);  //过时方案
        Integer a = Integer.valueOf(12);
        System.out.println(a);

        //自动装箱机制：可以自动把基本类型的数据转换成对象
        Integer b = 12;
        //自动拆箱机制：可以自动把包装类型的对象转换成对应的基本数据类型
        int c = b;

        //泛型和集合不支持基本数据类型，只能支持引用数据类型
        //ArrayList<int> list = new ArrayList<>();  //报错
        ArrayList<Integer> list = new ArrayList<>();
        list.add(12);  //自动装箱
        int r = list.get(0); //自动拆箱

        System.out.println("=======================");

        //1.把基本类型的数据转换成字符串
        Integer x = 23;  //自动装箱
        String s1 = Integer.toString(x);  //自动拆箱  Integer.toString(x)把x转换成字符串类型
        System.out.println(s1 + 1);  //231

        String s2 = x.toString();  //继承Object类，toString()也是转换成字符串
        System.out.println(s2 + 1);  //231

        String s3 = x + "";  //这样也可以转换成字符串
        System.out.println(s3 + 1);  //231

        //2.把字符串类型的数值转换成对应的基本类型
        //字符串类型的数值!!!不是数值没法转换
        //不是对应的数据类型也没办法转换，字符串中的数值是浮点型，不能用Integer
        String m1 = "29";
        //int z1 = Integer.parseInt(m1);  //字符串转换成对应的基本类型 parseInt()不推荐使用
        int z1 = Integer.valueOf(m1);
        System.out.println(z1 + 1);  //30

        String m2 = "99.5";
        //double z2 = Double.parseDouble(m2);  //字符串转换成对应的基本类型 parseDouble()不推荐使用
        double z2 = Double.valueOf(m2);
        System.out.println(z2 + 1);  //100.5
    }
}

四. StringBuilder

StringBuilder代表可变字符串对象，相当于一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的

好处：StringBuilder比String更适合做字符串的修改操作，效率会更高，代码也会更简洁

构造器	说明
public StringBuilder()	创建一个空白的可变的字符串对象，不包含任何内容
public StringBuilder(String str)	创建一个指定字符串内容的可变字符串对象

方法名称	说明
public StringBuilder append(任意类型)	添加数据并返回StringBuilder对象本身
public StringBuilder reverse()	将对象的内容反转
public int length()	返回对象内容长度
public String toString()	通过toString()就可以实现把StringBuilder转换为String

//demo
public class demo {
    public static void main(String[] args) {
        //StringBuilder sb = new StringBuilder();  //sb ""
        StringBuilder sb = new StringBuilder("wosun");

        //1.拼接内容
        sb.append(12);  //拼接int
        sb.append(true);  //拼接boolean
        sb.append(13.14);  //拼接double/float
        sb.append("你好");  //拼接String

        //支持链式编程
        sb.append(1).append('a').append(5.20).append(false);

        System.out.println(sb);

        //2.内容反转
        sb.reverse();  //内容反转
        System.out.println(sb);

        //3.返回字符串长度
        System.out.println(sb.length());

        //4.把StringBuilder对象又转换成String类型
        String s = sb.toString();
        System.out.println(s);

        System.out.println("======================");

        //需求：拼接100万次abc
        //String   很很恨很慢
//        String rs = "";
//        for (int i = 0; i < 1000000; i++) {
//            rs += "abc";
//        }
//        System.out.println(rs);

        //StringBuilder 非常快
        StringBuilder rs = new StringBuilder();
        for (int i = 0; i < 1000000; i++) {
            rs.append("abc");
        }
        System.out.println(rs);
    }
}

注意：如果操作字符串较少，或者不需要操作，以及定义字符串变量，还是建议使用String；如果需要频繁的拼接、修改等，建议使用StringBuilder

案例：返回任意整型数组的内容

//demo
public class demo {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1,2,3,4,5};
        System.out.println(method(arr1));
        int[] arr2 = new int[5];
        System.out.println(method(arr2));
        int[] arr3 = null;
        System.out.println(method(arr3));
    }

    //一般来说返回值是String，不会是StringBuilder
    public static String method(int[] arr){
        //！！！要先进行非空校验，判断arr是否为null
        if(arr == null){
            return null;  //数组对象不存在
        }
        //数组对象存在
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
//            if(i==0){
//                sb.append("[");
//            }
            sb.append(arr[i]);
            if(i!=arr.length-1){
                sb.append(",");
            }else{
                sb.append("]");
            }
        }
        return sb.toString();
    }
}

五. StringBuffer

StringBuffer的用法和StringBuilder是一模一样的，但StringBuilder是线程不安全的，StringBuffer是线程安全的

六. StringJoiner

StringJoiner是JDK8开始才有的，跟StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的

好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁

构造器	说明
public StringJoiner(间隔符号)	创建一个StringJoiner对象，指定拼接时的间隔符号
public StringJoiner(间隔符号,开始符号,结束符号)	创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号

方法名称	说明
public StringJoiner add(添加de)	添加数据，并返回对象本身
public int length()	返回长度（字符出现的个数）
public String toString()	返回一个字符串（该字符串就是拼接后的结果）

//demo
public class demo {
    public static void main(String[] args) {
        //StringJoiner s = new StringJoiner(",");  //间隔符
        StringJoiner s = new StringJoiner(",","[","]");  //间隔符 开始符 结束符
        s.add("java1");
        s.add("java2");
        s.add("java3");
        System.out.println(s);  //java1,java2,java3

        int[] arr = new int[]{1,2,3,4,5};
        System.out.println(method(arr));
    }

    public static String method(int[] arr){
        if(arr == null){
            return null;
        }
        StringJoiner sj = new StringJoiner(",","[","]");
        for (int i = 0; i < arr.length; i++) {
            String s = arr[i] + "";  //把数组里的整型数值 转换成 字符串
            sj.add(s);
        }
        return sj.toString();
    }
}

七. Math

代表数学，是一个工具类，里面提供的都是对数据进行操作的一些静态方法

Math类提供的常见方法

方法名	说明
public static int abs(int a)	获取参数绝对值
public static double ceil(double a)	向上取整
public static double floor(double a)	向下取整
public static long 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 random()	返回值为double的随机值，范围[0.0 , 1.0]

//demo
public class demo {
    public static void main(String[] args) {
// 获取参数绝对值 public static int abs(int a)	获取参数绝对值
// 获取参数绝对值 public static double abs(double a)
        System.out.println(Math.abs(-12));  //12
        System.out.println(Math.abs(123));  //123
        System.out.println(Math.abs(0));  //0
        System.out.println(Math.abs(-13.14));  //13.14

// 向上取整 public static double ceil(double a)
        System.out.println(Math.ceil(4.3));  //5.0
        System.out.println(Math.ceil(3));  //3.0

// 向下取整 public static double floor(double a)
        System.out.println(Math.floor(4.99));  //4.0
        System.out.println(Math.floor(3));  //3.0

// 四舍五入 public static long round(float a)
        System.out.println(Math.round(4.49));  //4
        System.out.println(Math.round(4.51));  //5

// 获取两个int值中的较大值 public static int max(int a,int b) (还可以是浮点型或long型)
// 获取两个int值中的较小值 public static int min(int a,int b)
        System.out.println(Math.max(10,20));  //20
        System.out.println(Math.min(10,20));  //10
        System.out.println(Math.min(10.07,10.09));  //10.07

// 返回a的b次幂的值 public static double pow(double a,double b)
        System.out.println(Math.pow(2, 3));  //8.0
// 返回值为double的随机值，范围[0.0 , 1.0] public static double random()
        System.out.println(Math.random());  //随机数 如0.5848377958673234
    }
}

八. System

System代表程序所在的系统，也是一个工具类

System类提供的常见方法

方法名	说明
public static void exit(int status)	终止当前运行的Java虚拟机
public static long currentTimeMillis()	返回当前系统的时间毫秒值形式

时间毫秒值：指的是从1970年1月1日00:00:00走到此刻的总的毫秒值（ms） 1s=1000ms

//demo
public class demo {
    public static void main(String[] args) {
//        public static void exit(int status)
        //终止当前运行的Java虚拟机
        //该参数用作状态代码，按照惯例，非零状态代码表示异常终止
        //System.exit(0); //人为终止虚拟机（不要使用）
        System.out.println("===============");

//        public static long currentTimeMillis()
        //返回当前系统的时间毫秒值形式
        Long l1 = System.currentTimeMillis();
        System.out.println(l1);

        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }

        Long l2 = System.currentTimeMillis();
        System.out.println((l2-l1)/1000.0 +"s");  //l2-l1是毫秒值
        //时间差即两次时间中间程序的运行时间，可以做程序的性能分析
    }
}

九. Runtime

Runtime代表程序所在的运行环境

Runtime是一个单例类

Runtime类提供的常见方法

方法名	说明
public static Runtime getRuntime()	返回与当前Java应用程序关联的运行时对象
public void exit(int status)	终止当前运行的虚拟机
public int availableProcessors()	返回Java虚拟机可用的处理器数
public long totalMemory()	返回Java虚拟机中的内存总量
public long freeMemory()	返回Java虚拟机中的可用内存
public Process exec(String command)	启动某个程序，并返回代表该程序的对象

//demo
public class demo {
    public static void main(String[] args) throws IOException, InterruptedException {
        //public static Runtime getRuntime() 返回与当前Java应用程序关联的运行时对象
        Runtime r = Runtime.getRuntime();

        //public void exit(int status) 终止当前运行的虚拟机，该参数用作状态代码；按照惯例，非零状态代码表示异常终止
        //r.exit(0);  //不要使用

        //public int availableProcessors() 返回Java虚拟机可用的处理器数
        System.out.println(r.availableProcessors());

        //public long totalMemory() 返回Java虚拟机中的内存总量
        //1024 = 1Kb  1024 * 1024 = 1Mb
        System.out.println(r.totalMemory());  //返回的是字节
        System.out.println(r.totalMemory() / 1024.0 +"Kb");
        System.out.println(r.totalMemory() / 1024.0 /1024.0 +"Mb");

        //public long freeMemory() 返回Java虚拟机中的可用内存
        System.out.println(r.freeMemory() );
        System.out.println(r.freeMemory() / 1024.0 /1024.0 +"MB");

        //public Process exec(String command) 启动某个程序，并返回代表该程序的对象
        Process p = r.exec("");  //电脑中QQ程序的地址
        //r.exec("QQ");  //想要这样直接启动QQ，需要把QQ配置到环境变量
        Thread.sleep(5000);  //让程序在这里暂停5s再往下走
        p.destroy();  //销毁（即关闭程序）
    }
}

十. BigDecimal

用来解决浮点型运算时，出现结果失真的问题

BigDecimal的常见构造器、常用方法

构造器	说明
public BigDecimal(double val) 注意：不推荐用这个	将double转换为BIgDecimal
public BigDecimal(String val)	将String转换为BIgDecimal

方法名	说明
public static BigDecimal valueOf(double val)	转换一个double成BIgDecimal
public BigDecimal add(BigDecimal b)	加法
public BigDecimal subtract(BigDecimal b)	减法
public BigDecimal multiply(BigDecimal b)	乘法
public BigDecimal divide(BigDecimal b)	除法
public BigDecimal divide(另一个BigDecimal对象，精确几位，舍入模式) public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)	除法，可以控制精确到小数几位
public double doubleValue()	将BigDecimal转换为double

//demo
public class demo {
    public static void main(String[] args) throws IOException, InterruptedException {
        System.out.println(0.1+0.2);  //0.30000000000000004  失真
        System.out.println("=====================");

        //把他们变成字符串封装成BigDecimal对象来运算
        double a = 0.1;
        double b = 0.2;
//public BigDecimal(String val)	将String转换为BIgDecimal
        //BigDecimal a1 = new BigDecimal(Double.toString(a));
        //BigDecimal b1 = new BigDecimal(Double.toString(b));

        //推荐用以下方式：把小数转换成字符串再得到BigDecimal对象来使用（更简洁）
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);

        BigDecimal c1 = a1.add(b1);
        BigDecimal c2 = a1.subtract(b1);
        BigDecimal c3 = a1.multiply(b1);
        BigDecimal c4 = a1.divide(b1);
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);

        //除法中如果除不尽，不给精确位数，会报错
        BigDecimal x = BigDecimal.valueOf(0.1);
        BigDecimal y = BigDecimal.valueOf(0.3);
        //System.out.println(x.divide(y)); //报错 没有精确值
        System.out.println(x.divide(y,2, RoundingMode.HALF_UP));  //0.4
        //不会写代码的时候用ctrl+alt+空格

        //public double doubleValue() 将BigDecimal转换为double
        double m = x.doubleValue();
        System.out.println(m);
    }
}