[Java知识库]常用API

1、Math类：

没有构造方法，如何使用类中的成员呢？
看类的成员是否都是静态，如果是，通过类名就可以直接调用

random()：左闭右开，取不到1

package learn;

public class TestDemo {
    public static void main(String[] args){
        System.out.println(Math.ceil(12.34));//13.0
        System.out.println(Math.floor(12.34));//12.0
        //返回值都是一个double类型的整数
        System.out.println(Math.round(12.56F));//四舍五入，数字后面要加F
        System.out.println(((int)Math.random()*100)+1);//产生1到100的随机数
    }
}

2、System类：

package learn;

public class TestDemo {
    public static void main(String[] args){
        System.out.println(System.currentTimeMillis()*1.0/1000/3600/24/365);//整数相除结果为整数，为使结果更精确，*1.0化为浮点数
        //返回毫秒，毫秒和秒相差1000，此处计算结果为和1970年相距的年份

        long start=System.currentTimeMillis();
        for(int i=0;i<1000;i++) {
            System.out.println(i);
        }
        long end=System.currentTimeMillis();
        System.out.println("共耗时："+(end-start)+"毫秒");
    }
}

3、Object类：

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或间接继承自该类
构造方法：public Object()
面向对象中，为什么子类的构造方法默认访问的是父类的无参构造方法？
因为他们的顶级父类只有无参构造方法

看方法的源码：选中方法，按下Ctrl+B

1、Object类的toString()方法

package learn;

public class Student {
    public String name;
    public 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 +
                '}';
    }
}

package learn;

public class TestDemo {
    public static void main(String[] args){
        Student s=new Student();
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s);//learn.Student@1b6d3586  Student中没有toString方法，调用的是Object中的（所有类默认继承自Object）
        System.out.println(s.toString());//learn.Student@1b6d3586
        /*
        public void println(Object x) {
            String s = String.valueOf(x);
            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());
        }
        */
    }
}
/*
输出:
Student{name='林青霞', age=30}
Student{name='林青霞', age=30}
*/

public String toString?()返回对象的字符串表示形式。 一般来说， toString方法返回一个“ toString代表”这个对象的字符串。 结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖（即重写）此方法。
如何重写？自动生成即可。（AIt+Insert->toString()）

2、Object类的equals()方法

package learn;

public class Student {
    public String name;
    public 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;
    }
}

package learn;

public class TestDemo {
    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==s2);
        System.out.println(s1.equals(s2));
    }
}
/*
输出：
false
false
*/

重写equals()方法：

package learn;

public class Student {
    public String name;
    public 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;
        //判断参数是否为null，判断两个对象是否来自同一个类

        Student student = (Student) o;//向下转型

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
}

System.out.println(s1.equals(s2));输出结果变为：true

4、Arrays类：

Arrays类是一个工具类
工具类的设计思想：构造方法用private修饰，防止外界创建对象。成员用public static修饰，为了让我们可以使用类名直接访问成员方法。

5、基本类型包装类：

package learn;

public class TestDemo {
    public static void main(String[] args){
        /*
        public static final int MAX_VALUE;
        public static final int MIN_VALUE;
        在两者之间即为整数
        */
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //2147483647 即 2^31-1
        //-2147483648 即 2^31
    }
}

将基本数据类型封装成对象的好处在于：可以在对象中定义更多的功能方法操作该数据
常用操作之一：用于基本数据类型与字符串之间的转换
特殊：int->Integer；char->Character
其余：首字符变为大写 (eg.byte->Byte)

Integer类的概述和使用：
Integer：包装一个对象中的原始类型int的值t
1、public static Integer valueOf(int i)：返回表示指定的int值的Integer实例
2、public static Integer valueOf(String s)：返回一个保存指定值的Integer对象String

package learn;

public class TestDemo {
    public static void main(String[] args){
        Integer i1=Integer.valueOf(100);
        System.out.println(i1);
        Integer i2=Integer.valueOf("100");//字符串内必须为数字，eg.不允许为"abc"
        System.out.println(i2);
    }
}

int和String的相互转换：
1、int转换为String：
public static String valueOf(int i)：返回int参数的字符串表示形式。该方法是String类中的方法
2、String转换为int：
public static int parseInt(String s)：将字符串解析为int类型。该方法是Integer类中的方法

package learn;

public class TestDemo {
    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：String->Integer->int
        Integer i=Integer.valueOf(s);
        System.out.println(i);
        //方式2
        int x=Integer.parseInt(s);
        System.out.println(x);
    }
}

案例：

package learn;

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args){
        //需求：有一个字符串"91 27 46 38 50",输出："27 38 46 50 91"
        String s="91 27 46 38 50";
        String[] strArrays=s.split(" ");

        int[]arr=new int[strArrays.length];
        for(int i=0;i< strArrays.length;i++){
            arr[i]=Integer.parseInt(strArrays[i]);
        }

        Arrays.sort(arr);

        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 x=sb.toString();
        System.out.println(x);
    }
}

自动装箱和拆箱：
装箱：把基本数据类型转换为对应的包装类类型
拆箱：把包装类类型转换为对应的基本数据类型
注意： 在使用包装类类型的时候，如果做操作，最好先判断是否为null
建议：只要是对象，在使用前就必须进行不为null的判断

package learn;

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args){
        Integer i=Integer.valueOf(100);//装箱
        Integer ii=100;//自动装箱
        //ii=ii.intValue()+100;//拆箱后自动装箱
        ii+=100;//自动拆箱
        System.out.println(ii);

        Integer iii=null;
        if(iii!=null) {
            iii += 300;//NullPointerException
        /*
        iii+=300;执行过程中自动拆箱，其实包含着iii.intValue()操作，而空指针是不能调用方法的
         */
        }
    }
}

日期类：Date、SimpleDateFormat、Calendar

6、Date类：

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

package learn;

import java.util.Date;

public class TestDemo {
    public static void main(String[] args){
        Date d1=new Date();
        System.out.println(d1);

        Date d2=new Date(1000*60*60);
        System.out.println(d2);
        //Sat Jan 29 15:12:21 CST 2022
        //Thu Jan 01 09:00:00 CST 1970//中国东八区，1点加8个小时
        //标准基准时间:1970 0时
    }
}

2、常用方法：
public long getTime()：获取的是日期对象从1970年1月1日00：00：00到现在的毫秒值
public void setTime()：设置时间，给的是毫秒值

package learn;

import java.util.Date;

public class TestDemo {
    public static void main(String[] args){
        Date d=new Date();
        System.out.println(d);
        d.setTime(1000*60*60);
        System.out.println(d);
        //Sat Jan 29 15:58:06 CST 2022
        //Thu Jan 01 09:00:00 CST 1970
    }
}

7、SimpleDateFormat类：

概述：SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
常用模式字母及对应关系：
y 年
M 月
d 日
H 时
m 分
s 秒

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

SimpleDateFormat格式化和解析日期：
（1）格式化（从Date到String）
public final String format(Date date)：将日期格式化成日期/时间字符串
（2）解析
public Date parse(String source)：从给定字符串的开始解析文本以生成日期

package learn;

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

public class TestDemo {
    public static void main(String[] args) throws ParseException {
        Date d=new Date();
        //格式化:Date->String
        SimpleDateFormat sdf=new SimpleDateFormat();
        String s=sdf.format(d);
        System.out.println(s);
        //22-1-29 下午4:51
        SimpleDateFormat sdf2=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");//eg.年有4位，所以用4个y
        String s2=sdf2.format(d);
        System.out.println(s2);
        //2022年01月29日 16:51:17
        System.out.println();
        //解析:String->Date，解析成为一个日期对象
        String ss="2022-1-22 11:11:11";
        SimpleDateFormat sdf3=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//格式和待解析字符串要匹配
        Date d3=sdf3.parse(ss);
        System.out.println(d3);
        //Sat Jan 22 11:11:11 CST 2022
    }
}

8、Calendar类：

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

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

public int get?(int field)：可用于获取年月日

package learn;

import java.util.Calendar;

public class TestDemo {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        System.out.println(c);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;//因为它的月份从0起
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
        //2022年1月31日
    }
}

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

package learn;

import java.util.Calendar;

public class TestDemo {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        System.out.println(c);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;//因为它的月份从0起
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
        //2022年1月31日

        //需求：10年后的5天前
        c.add(Calendar.YEAR,10);
        c.add(Calendar.DATE,-5);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH) + 1;
        date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");//2032年1月26日
    }
}

案例：二月天
需求：获取任意一年的二月有多少天

package learn;

import java.util.Calendar;
import java.util.Scanner;

public class TestDemo {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入年份");//键盘录入年份
        int year=sc.nextInt();
        
        Calendar c=Calendar.getInstance();

        c.set(year,2,1);//月份设置为3月，但因月份从0开始,所以设置值为2
        //3月1日往前推一天就是2月最后一天，即为2月天数
        c.add(Calendar.DATE,-1);

        int date=c.get(Calendar.DATE);
        System.out.println(date);
    }
}