常用API

1、Math

1.1 Math类概述

包含基本数字运算的方法。

package Java16.Math;

public class demo1 {
    public static void main(String[] args) {
        //绝对值函数abs
        System.out.println(Math.abs(88));
        System.out.println(Math.abs(-88));
        System.out.println("------------");
        //返回大于或等于参数的最小double值,向上取整ceil
        System.out.println(Math.ceil(12.31));
        System.out.println(Math.ceil(12.545));
        System.out.println("------------");
        //返回小于等于参数的最小double值，向下取整floor
        System.out.println(Math.floor(12.31));
        System.out.println(Math.floor(14.21));
        System.out.println("----------------");
        //四舍五入取最近参数int型，round
        System.out.println(Math.round(12.31F));
        System.out.println(Math.round(11.99f));
        System.out.println("------------------");
        //比较int型数据取较大，max
        System.out.println(Math.max(12,14));
        System.out.println(Math.max(131,2391));
        System.out.println("-----------------");
        //比较int型数据取较小，min
        System.out.println(Math.min(13,31));
        System.out.println(Math.min(1344,1412));
        System.out.println("----------------");
        //计算幂指数，pow
        System.out.println(Math.pow(2,3));
        System.out.println(Math.pow(4.1,3));
        System.out.println("---------------");
        //取0-1随机数，random
        System.out.println(Math.random());
        System.out.println((int)(Math.random()*100));

    }
}

System 类

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

package Java16.System;

public class demo {
    public static void main(String[] args) {
        System.out.println("star");
        //终止当前运行的Java虚拟机，非零表示异常终止，exit(int status)
//        System.exit(0);
        System.out.println("end");
        //返回当前时间以毫秒为单位，currentTimeMillis().
//        System.out.println(System.currentTimeMillis()*1.0/1000/60/60/24/365+"年");
        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类

Object是类层次结构的跟，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类。
构造方法: public Object()
为什么说子类的构造方法默认访问的是父类的无参构造方法？因为它们的顶级父类只有无惨构造方法

4.Arrays

4.1冒泡排序法

对要进行排序的数据中相邻的数据进行两两比较将较大的数据放在后面，依次对所有数据进行操作，直到所有数据完成排序。

package Java16.Array.paixu;

public class demo {
    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++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }*/
        //冒泡排序法
        for(int x=0;x<arr.length;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));
    }

    //将数组元素组成一个字符串
    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.2 Arrays类的概述和常用方法

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

package Java16.Array.Arraysdemo;

import java.util.Arrays;

public class demo {
    public static void main(String[] args){
        //定义一个数组
        int[] arr={14,54,24,27,46,73};

        System.out.println("排序前："+ Arrays.toString(arr));

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

工具类的设计思想：
构造方法用private修饰
成员用public static修饰

5. 基本类型包装类

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

基本数据类型和包装类的对于关系

5.1 Integer类的概述和使用（其它几个自学）

Integer类包装一个对象中的原始类型int的值。 类型为Integer的对象包含一个单一字段，其类型为int 。
此外，该类还提供了一些将int转换为String和String转换为int ，以及在处理int时有用的其他常量和方法。

（已过时）


推荐使用静态方法获取对象：

package Java16.Demo;

public class demo2 {
    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 i2 = new Integer("abc");//NumberFormatException
//        System.out.println(i2);*/

        //静态方法获取对象
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);
        Integer i2 = Integer.valueOf("100");
        System.out.println(i2);
    }
}

5.3 int和String的相互转换

package Java16.Demo;

public class demo3 {
    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);
        
    }
}

• Int 转换为String
  public static String valueOf(int i)：返回int参数的字符串表示形式。该方法是String类中的方法

 String s2 = String.valueOf(number);

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

int y = Integer.parseInt(s);

案例

1、字符串中数据排序
字符串“91 27 46 38 50”

public class demo4 {
    public static void main(String[] args){
        String s = "91 27 46 38 50";
        //split方法将字符串以regex参数进行分割形成String数组，此处regex为空格
        String[] sArray = s.split(" ");
/*        for(int i=0;i<sArray.length;i++){
            System.out.println(sArray[i]);
        }*/
        //定义一个int数组，存储String数组中的元素
        int[] arr = new int[sArray.length];
        for(int i=0;i<sArray.length;i++){
            //将String型转化为int型------Integer.parseInt(s)
            arr[i] = Integer.parseInt(sArray[i]);
        }
/*        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }*/
        //对arr数组进行排序，冒泡排序法
//        for(int x=0;x<arr.length;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;
//                }
//            }
//        }
        //可以直接调用方法Arrays类中的sort方法,需要调用包
        Arrays.sort(arr);

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

        System.out.println("result:"+result);
    }
}

5.4 自动装箱和拆箱

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

package Java16.Demo;

public class demo5 {
    public static void main(String[] args) {
        //装箱,基本数据类型----------包装类类型
        //i和ii就是包装类类型
        Integer i = Integer.valueOf(100);
        //自动装箱
        Integer ii = 100;//Integer.valueOf(100);
        
        //拆箱，包装类类型-----------基本数据类型
        //ii.intValue()就是拆箱；
        //ii += 200;
        ii = ii.intValue() + 200;
        //自动拆箱+自动装箱
        ii += 200;
        System.out.println(ii);
    }
}

6.日期类

6.1 Data类概述和构造方法

package Java16.Data;

import java.util.Date;

public class datademo {
    public static void main(String[] args) {
        //public Date();分配一个 Date对象并对其进行初始化，以便它表示分配的时间，测量到最近的毫秒。
        Date d1 = new Date();
        System.out.println(d1);

        //public Date(long date);分配一个 Date对象，并将其初始化为表示从标准基准时间（称为“时代”）即1970年1月1日00:00:00 GMT起的指定毫秒数。
        long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);
    }
}

6.2 Data类的常用方法

package Java16.Data;

import java.util.Date;

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

        //public long getTime();返回自1970年1月1日以来，由 Date对象表示的00:00:00 GMT的毫秒数
//        System.out.println(d.getTime()*1.0/1000/60/60/24/365+"year");

        //public void setTime(long time);设置此 Date对象以表示1970年1月1日00:00:00 GMT后的 time毫秒的时间点。
//        long time = 1000*60*60;
        //System.currentTimeMillis();当前时间与1970年的毫秒数；
        //currentTimeMillis()----在1970年1月1日UTC之间的当前时间和午夜之间的差异，以毫秒为单位。
        long time = System.currentTimeMillis();
        d.setTime(time);
        System.out.println(d);
    }
}

6.3 SimpleDateFormat类概述

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

package Java16.Data;

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

public class demo3 {
    public static void main(String[] args) throws ParseException {
        //SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
        //SimpleDateFormat允许您从选择日期时间格式化的任何用户定义的模式开始

        //格式话：从Date-----String
        //public final String format(Date date);将日期格式化成日期/时间字符串
        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
        //public Date parse(String text);从给定字符串的开始解析文本以生成日期
        String ss = "2021-3-21 11:11:11";
        //两者格式要一致"2021-3-21 11:11:11"------"yyyy-MM-dd HH:mm:ss"
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}

6.4 日期工具类案例

package Java16.Data;

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

public class demo4 {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d = new Date();

        String s1 = DataUtils.dateToString(d,"yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

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

        String s = "2048-08-09 12:23:43";
        Date dd = DataUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);

    }
}

package Java16.Data;

//工具类
//构造方法私有
//成员方法静态

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

public class DataUtils {
    private DataUtils(){}

/*    把日期转化为指定格式的字符串
    返回值类型String
    参数：Date data,String format    */
    public static String dateToString(Date data,String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(data);
        return s;
    }

    /*把字符串解析为指定格式的日期
    * 返回值类型为Date
    * 参数String s,String format  */
    public static Date stringToDate(String s,String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(s);
        return d;

    }

}

6.6 Calendar 类概述

Calendar类是一个抽象类，可以为在某一特定时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法。
Calendar提供了一种类方法getInstance ，用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：
Calendar rightNow = Calendar.getInstance();

package Java16.Data;

import java.util.Calendar;

public class demo5 {
    public static void main(String[] args){
        //获取Calendar类对象
        Calendar c = Calendar.getInstance();//多态的形式
//        System.out.println(c);
//        public int get(int field)返回给定日历字段的值
        //Calendar.YEAR获取年的字段
        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+"日");
    }
}

package Java16.Data;

import java.util.Calendar;

public class demo6 {
    public static void main(String[] args) {
        //获取日历对象
        Calendar c = Calendar.getInstance();

        //public int get(int field);返回给定日历字段的值、
        //public abstract void add(int field,int amount);抽象方法
        // 根据日历的规则，将指定的时间量添加或减去给定的日历字段
        //三年前的今天
/*        c.add(Calendar.YEAR,-3);
        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+"日");*/

        //十年后的5天前
/*        c.add(Calendar.YEAR,10);
        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,int hourOfDay,int minute,int second)
        //设置当前日历的年月日
        c.set(2020,11,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+"日");

    }
}

6.8 案例二月天

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

package Java16.Data;

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

public class dateOfFebruary {
    //获取任意一年的二月有多少天
    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);

        //三月一日往前一天就是2月的最后一天
        c.add(Calendar.DATE,-1);

        //获取这一天输出
        int date = c.get(Calendar.DATE);
        System.out.println("这一年的二月有"+date+"天");
    }
}