13.常用API

常用API

Math

常用方法

演示

package commonApi.math;

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

        System.out.println("--------");
        System.out.println(Math.ceil(12.34));
        System.out.println(Math.ceil(12.56));

        System.out.println("--------");
        System.out.println(Math.floor(12.34));
        System.out.println(Math.floor(12.56));

        System.out.println("--------");
        System.out.println(Math.round(12.34F));
        System.out.println(Math.round(12.56F));

        System.out.println("--------");
        System.out.println(Math.max(66, 88));
        System.out.println(Math.min(66, 88));

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

        System.out.println("--------");
        System.out.println(Math.random());
        System.out.println(Math.random()*100);
        System.out.println((int)(Math.random()*100));
    }
}

System

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

system类的常用方法

demo

package commonApi.system;

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("start");
        // System.exit(0);  // 终止当前java虚拟机
        System.out.println("end");

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

Object类

object是类层次结构的根, 每个类都可以将Object作为超类. 所有类都直接或者间接的继承自该类.

构造方法: public Object()

子类构造方法默认访问的是父类的无参构造方法? 因为顶级父类只有无参构造方法

常用方法

Student

package commonApi.object;

import java.util.Objects;

public 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 --- s2
            0    --- s3
         */
        // 比较地址是否相同
        if (this == o) return true;
        // 判断参数是否为null
        // 判断两个对象是否来自同一个类
        if (o == null || getClass() != o.getClass()) return false;

        // 向下转型
        Student student = (Student) o;  // student = s2
        // 比较年龄和姓名是否相同
        return age == student.age &&
                Objects.equals(name, student.name);
    }
}

ObjectDemo

package commonApi.object;

/*
    查看源码,选中方法, Ctrl + B
 */

public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s);  // commonApi.object.Student@27f674d
        System.out.println(s.toString());

        /*
        public void println(Object x) {
            String s = String.valueOf(x);
            synchronized (this) {
                print(s);
                newLine();
            }
        }
         */


        Student s2 = new Student();
        s2.setName("林青霞");
        s2.setAge(30);

        Student s3 = new Student();
        s3.setName("林青霞");
        s3.setAge(30);

        // 比较两个对象是否相同
        System.out.println(s2 == s3);
        System.out.println(s2.equals(s3));
    }
}

Arrays

冒泡排序: 将一组数据按照固定的规则进行排序

冒泡排序: 一种排序规则, 对要进行排序的数据中相邻的数据进行两两比较, 将较大的数据放在后面, 一次对所有的数据进行操作, 直至所有数据按要求完成排序.

如果有n个数据进行排序,总计需要比较n-1次

每次比较完毕,下一次比较就会少一个数据参与

BubbleSort

package commonApi.arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
        System.out.println("排序前:" + arrayToString(arr));

        // 冒泡排序对数组排序过程
        /*
        for (int i=0; i<arr.length - 1; 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));

        for (int i=0; i<arr.length - 1 -1; 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));

        for (int i=0; i<arr.length - 1 -2; 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));

        for (int i=0; i<arr.length - 1 -3; 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));
        */
         // 优化版本
        for (int x=0; x<arr.length-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;
    }
}

Arrays类

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

ArrayDemo

package commonApi.arrays;

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        // 定义数组
        int[] arr = {24, 69, 80, 57, 13};

        System.out.println("排序前:" + Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }
}

工具类的设计思想:

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

基本类型包装类

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

常用的操作之一: 用于基本数据类型与字符串之间的转换

Integer

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

demo

package commonApi.decorateClass;

public class IntegerDemo {
    public static void main(String[] args) {
        // 需求: 判断一个整数在int 范围内
        // public static final int MIN_VALUE
        // public static final int MAX_VALUE
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);

        /*
        // public Integer(int value)
        Integer i1 = new Integer(100);
        System.out.println(i1);

        // public Integer(String s)
        Integer i2 = new Integer("100");
        System.out.println(i2);
         */

        // public static Integer valueOf(int i)
        Integer i3 = Integer.valueOf(100);
        System.out.println(i3);

        // public static Integer valueOf(String s)
        Integer s4 = Integer.valueOf("100");
        System.out.println(s4);
    }
}

注意: 静态方法不需要用new

int和String的相互装换

基本类型包装类的常见操作: 用于基本类型和字符串之间的相互转换

Int 转换为String

• public static String valueOf(int i): 返回int参数的字符串形式. 该方法是String类中的方法

String 转换为int

• pulic static int parseInt(String s): 将字符串解析为int类型. 该方法是Integer类中的方法

demo

package commonApi.decorateClass;

public class ConvertDemo {
    public static void main(String[] args) {
        // int --> String
        int number = 100;
        // 方式1
        String s1 = "" + number;
        System.out.println(s1);

        // 方式2
        String s2 = String.valueOf(number);
        System.out.println(s2);

        System.out.println("--------");
        // String -->  int
        String s = "100";
        // 方式1
        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);
    }
}

自动装箱和拆箱

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

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

Integer i = 100; // 自动装箱, 将基本类型int变为Integer
i += 200;  // i = i + 200; i + 200 自动拆箱; i = i + 200 自动装箱

注意: 在使用包装类类型时, 如果做操作, 最好先判断是否为nulll

我们推荐的是, 只要是对象, 在使用钱就必须进行部位null 的判断

PackAndUnpack

package commonApi.decorateClass;

public class PackAndUnpack {
    public static void main(String[] args) {
        // 装箱: 把基本数据类型装换为对应的包装类类型
        Integer i = Integer.valueOf(100);
        Integer ii = 100;  // 自动装箱, 底层也是调用: Integer.valueOf(100);

        //拆箱: 把包装类类型转换为对应的基本数据类类型
        // ii += 200;
        ii = ii.intValue() + 200;  // intValue拆箱后变成基本类型
        System.out.println(ii);

        ii += 200;  // 自动拆箱, 底层也是调用: Integer.intValue(ii);
        System.out.println(ii);

        Integer iii = null;
        // iii += 300;  //NullPointerException
        if (iii != null) {
            iii += 300;
        }
        System.out.println(iii);

    }
}

日期类

date类

date类代表了一个特定的时间, 精确到毫秒

构造方法

常见方法

DateDemo

package commonApi.decorateClass;

import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        // public Date()

        Date d1 = new Date();
        System.out.println(d1);

        // public Date(long date):
        long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);


        // 创建时间日期对象
        Date d = new Date();
        // public long getTime()
        System.out.println(d.getTime()*1.0/1000/60/60/24/365 + "年");

        // public void setTime()
        long time = 1000*60*60;
        d.setTime(time);
        System.out.println(d);
        
        long time1 = System.currentTimeMillis();
        d.setTime(time1);
        System.out.println(d);
    }
}

SimpleDateFormat类

SimpleDateFormat是一个具体类, 用于以区域设置敏感的方式格式化和解析日期. 重点学习日期格式化和解析

日期和时间格式有日期和时间模式字符串指定, 在日期和时间模式字符串中, 从"A"到"Z"以及从"a" 到 "z"引号的字幕被解释为表示日期或时间字符串的组件的模式字母.

常见模式字母对应:

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

构造方法

格式化和解析方法

1. 格式化(从Date到String)

   • public final String format(Date date): 将日期格式化为日期/时间字符串

2. 解析(从String到Date)

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

SimpleDateFormatDemo

package commonApi.decorateClass;

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

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

        // 解析: 从 String 到 Date
        String s1 = "2020-10-14 11:11:11";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d2 = sdf2.parse(s1);
        System.out.println(d2);
    }
}

Calendar类

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

• 提供了一个getInstance用于获取Calendar对象, 其日历字段已使用当前日期和时间初始化;
• Calendar rightNow = Calendar.getInstance();

常用方法

CalendarDemo

package commonApi.decorateClass;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        // 获取对象
        Calendar c = Calendar.getInstance();  // 多态形式得到对象
        System.out.println(c);

        // public int get(int field)
        /*
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

         */

        // public abstract void add(int field, int amount)
        // 10年后的5天前
        /*
        c.add(Calendar.YEAR, 10);
        c.add(Calendar.DATE, -5);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

         */

        //Public final void set(int year, int month, int date)
        c.set(2030, Calendar.NOVEMBER,20);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}