Java学习之常用API

2021-06-21

一些常用的Java内置类

1.Math类

1.1Math类介绍

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

没有构造方法，如何使用类中的成员呢？

看类的成员是否都是静态的，如果是，通过类名就可以直接调用

1.2Math类的常用方法

方法名	说明
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.3代码演示

package Java_API;

public class Apiof_Math {
    public static void main(String[] args) {
        System.out.println(Math.abs(66));
        System.out.println(Math.abs(-66));
        System.out.println("----------");

        System.out.println(Math.ceil(66.34));
        System.out.println(Math.ceil(-66.66));
        System.out.println("----------");

        System.out.println(Math.floor(66.34));
        System.out.println(Math.floor(-66.66));
        System.out.println("----------");

        System.out.println(Math.round(66.34));
        System.out.println(Math.round(66.66));
        System.out.println("----------");

        System.out.println(Math.max(1, 2));
        System.out.println("----------");

        System.out.println(Math.min(1, 2));
        System.out.println("----------");

        System.out.println(Math.pow(2, 2));
        System.out.println("----------");

        System.out.println((Math.random() * 100) + 1);
    }
}
//输出结果
/*
66
66
----------
67.0
-66.0
----------
66.0
-67.0
----------
66
67
----------
2
----------
1
----------
4.0
----------
44.98710013806295
*/

2.System类

2.1System类介绍

System包含几个有用的类字段和方法，它不能被实例化

2.2System的常用方法

方法名	说明
public static void exit(int status)	终止当前运行的Java虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)，以1970年为起始

2.3代码演示

package Java_API;

public class Apiof_System {
    public static void main(String[] args) {
        System.out.println("开始");
        //System.exit(0);
        System.out.println("结束");

        System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("用时" + (end - start) + "毫秒");
    }
}
//输出结果1
/*
开始

*/
//输出结果2
/*
开始
结束
51.504355388413245年
0
1
2
3
4
5
...
用时1317毫秒
*/

3.Object类

3.1Object类介绍

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或间接继承自该类
构造方法：public Object()

回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？

因为它们的顶级父类只有无参构造方法

3.2Object类常用方法

方法名	说明
public String toString()	返回对象字符串的表现形式。建议所有子类重写该方法，自动生成
public boolean equals(Object obj)	比较对象是否相等。默认比较地址，重写后可以比较内容，自动生成

3.3代码演示方法1

package Java_API;

public class Apiof_Object {
    private String name;
    private  int age;

    public Apiof_Object() {
    }

    public Apiof_Object(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;
    }

    //建议子类重写toString()方法
    @Override
    public String toString() {
        return "Apiof_Object{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

//Ctrl+B查看源码
public class Apiof_Object2 {
    public static void main(String[] args) {
        Apiof_Object n_1 = new Apiof_Object();
        n_1.setName("John");
        n_1.setAge(18);
        System.out.println(n_1); //Java_API.Apiof_Object@10f87f48
        /*
            public void println(Object x) {
            String s = String.valueOf(x);
            if (getClass() == PrintStream.class) {
                // need to apply String.valueOf again since first invocation
                // might return null
                writeln(String.valueOf(s));
            } else {
                synchronized (this) {
                    print(s);
                    newLine();
                }
            }
        }
         */

        /*
            public static String valueOf(Object obj) {
                return (obj == null) ? "null" : obj.toString();
            }
         */

        /*
            public String toString() {
                return getClass().getName() + "@" + Integer.toHexString(hashCode());
            }
         */
    }
}
//输出结果
/*
Apiof_Object{name='John', age=18}
*/

3.4代码演示方法2

package Java_API;

public class Apiof_Object3 {
    private String name;
    private int age;

    public Apiof_Object3() {
    }

    public Apiof_Object3(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 == s_1
            o    == s_2
         */
        //比较地址是否相同，如果相同，直接返回true
        if (this == o) return true;

        //判断参数是否为null
        //判断两个对象是否来自同一个类
        if (o == null || getClass() != o.getClass()) return false;

        //向下转型
        Apiof_Object3 that = (Apiof_Object3) o;

        //比较年龄是否相同
        if (age != that.age) return false;

        //比较姓名内容是否相同
        return name != null ? name.equals(that.name) : that.name == null;
    }
}

public class Apiof_Object4 {
    public static void main(String[] args) {
        Apiof_Object3 s_1 = new Apiof_Object3();
        s_1.setName("Angle");
        s_1.setAge(18);

        Apiof_Object3 s_2 = new Apiof_Object3();
        s_2.setName("Angle");
        s_2.setAge(18);

        System.out.println(s_1.equals(s_2));
    }
}
//输出结果
/*
	true
*/

4.Arrays类

4.1Arrays类介绍

Arrays类包含用于操作数组的各种方法

4.2Arrays类的常用方法

方法名	说明
public static String toString(int [ ] a)	返回指定数组的内容的字符串表示形式
public static void sort(int[ ] a)	按照数字顺序排列指定的数组

工具类的设计思想：

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

5.基本类型包装类

5.1基本类型包装类介绍

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

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

5.2求int类型的取值范围代码演示

package Java_BasicType;

import Java_InternalClass4.Inter;

public class Demo_1 {
    public static void main(String[] args) {
        //打印int类型的取值范围
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
    }
}
//输出
/*
	-2147483648
	2147483647
*/

5.3Integer类介绍

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

方法名	说明
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

5.4代码演示

package Java_API;

public class Apiof_基本类型包装类 {
    public static void main(String[] args) {
        /*
        Integer i1 = new Integer(100);
        System.out.println(i1);
        Integer i2 = new Integer("100");
        System.out.println(i2);
        //Integer i5 = new Integer("abc");
        //System.out.println(i5); //NumberFormatException
         */

        Integer i3 = Integer.valueOf(100);
        System.out.println(i3);
        Integer i4 = Integer.valueOf("100");
        System.out.println(i4);
        //Integer i6 = new Integer("abc");
        //System.out.println(i6); //NumberFormatException

        Double d1 = new Double(11.1);
        Double d2 = new Double("22.2");
        //Double d5 = new Double("abc"); //lang.Double
        System.out.println(d1);
        System.out.println(d2);

        Double d3 = Double.valueOf(33.3);
        Double d4 = Double.valueOf("44.4");
        //Double d6 = Double.valueOf("abc"); //lang.Double
        System.out.println(d3);
        System.out.println(d4);
    }
}

//输出结果
/*
	100
	100
	11.1
	22.2
	33.3
	44.4
*/

5.5 int和String类型的相互转换

基本类型包装类的最常见的操作就是：用于基本类型和字符之间的相互转换

5.5.1 int转换为String

public sataic String valueOf(int i)：返回int参数的字符串表示形式。该方法是String类中的方法

5.5.2代码演示

package Java_API;

public class Java_TypeChange_int_String {
    public static void main(String[] args) {
        //int类型与String类型之间的转换
        int number = 100;
        //方法1
        String i1 = "" + number;
        System.out.println(i1);
        //方法2
        String i2 = String.valueOf(number);
        System.out.println(i2);
    }
}
//输出结果
/*
	100
*/

5.5.3 String类型转换为int类型

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

5.5.4代码演示

package Java_API;

public class Java_TypeChange_int_String {
    public static void main(String[] args) {
        //String类型与int类型之间的转换
        String str = "999";
        //方法1
        Integer s1 = Integer.valueOf(str);
        int s2 = s1.intValue();
        System.out.println(s2);
        //方法2
        int s3 = Integer.parseInt(str);
        System.out.println(s3);
    }
}
//输出结果
/*
	999
	999
*/

6.自动装箱和拆箱

6.1装箱介绍

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

注意：在使用包装类类型的时候，如果做操作，最好先判断是否为null。老师的推荐是，只要是对象，在使用前就必须进行不为null的判断。

6.2代码演示

package Java_Api;

public class Java_自动装箱和拆箱 {
    public static void main(String[] args) {
        //自动装箱
        Integer i_1 = 100;
        //自动拆箱以及自动装箱
        i_1 += 100;
        Integer i_2 = Integer.valueOf(300);
        Integer i_3 = null;
        //i_3 += 400; //报错：NullPointerException
        if (i_3 != null){
            i_3 += 400;
        }
        System.out.println(i_1);
        System.out.println(i_2);
        System.out.println(i_3);
    }
}
//输出结果
/*
	200
	300
	null
*/

7.Date类

7.1Date介绍

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

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

7.2代码演示

package Java_Api;

import java.util.Date;

public class Java_Data类 {
    public static void main(String[] args) {
        Date d_1 = new Date();
        System.out.println(d_1);
        long time = 1000 * 60 * 60;
        Date d_2 = new Date(time);
        System.out.println(d_2);
    }
}
//输出结果
/*
	Sat Jul 03 12:52:06 CST 2021
	Thu Jan 01 09:00:00 CST 1970
*/

7.3Date类的常用方法

方法名	说明
public long getTime()	获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值
public void setTime(long time)	设置时间，给的是毫秒

7.3.1代码演示

package Java_Api;

import java.util.Date;

public class Java_Data类 {
    public static void main(String[] args) {
        Date d_4 = new Date();
        System.out.println(d_4.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
        d_4.setTime(time);
        System.out.println(d_4);
    }
}
//输出结果
/*
	51.53757118271182年
	Thu Jan 01 09:00:00 CST 1970
*/

7.4SimpleDateFormat类

SimpleDateFomat是一个具体的类，用于以区域的设置敏感的方式格式化和解析日期。我们重点学习日期的格式化和解析日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从’A’到’Z’以及’a’到’z’引号的字母被解释为表示日期或时间字符串的组件的模式字母。

常用的模式字母及对应关系如下：

y 年
M 月
d 日
H 时
m 分
s 秒

7.4.1SimpleDateFormat的构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

7.4.2SimpleDateFormat格式化和日期解析

格式化(从Date到String)

public final String format(Date date)：将日期格式转化成日期/时间字符串
解析(从String到Date)

public Date parse(String source)：给定字符串的开始解析文本以生成日期

7.4.3代码演示

package Java_Api;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Java_SimpleDateFormat类 {
    public static void main(String[] args) throws ParseException {
        Date d_1 = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String d_2 = sdf.format(d_1); //格式化
        System.out.println(d_2);

        String d_3 = "2021-08-03 13:37:00";
        SimpleDateFormat sdf_2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d_4 = sdf_2.parse(d_3); //解析
        System.out.println(d_4);
    }
}
//输出结果
/*
	2021年07月03日 13:40:35
	Tue Aug 03 13:37:00 CST 2021
*/

7.5Calendar类

7.5.1Calendar类介绍

Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

Calendar提供了一个类方法getlnstance用于获取Calendar对象，其日历字段已使用当前日期和时间格式化：

Calendar rightNow = Calendar.getInstance();

7.5.2代码演示

package Java_Api;

import java.util.Calendar;

public class Java_Calendar日期类 {
    public static void main(String[] args) {
        Calendar c_1 = Calendar.getInstance();
        int year = c_1.get(Calendar.YEAR);
        int month = c_1.get(Calendar.MONTH) + 1;
        int date = c_1.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}
//输出结果
/*
	2021年7月4日
*/

7.5.3Calendar的常用方法

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstract void add(int field, int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year, int month, int date)	设置当前日历的年月日

7.5.4代码演示add和set方法

package Java_Api;

import java.util.Calendar;

public class Java_Calendar日期类 {
    public static void main(String[] args) {
        Calendar c_1 = Calendar.getInstance();
        c_1.add(Calendar.YEAR, 10);
        c_1.add(Calendar.DATE, -3);
        int year = c_1.get(Calendar.YEAR);
        int month = c_1.get(Calendar.MONTH) + 1;
        int date = c_1.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

        c_1.set(2022, 8, 5);
        int year = c_1.get(Calendar.YEAR);
        int month = c_1.get(Calendar.MONTH);
        int date = c_1.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}
//第一部分输出结果为
/*
	2031年7月1日
*/
//第二部分输出结果为
/*
	2022年8月5日
*/