常用API

1. Math

1.1 Math类概述

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

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

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

1.2 Math类的常用方法

package com.szy006;
/*
Math类的常用方法
 */
public class MathDemo {
    public static void main(String[] args) {
        //public static int abs(int a):返回参数的绝对值
        System.out.println(Math.abs(88));
        System.out.println(Math.abs(-34));
        System.out.println("-------------");
        //public static double ceil(double a):返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.34));
        System.out.println(Math.ceil(12.56));
        System.out.println("-------------");
        //public static double floor(double a):返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(12.13));
        System.out.println(Math.floor(-123.34));
        System.out.println("-------------");
        //public static int round(float a):按照四舍五入返回最接近参数的int
        System.out.println(Math.round(12.34F));
        System.out.println(Math.round(12.56F));
        System.out.println("-------------");
        //public static int max(int a,int b):返回两个int值中的较大值
        System.out.println(Math.max(34,67));
        System.out.println(Math.max(-23,-25));
        System.out.println("-------------");
        //public static int min(int a,int b):返回两个int值中的较小值
        System.out.println(Math.min(1,3));
        System.out.println(Math.min(-2,-3));
        System.out.println("-------------");
        //public static double pow(double a,double b):返回a的b次幂的值
        System.out.println(Math.pow(2.0,3.0));
        System.out.println(Math.pow(3,4));
        System.out.println("-------------");
        //public static double random():返回值为double 的正值，[0.0,0.1)
        System.out.println(Math.random());
        System.out.println(Math.random()*100);
        System.out.println(Math.random()*1000);//0-1000的随机数
        System.out.println((int)(Math.random()*100));//0-99的随机整数
        System.out.println((int)(Math.random()*100)+1);//0-100的随机整数

    }
}

2.System

2.1 System类概述

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

2.1 System类的常用方法

package com.szy006;
/*
System类的常用方法
 */
public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        //public static void exit(int status):终止当前运行的Java虚拟机，非零表示异常终止
//        System.exit(0);
        System.out.println("结束");
        //public static long currentTimeMillis():返回当前时间（以毫秒为单位）
//        System.out.println(System.currentTimeMillis());
        long start=System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            System.out.println(i);
        }
        long end=System.currentTimeMillis();
        System.out.println("共耗时："+(end-start)+"毫秒");
    }
}

3. Object

3.1 Object 类的概述

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

构造方法：public Object()

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

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

package com.szy008;

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 String toString() {//重写Object的toString()方法
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.szy008;
/*
看方法的原码，选中方法，按下Ctrl+B
 */
public class ObjectDemo {
    public static void main(String[] args) {
        Student s=new Student();
        s.setName("江小白");
        s.setAge(7);
        System.out.println(s);//com.szy008.Student@1b6d3586
        System.out.println(s.toString());//建议所有子类重写此方法

        /*
         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());
    }
         */
    }
}

3.2 Object类的常用方法

package com.szy009;

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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {//重写Object 的equals方法，使其比较的不再是地址值而是内容
        if (this == o) return true;//this--s1;o--s2
        //比较地址是否相同，(地址相同是同一个对象)如果相同直接返回true

        //判断参数是否为null（为null时没有必要比了）
        // 判断两个对象是否来自于同一个类
        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;
    }

}

package com.szy009;
/*
测试类
public boolean equals(Object obj):指示一些其他对象是否等于此
 */
public class ObjectDemo {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("张小凡");
        s1.setAge(27);
        Student s2=new Student();
        s2.setName("张小凡");
        s2.setAge(27);

        //需求：比较两个对象内容是否相同
        System.out.println(s1.equals(s2));
        /*
        public boolean equals(Object obj) {
        return (this == obj);//比较的是地址值
    }
         */
    }
}

4. Arrays

4.1冒泡排序

排序：将一组数据按照固定的规则进行排列

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

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

冒泡排序代码实现：

package com.szy010;

public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24,69,80,57,13};
        int temp;
        for (int j = 0; j < arr.length-1; j++) {
            for (int i = 0; i < arr.length - j-1; i++) {
                if (arr[i] > arr[i + 1]) {
                    temp = arr[i + 1];
                    arr[i + 1] = arr[i];
                    arr[i] = temp;
                }

            }
            System.out.println("第"+(j+1)+"次比较后："+arrayToString(arr));
        }

    }
    //把数组中的元素按照指定的规则组成一个字符串：
    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;
    }


}

4.2Arrays 类的概述和常用方法

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

Arrays 是工具类

一般工具类的设计思想是：

• 构造方法用private 修饰（防止外界创建对象）
• 成员用public static 修饰（使用类名来访问成员方法）

5.基本类型包装类

5.1基本类型包装类概述

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

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

package com.szy012;
/*
基本类型包装类
 */
public class IntegerDemo {
    public static void main(String[] args) {
        //需求：我要判断一个数据是否在int范围内
        //public static final MIN_VALUE
        //public static final MAX_VALUE
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
    }

}

5.2 Integer类的概述和使用

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

package com.szy012;
/*
构造方法：
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
 */
public class IntegerDemo2 {
    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 i1=Integer.valueOf(100);
        System.out.println(i1);
        Integer i2=Integer.valueOf("100");//这里的字符串只能是数字字符串
        System.out.println(i2);
    }
}

5.3int和String的相互转换

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

1. int转换为String

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

2. String转换为int

   public static int parselnt(String s):将字符串解析为int 类型，该方法是Integer类中的方法

package com.szy012;
/*
int和String的相互转换
 */
public class IntegerDemo3 {
    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
        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);

    }
}

案例：字符串中数据排序

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

package com.szy013;

import java.util.Arrays;

//需求：有一个字符串：“91 27 46 38 50”，
// 请写程序实现最终输出结果是：“27 38 46 50 91”
public class StringDemo {
    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[] arr=new int[strArray.length];
        for(int i=0;i<strArray.length;i++){
            arr[i]=Integer.parseInt(strArray[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 result=sb.toString();
        System.out.println(result);//输出字符串
    }
}

5.4自动装箱和拆箱

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

package com.szy013;
/*
 * 装箱:把基本数据类型转换为对应的包装类类型
 * 拆箱：把包装类类型转换为对应的基本数据类型
 */
public class IntegerDemo4 {
    public static void main(String[] args) {
        //装箱:把基本数据类型转换为对应的包装类类型
        Integer i=Integer.valueOf(100);//装箱
        Integer ii=100;//自动装箱

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

        Integer iii=null;
        if(iii!=null){
            iii+=300;//NullPointerException
        }
    }
}

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

注意：在使用包装类类型的时候，如果做操作，最好先判断是否为null

我们推荐的是，只要是对象，在使用前就必须进行不为null的判断

6.日期类

6.1Date类概述和构造方法

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

package com.szy001;

import java.util.Date;

/*
public Date():分配一个Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(Long date)：分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
 */
public class DateDemo {
    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);
    }
}

6.2Date类的常用方法

package com.szy001;

import java.util.Date;

/*
public long getTime():获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值
public void setTime(long time)：设置时间，给的是毫秒值
 */
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);
    }
}

6.3SimpleDateFormat类概述

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

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

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

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

6.4SimpleDateFormat的构造方法

1. 格式化（从Date到String）

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

2. 解析（从String到Date）

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

package com.szy001;

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

/*
构造方法：
public SimpleDateFormat():构造一个SimpleDateFormat,使用默认模式和日期格式
public SimpleDateFormat(String pattern):构造一个SimpleDateFormat使用给定的模式和默认的日期格式
格式化：从Date到String
    public final String format(Date date):将日期格式化成日期/时间字符串
解析：从String到Date
    public Date parse(String source):从给定字符串的开始解析文本以生成日期
 */
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);
        System.out.println("------------");

        //解析：从String到Date
        String ss="2022年3月11日 12:23:04";
        SimpleDateFormat sdf2=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date dd=sdf2.parse(ss);
        System.out.println(dd);
    }
}

案例：日期工具类

需求：定义一个日期工具类（DateUtils),包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类（DateDemo），测试日期工具类的方法。

package com.szy002;

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

public class DateUtils {
    public static String dateToString(Date d,String format){
        SimpleDateFormat sdf=new SimpleDateFormat(format);
        String s=sdf.format(d);
        return s;
    }
    public static Date StringToDate(String s,String format) throws ParseException {
        SimpleDateFormat sdf2=new SimpleDateFormat(format);
        Date d=sdf2.parse(s);
        return d;
    }
}

package com.szy002;

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

public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d=new Date();
        String s1=DateUtils.dateToString(d,"yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        String s2=DateUtils.dateToString(d,"yyyy年MM月dd日");
        System.out.println(s2);

        String s3=DateUtils.dateToString(d,"HH:mm:ss");
        System.out.println(s3);
        System.out.println("----------");

        String s="2044-08-09 12:10:02";
        Date d2=DateUtils.StringToDate(s,"yyyy-MM-dd HH:mm:ss") ;
        System.out.println(d2);
    }
}

6.6Calendar类概述

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

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

Calendar rightNow=Calendar.getInstance();

package com.szy003;

import java.util.Calendar;

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

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

        Calendar rightNow=Calendar.getInstance();*/
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)+1;
        int date=c.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+date+"日");

    }
}

6.7 Calendar的常用方法

package com.szy003;
import java.util.Calendar;
/*
public abstract void add(int field,int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year,int month,int date):设置当前日历的年月日
 */
public class CalendarDemo2 {
    public static void main(String[] args) {
        //获取日历类对象
        Calendar c=Calendar.getInstance();//多态的形式
        //public int get(int field)：返回给定日历字段的值
      /*  int year=c.get(Calendar.YEAR);
        int month=c.get(Calendar.MONTH)+1;
        int date=c.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+date+"日");*/
//        public abstract void add(int field,int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
//        c.add(Calendar.YEAR,3);//加3年：三年后的今天
        /*c.add(Calendar.DATE,-5);//五天前
        int year=c.get(Calendar.YEAR);
        int month=c.get(Calendar.MONTH)+1;
        int date=c.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+date+"日");*/

//        public final void set(int year,int month,int date):设置当前日历的年月日
        c.set(2048,11,11);//设置日历为2048年12月11日
        int year=c.get(Calendar.YEAR);
        int month=c.get(Calendar.MONTH)+1;
        int date=c.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+date+"日");
    }
}

案例：二月天

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

方法1：判断平闰年

package com.szy003;

import java.util.Scanner;

/*
二月天：获取任意一年的二月有多少天
 */
public class FebDay {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int year=sc.nextInt();
        if(year%4==0&&year%100!=0||year%400==0){
            System.out.println("29");
        }
        else{
            System.out.println("28");
        }
    }
}

方法2：获取该年的三月一号前一天的日期

package com.szy003;

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

public class FebDay2 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int year=sc.nextInt();
        //设置日历对象的年月日
        Calendar c=Calendar.getInstance();
        c.set(year,2,1);//该年的3月1日
        //三月1日往前一天就是二月的最后一天
        c.add(Calendar.DATE,-1);
        //获取这一天输出即可
        int date= c.get(Calendar.DATE);
        System.out.println(year+"年的2月份有"+date+"天");
    }
}