Java之API使用(二)

我们在前面的文章中给大家初步介绍了Java中​​API的使用方式​​。本文继续给大家介绍JavaAPI中常见的API，让大家对Java中常见的方法优格清晰地了解，最后通过一些案例供大家练习。首先大家介绍一些常见的API。

1.常用的API

1.1 Math

• 1、​​​Math类概述​​​

• Math 包含执行基本数字运算的方法

• 2、​​​Math中方法的调用方式​​​

• Math类中无构造方法，但内部的方法都是静态的，则可以通过​类名.进行调用​

• 3、​​​Math类的常用方法​​​

1.2 System

• ​​​System类的常用方法​​​

我们通过一个案例对上面的API的相关方法用法做一个总结，具体需求如下：

​需求​：在控制台输出1-10000，计算这段代码执行了多少毫秒

根据其需求我们给出如下的代码：

public class SystemDemo {
    public static void main(String[] args) {
        // 获取开始的时间节点
        long start = System.currentTimeMillis();
        for (int i = 1; i <= 10000; i++) {
            System.out.println(i);
        }
        // 获取代码运行结束后的时间节点
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }
}

该需求执行的结果如下：

1.3 Object类的toString方法

• ​​​Object类概述​​​

• Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份

• ​​​查看方法源码的方式​​​

• 选中方法，按下Ctrl + B

• ​​​重写toString方法的方式​​​

• 1. Alt + Insert 选择toString
• 2. 在类的空白区域，右键 -> Generate -> 选择toString

• ​​​toString方法的作用​​：

• 以良好的格式，更方便的展示对象中的属性值

我们通过一个案例对上面的API的相关方法用法做一个总结，具体实现如下：

class Student extends Object {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("一计之长");
        s.setAge(30);
        System.out.println(s); 
        System.out.println(s.toString()); 
    }
}

• 通过以上代码，我们试着分析出以下的运行结果：

Student{name='一计之长', age=30}
Student{name='一计之长', age=30}

我们通过Eclipse验证一下，具体执行如下：

结果与我们所分析的是一致的。

1.4 Object类的equals方法

• ​​​equals方法的作用(经常的面试题)​​​

• 用于对象之间的比较，返回true和false的结果
• 举例：s1.equals(s2); s1和s2是两个对象

• ​​​重写equals方法的场景​​​

• 不希望比较对象的地址值，想要结合对象属性进行比较的时候。

• ​​​重写equals方法的方式(开发中经常重写)​​​

• 1. alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
• 2. 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。

我们通过一个案例对上面的API的相关方法用法做一个总结，具体实现如下：

class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public boolean equals(Object o) {
        //this -- s1
        //o -- s2
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o; //student -- s2

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
}
public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("一计之长");
        s1.setAge(30);

        Student s2 = new Student();
        s2.setName("一计之长");
        s2.setAge(30);

        //需求：比较两个对象的内容是否相同
        System.out.println(s1.equals(s2));
    }
}

具体的执行结果如下：

1.5 冒泡排序原理

• ​​​冒泡排序概述​​​

• 一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序

• 如果有n个数据进行排序，总共需要比较n-1次
• 每一次比较完毕，下一次的比较就会少一个数据参与

1.6 冒泡排序代码实现（面试题)

具体实现如下：

/*
    冒泡排序：
        一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，
        依次对所有的数据进行操作，直至所有数据按要求完成排序
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24, 69, 80, 57, 13};
        System.out.println("排序前：" + arrayToString(arr));

        // 这里减1，是控制每轮比较的次数
        for (int x = 0; x < arr.length - 1; x++) {
            // -1是为了避免索引越界，-x是为了调高比较效率
            for (int i = 0; i < arr.length - 1 - x; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        System.out.println("排序后：" + arrayToString(arr));

    }

    //把数组中的元素按照指定的规则组成一个字符串：[元素1, 元素2, ...]
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

具体执行的结果如下：

1.7 Arrays

• ​​​Arrays的常用方法​​​

​​​​

• ​​​工具类设计思想​​​

1、构造方法用 private 修饰

2、成员用 public static 修饰

2.包装类

2.1基本类型包装类

• ​​​基本类型包装类的作用​​​

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据常用的操作之一：用于基本数据类型与字符串之间的转换

• 基本类型对应的包装类如下：

2.2 Integer类

• ​​​Integer类概述​​​

​包装一个对象中的原始类型 int 的值​

• ​​​Integer类构造方法​​​

我们通过如下的代码来实现以上API的具体用法：

public class IntegerDemo {
    public static void main(String[] args) {
        //public Integer(int value)：根据 int 值创建 Integer 对象(过时)
        Integer i1 = new Integer(100);
        System.out.println(i1);

        //public Integer(String s)：根据 String 值创建 Integer 对象(过时)
        Integer i2 = new Integer("100");
//        Integer i2 = new Integer("abc"); //NumberFormatException
        System.out.println(i2);
        System.out.println("--------");

        //public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
        Integer i3 = Integer.valueOf(100);
        System.out.println(i3);

        //public static Integer valueOf(String s)：返回一个保存指定值的Integer对象 String
        Integer i4 = Integer.valueOf("100");
        System.out.println(i4);
    }
}

具体执行的结果如下：

2.3 int和String类型的相互转换

• ​int转换为String​

• 转换方式

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

• 示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);
        //方式2
        //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------");
    }
}

具体执行结果如下：

• ​​​String转换为int​​​

• 转换方式

• 方式一：先将字符串数字转成Integer，再调用valueOf()方法
• 方式二：通过Integer静态方法parseInt()进行转换

• 示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

具体执行结果如下：

2.4字符串数据排序案例

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

具体代码实现如下：

import java.util.Arrays;
public class IntegerTest {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "91 27 46 38 50";

        //把字符串中的数字数据存储到一个int类型的数组中
        String[] strArray = s.split(" ");
//        for(int i=0; i<strArray.length; i++) {
//            System.out.println(strArray[i]);
//        }

        //定义一个int数组，把 String[] 数组中的每一个元素存储到 int 数组中
        int[] arr = new int[strArray.length];
        for(int i=0; i<arr.length; i++) {
            arr[i] = Integer.parseInt(strArray[i]);
        }

        //对 int 数组进行排序
        Arrays.sort(arr);

        //把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
        StringBuilder sb = new StringBuilder();
        for(int i=0; i<arr.length; i++) {
            if(i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();

        //输出结果
        System.out.println(result);
    }
}

具体执行结果如下：

2.5自动拆箱和自动装箱

• 自动装箱

  把基本数据类型转换为对应的包装类类型

• 自动拆箱

  把包装类类型转换为对应的基本数据类型

• 示例代码

Integer i = 100;  // 自动装箱
i += 200;         // i = i + 200;  i + 200 自动拆箱；i = i + 200; 是自动装箱

3.时间和日期

3.1 Date类

• ​Date类概述​

         Date 代表了一个特定的时间，精确到毫秒

• ​Date类构造方法​

  方法名	说明
  public Date()	分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
  public Date(long date)	分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

• ​示例代码​

import java.util.Date;
public class DateDemo01 {
    public static void main(String[] args) {
        //public Date()：分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
        Date d1 = new Date();
        System.out.println(d1);

        //public Date(long date)：分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
        long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);
    }
}

具体执行结果如下：

3.2Date类常用方法

• ​常用方法的方法如下：

• ​示例代码

import java.util.Date;
public class DateDemo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();

        //public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
//        System.out.println(d.getTime());
//        System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

        //public void setTime(long time):设置时间，给的是毫秒值
//        long time = 1000*60*60;
        long time = System.currentTimeMillis();
        d.setTime(time);

        System.out.println(d);
    }
}

具体执行结果如下：

总结

本文主要给大家介绍了API中常用的方法，这些方法在我们早日常的开发中经常使用，因此希望大家认真掌握。