常用的API Math类，System类，Object类，Arrays类，基本类型的包装，int和String的转换，Date类，SimpleDateFormat类-CSDN博客

本文链接：https://blog.csdn.net/weixin_58427102/article/details/124441622

常用API

Math类：

java.lang包下包含执行基本数字运算的方法

参数名相同，参数不同，即为方法重载。

//public static int abd(int a);返回参数的绝对值
System.out.println(Math.abs(1));  //1
System.out.println(Math.abc(-1));  //1
//public static double ceil (double a);返回大于或等于参数的最小double值，等于一个整数
System.out.println(Math.ceil(12.34));  //13.0
System.out.println(Math.ceil(12.56));  //13.0
//public static double floor (double a);返回小于或等于参数的最小double值，等于一个整数
System.out.println(Math.floor(12.34)); //12.0
System.out.println(Math.floor(12.56));  //12.0
//public static int round(float a );按照四舍五入但会最接近参数的int
System.out.println(Math.round(12.34F)); //12
System.out.println(Math.round(12.56F)); //13
//public static int max(int a,int b);返回两个int值中的较大值
System.out.println(Math.max(66,88));//88
//public static int min (int a,int b);返回两个int值中的较小值
System.out.println(Math.min(66,88));//66
//public static double pow(double a,double b);返回a的b次幂的值
System.out.println(Math.pow(2.0,3.0));//8.0
//public static double rando();返回值为double的正值[0.0,1.0)
System.out.println(Math.random());//返回值为double的正值[0.0,1.0)之间的小数
System.out.println(Math.random()*100);//返回值为double的正值[0.0,1.0)之间的小数扩大100倍
System.out.println(int(Math.random()*100)+1);//1-100,整数

System类：

java.lang.System包下

包含几个有用的类字段和方法，他不能被实例化。（即不能创建对象）

//public static void exit(int status);终止当前运行的java虚拟机。非零表示异常终止
	System.out.println("开始");
	System.exit(0);//这句话在 “结束”就不会输出
	System.out.println("结束");
//public static long currentTimeMillis();返回当前时间(以毫秒为单位)
	System.out.println(System.currentTimeMillis());//当前时间和1970.1.1之间的毫秒值
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)+"毫秒")；

Object类：

java.lang包下是类层次结构的根，每个类都有Object作为超类。所有对象（包括数组）都实现了这个类的方法（所有的类都直接或间接地继承object类）

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

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

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

默认继承object

继承object中to String方法

Alt+Ins ->to String 自动生成to String 方法

Arrays类：

java.util包下需要导包

该类包含用于操作数组的各种方法（如排序和搜索）。该类还包含一个静态工厂，可以将数组视为列表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Uw1TBmRK-1651012137307)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20220414152737410.png)]

import java.util.Arrays;
//定义数组
int[] arr={24,69,80,57,13};
System.out.println("排序前"+Arrays.toString(arr));//[24,69,80,57,13]
Arrays.sort(arr);
System.out.println("排序后"+Arrays.toString(arr));//[13,24,57,69,80]

工具类的设计思想：
    构造方法用private修饰//为了防止外界创建对象
    成员用public static 修饰//为了让使用类名来访问该成员方法

拓展

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

冒泡排序:一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，一次对所有的数据进行操作，直至所有数据按要求完成排序
	如果有n个数据进行排序，总共需要比较n-1次
	每一次比较完毕，下一次的比较就会少一个数据参与
for(int x=0;x<arr.length-1;i++){
	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，元素3，....]
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();
	renturn s;
}

StringBuilder

一、创建Stringbuilder对象
StringBuilder strB = new StringBuilder();

1、append(String str)/append(Char c)：字符串连接
System.out.println(“StringBuilder:”+strB.append(“ch”).append(“111”).append(‘c’));
//return “StringBuilder:ch111c”

2、toString()：返回一个与构建起或缓冲器内容相同的字符串
System.out.println(“String:”+strB.toString());
//return “String:ch111c”

3、appendcodePoint(int cp)：追加一个代码点，并将其转换为一个或两个代码单元并返回this
System.out.println(“StringBuilder.appendCodePoint:”+strB.appendCodePoint(2));
//return “StringBuilder.appendCodePoint:ch111c”

4、setCharAt(int i, char c)：将第 i 个代码单元设置为 c（可以理解为替换）
strB.setCharAt(2, ‘d’);
System.out.println(“StringBuilder.setCharAt:” + strB);
//return “StringBuilder.setCharAt:chd11c”

5、insert(int offset, String str)/insert(int offset, Char c)：在指定位置之前插入字符(串)
System.out.println(“StringBuilder.insertString:”+ strB.insert(2, “LS”));
//return “StringBuilder.insertString:chLSd11c”
System.out.println(“StringBuilder.insertChar:”+ strB.insert(2, ‘L’));
//return “StringBuilder.insertChar:chLLSd11c”

6、delete(int startIndex,int endIndex)：删除起始位置（含）到结尾位置（不含）之间的字符串
System.out.println(“StringBuilder.delete:”+ strB.delete(2, 4));
//return “StringBuilder.delete:chSd11c”

基本类型包装类：

int范围：-2的31次方到2的31次方-1                      -21474

Integer: 	public static final int MIN_VALUE(int可以为-2的31次方)                   final修饰说明：常量       static静态访问说明：可以通过类名直接访问

    		public static final int MAX_VALUE(int可以为2的31次方-1)
    System.out.println(Integer.MIN_VALUE);    //-214743648
	System.out.println(Integer.MAX_VALUE);    //214743647

Internet 在java.lang包下不用导包‘

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

常用操作之一：用于基本数据类型与字符串之间的转换——此外该类还提供了几种将int转换为String和String转换为int，以及其他常量和方法在处理int时非常有用

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

//构造方法：public Integer(int value): 根据int值创建Integer对象(过时)
			Integer i1= new Integer(100);
        	System.out.println(i1);//100
//		public Integer(String s ): 根据String值创建Integer对象(过时)
			Integer i1= new Integer("100");
			System.out.println(i1);//100
			
			Integer i1= new Integer("abc");
			System.out.println(i1);//报错：NumberFormatException说明不是数字字符串不能被解析
//静态方法获取对象：      
//		public static Integer valueOf(int i):返回指定的int值的Integer实例
		Integer i1 = Integer.valueOf(100);
		System.out.println(i1);//100
//		public static Integer valueOf(String s):返回一个保存指定值的 Integer对象String
		Integer i1= Integer.valueOf("100");
		System.out.println(i1);//100
		Integer i1= Integer.valueOf("abc");
		System.out.println(i1); //NumberFormatException

int和String的相互转换：

/*int ——> String*/

int number = 100;
//方式一
String s1 = "" + number//字符串参与加法运算是字符串连接，则变成字符串
System.out.println(s1);
//方式二
	//public static String valueOf(int i)
String s2 = String.valueOf(number);
System.out.println(s2);

-------------------------------------------------------------
/* String ——> Integer ——>int*/

//方式一
Integer i = Intger.valueOf(s);//相当于把一个字符串变成一个Integer类型
//public int intValue()
int x = i.intValue();//通过对象i调用
System.out.println(x);//100  为int型
//方式二
	//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”

思路：

定义一个字符串
把字符串中的数字数据存储到一个int类型的数组中
- 得到字符串中每一个数字数据：
  
  public String[] split(String regex)
- 定义一个int数组，把String[]数组中的每一个元素存储到int数组中
  
  public static int parselnt(String s )
对int数组进行排序
把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
输出结果

import java.util.Arrays;
public class IntegerTest {
    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数组，把String[]数组中的每一个元素存储到int数组中
        int[] arr = new int[strArray.length];
        for (int i= 0;i<arr.length;i++){
            arr[i]= Integer.parseInt(strArray[i]);//把一个字符串数据转成int数据
        }
//        for (int i= 0;i<arr.length;i++){
//            System.out.println(arr[i]);
//        }   得到的是int型的每个暑假
        //对int数组进行排序
        Arrays.sort(arr);
        //把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
        StringBuilder sb = new StringBuilder();
        for (int i = 0 ;i<arr.length;i++){
            if (i==arr.length){
                sb.append(arr[i]);//对字符串进行拼接  append！！！！！
            }else{
                sb.append(arr[i]+" ");
            }
        }
        String result = sb.toString();//StringBuilder 转换成String类型
        System.out.println("resule："+result);
    }
}

自动装箱和拆箱

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

Integer i=Integer.valueOf(100);//100是基本类型通过Integer调用ValueOf方法转换成包装类类型
//即为装箱
Integer ii = 100;  //自动装箱  底层做了Integer i=Integer.valueOf(100)动作

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

//ii+=200;
ii = ii.intValue()+200;//ii是包装类类型，通过intValue方法转换为基本数据类型
//即为拆箱     此时ii=300
ii+=200;  //自动拆箱 然后 自动装箱，底层做了自动拆箱，装箱的动作

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

Integer iii = null；//在开发中使用包装类类型之前先判断是不是null
if(iii!=null){
	iii += 300; //NullPointerEception  空指针
}

日期类：

Date类

java.sql包下 java.until.Date包下（使用）

Date类代表了一个特定的时间，以毫秒的精度(标准的基准时间为1970年1月1日)

public Date() :分配一个Date对象，并初始化，以便代表她被分配的时间，精确到毫秒
```
//until包下的
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);
```

public long getTime():获取的是日期对象从1970.01.01 00:00:00到现在的毫秒值

//创建日期对象
        Date d = new Date();
        //public long getTime():获取的是日期对象从1970.01.01 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;
d.setTime(time);
System.out.println(d);
//System.currentTimeMillis();系统当前时间

SimpleDateFormat类

java.text包下

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

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

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

SimpleDateFormat格式化和解析

格式化（从Date到String）

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

默认格式

//格式化（从Date到String）
Date d = new Date();//日期
SimpleDateFormat sdf = new SimpleDateFormat();//通过SimpleDateFormat的sdf对象
String s = sdf.format(d);//调用format方法将日期型d格式化为字符串型s
System.out.println(s);

日期格式

Date d = new Date();//日期
//SimpleDateFormat sdf = new SimpleDateFormat();//通过SimpleDateFormat的sdf对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
//20220417192830
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
//2022年04月17日19:28:46
String s = sdf.format(d);//调用format方法将日期型d格式化为字符串型s
System.out.println(s);

解析（从String到Date）

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

 //解析（从String到Date）
        String ss="2022-02-22 22:22:22";//字符串要与下面的模式格式一致
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf1.parse(ss);
        System.out.println(dd);//.ParseException解析异常

日期工具类

/*
工具类：构造方法私有|成员方法静态
 */
    private DateTest(){}
    /*
    把日期转为指定格式的字符串
    返回值类型：String
    参数：Date date，String format
     */
    //成员方法用静态修饰：将来通过类名调用，返回值为String
    public static String dateToString(Date date,String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);//按照指定格式创建SimpleDateFormat
        String s = sdf.format(date);//用sdf对象调用format方法把日期转换为了指定格式的字符串传给s
        return s;//返回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;

/*测试类*/
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= DateTest.dateToString(d,"yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);


        String s= "2027-02-14 12:12:12";
        Date s2 = DateTest.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(s2);


    }
}

Calendar类：日历类

java.util包下

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

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

Calendar rightNow = Calendar.getInstance();

import java.util.Calendar;

//Calendar为某一时刻和一组日历字段之间的转换提供了一些方法。并为操作日历字段提供了一些方法
//Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：
public class CalendarDemo {
        public static void main(String[] args){
                //获取日历类的对象
                Calendar ca = Calendar.getInstance();//多态形式得到对象：一个返回值类型，是一个抽象类，那么他需要的是该类的子类对象
//                System.out.println(ca);
                //public int get (int field)   通过给定的日历字段得出日历字段的值
                int year = ca.get(Calendar.YEAR);
                int month = ca.get(Calendar.MONTH) + 1;
                int date = ca.get(Calendar.DATE);
                System.out.println(year+"年"+month+"月"+date+"日");
        }
}

public int get(ubt fueld):返回给定日历字段得值
public abstract void add(int field,int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
public finalvoidset(int year, int month,int date):设置当前日历的年月日

//                public abstract void add(int field,int amount);根据日历的规则，将指定的时间量添加或减去给定的日历字段
          //需求二，三年前的今天
                ca.add(Calendar.YEAR,-3);
                int year1 = ca.get(Calendar.YEAR);
                int month1 = ca.get(Calendar.MONTH) + 1;
                int date1 = ca.get(Calendar.DATE);
                System.out.println(year1+"年"+month1+"月"+date1+"日");
          //需求三，十年后的五天前
                ca.add(Calendar.YEAR,10);
                ca.add(Calendar.DATE,-5);
                int year2 = ca.get(Calendar.YEAR);
                int month2 = ca.get(Calendar.MONTH) + 1;
                int date2 = ca.get(Calendar.DATE);
                System.out.println(year2+"年"+month2+"月"+date2+"日");

//public final void set(int year,int month,int date);设置当前日历的年月日
ca.set(2022,01,22);
int year = ca.get(Calendar.YEAR);
int month = ca.get(Calendar.MONTH) + 1;
int date = ca.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+date+"日");