3-权限修饰符、代码块、常用API和包装类_java基础例子权限修饰符、常用包装类、代码块,部分常见类-CSDN博客

本文链接：https://blog.csdn.net/weixin_44161705/article/details/120332353

文章目录

目录
一、权限修饰符
二、代码块
三、常用API
四、包装类

一、权限修饰符

概述：在java中提供了4个权限修饰符,使用不同的权限修饰符修饰,被修饰的内容就具有不同的访问权限。

分类:
1、public : 公共的
2、protected: 受保护的 (空的):
3、默认
4、private: 私有的

			同一个类 同一个包 不同包的父子类 不同包的无关类 
public 			√ 		√ 			√ 			√ 
protected 		√ 		√			√ 			× 
默认 			√ 		√ 			× 			× 
private 		√ 		× 			× 			×

开发中的使用：
	定义类一般使用public
	定义成员方法一般使用public
	定义成员变量一般使用private
	定义构造方法一般使用public

二、代码块

1、构造代码块

1、格式: {}
2、位置: 类中,方法外
3、执行: 每次调用构造方法时,都会执行一次,优先于构造方法执行
4、使用场景: 统计创建了多少个对象
5、案例:
	public class Person { 
		// 构造代码块 
		{ 
			System.out.println("Person类的构造代码块"); 
		}
		public Person(){ 
			System.out.println("Person类的空参构造方法"); 
		} 
	}

2、静态代码块


 1. 格式: static {} 
 2. 位置: 类中,方法外 
 3. 执行: 随着类的加载而执行,并且只执行一次 
 4. 使用场景:
    加载驱动,或者放只需要执行一次的代码 
 案例:
 	public class Person { 
	 	static { 
	 		System.out.println("Person类的静态代码块"); 
	 	} 
 	}

3、局部代码块


 1. 格式: {} 位置: 方法中 
 2. 执行: 调用方法时,执行到了局部代码块的位置才执行 
 3. 使用场景: 节省内存空间,意义不大 
 4. 案例:
 	public class Test { 
	 	public static void main(String[] args) { 
		 	int num1 = 10; 
		 	System.out.println(num1); 
		 	System.out.println("开始"); 
		 	// 局部代码块 
		 	{ 
			 	int num2 = 20; 
			 	System.out.println("局部代码块,num2:" + num2); 
		 	}
		 	// System.out.println(num2);// 编译报错,因为超过了num2的作用域 
		 	System.out.println("结束"); 
	 	} 
 }

4、注意：


 1. 静态代码块优先于构造代码块执行 
 2. 构造代码块优先于构造方法执行

public class Person { 
	// 静态代码块 
	static { 
		System.out.println("Person类的静态代码块");
	}
	// 构造代码块 
	{ 
		System.out.println("Person类的构造代码块"); 
	}
	public Person(){ 
		System.out.println("Person类的空参构造方法"); 
	} 
}

三、常用API

1、Object类

3.1 Object类的概述

1、java.lang.Object类是java语言的根类,所有java类的父类 
2、在java中所有的类都是直接或者间接继承Object类 
	2.1、public class Person /*extends Object*/ {} 默认继承Object类 
	2.2、public class Student extends Person{} 间接继承Object类
3、Object类中总共有11个成员方法,也就意味着java中所有的类都拥有这11个方法(java的类都会继承
Object类)
4、这里介绍2个方法
	4.1、String toString() 返回该对象的字符串表示。 
	4.2、public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

3.2、toString方法

String toString() 返回该对象的字符串表示。
使用场景:
如果打印对象的时候不希望打印的是地址值,那么就重写toString方法

案例：

public class Person {
    private String name;

    public Person(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        /**
         * String toString() 返回该对象的字符串表示。
         *  1.因为java中所有的类都会继承Object类,所以所有的类都拥有toString方法
         *  2.Object类中的toString方法返回的字符串格式默认为: 类的全名+@+地址值
         *  3.如果不想使用toString方法的默认返回值,那么就得重写toString方法
         *  4.直接打印对象名,其实打印的是该对象调用toString方法返回的字符串内容
         */
        Person p = new Person("hsm");

        System.out.println(p.toString());   //Person{name='hsm'}
        System.out.println(p);              //Person{name='hsm'}

        System.out.println(p);              //com.hsm.demo2_API.demo1_object.Person@1540e19d
        System.out.println(p.toString());   //com.hsm.demo2_API.demo1_object.Person@1540e19d


    }
}

3.3、equals方法

public boolean equals(Object obj)：判断2个对象是否相等。
使用:
Object类的equals方法默认比较的是地址值,如果希望比较的不是地址值,而是所有的属性值,
那么就按alt+insert,选择equals() and hashCode()重写就行

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {   //形参多态
        // 如果2个对象的地址值相对,直接返回true结束方法
        if (this == o) return true;

        // 如果参数为null或者2个对象的类不一致,就直接返回false结束方法
        if (o == null || getClass() != o.getClass()) return false;

        // 执行到这里,说明要比较的2个对象地址值不同,类型相同
        // 比较2个对象的所有属性值是否相同
        Person person = (Person) o;

        // 比较所有属性
        return age == person.age &&
                Objects.equals(name, person.name);
    }

}

public class Test {
    public static void main(String[] args) {
        /**
         * public boolean equals(Object obj)：判断2个对象是否相等。
         *  1.因为java中所有的类都会继承Object类,所以所有的类都拥有equals方法
         *  2.Object类中的equals方法默认比较的是2个对象的地址值
         *  3.在开发中,如果2个对象的所有属性值相同,往往认为这2个对象是相等的
         *  4.如果不希望使用Object类的equals方法比较2个对象,那么就得重写equals方法, 指定比较规则
         */

        Person p1 = new Person("hsm",18);
        Person p2 = new Person("hsm",18);
        Person p3 = new Person("张三", 18);

        System.out.println(p1.equals(p2));  //true
        System.out.println(p1.equals(p3));  //false

        //Object类中的equals方法默认比较的是2个对象的地址值
        System.out.println(p1.equals(p2));  //false
        System.out.println(p1.equals(p3));  //false


    }
}

3.4 Objects类

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashCode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下： public static boolean equals(Object a, Object b) :判断两个对象是否相等。

public class Test {
    public static void main(String[] args) {
        String a = null;
        String b = "张三";
        // System.out.println(a.equals(b));// 调用的是String类的equals方法,报空指针 异常
        // System.out.println(Objects.equals(a, b));// false
        // System.out.println(Objects.equals("张三", b));// true
        // System.out.println(Objects.equals(new String("张三"), b));// true

        /*
        源码如下：
        public static boolean equals (Object a, Object b){
            return (a == b) || (a != null && a.equals(b));
        }
        1.如果2个对象的地址值相同,后面就不执行了(逻辑或短路),而是直接返回true,结束方法
        2.如果2个对象的地址值不同:
            2.1 如果a对象的地址值为空,逻辑与后面就不执行了(逻辑与短路),而是直接返回 false,结束方法
            2.2 如果a对象的地址值不为空,执行a.equals(b),就是比较2个对象是否相等
        */
    }
}

2、Date类

Date类的概述

java.util.Date类表示日期,内部精确到毫秒.表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。
0时区标准基准时间:1970年1月1日00:00:00
东八区标准基准时间: 1970年1月1日08:00:00

Date类中的构造方法

public Date Date();当前系统时间对应的日期对象
public Date Date(long mills);距离标准基准时间指定偏移毫秒数对应的日期对

象

Date类中的常用方法

public long getTime();获取当前日期对象距离标准基准时间的毫秒值
public boolean after(Date when) 判断此日期是否在指定日期之后
public boolean before(Date when) 判断此日期是否在指定日期之前

案例：

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        /**
         *
         * 概述：
             * >  1. java.util.Date类表示日期,内部精确到毫秒.表示自从标准基准时间（称为“历元（epoch）”，
         *          即1970年1月1日00:00:00 GMT）以来的指定毫秒数。
             * >  2. 0时区标准基准时间:1970年1月1日00:00:00
             * > 3. 东八区标准基准时间: 1970年1月1日08:00:00
         *
         * 构造方法:
         *       1. public Date Date();当前系统时间对应的日期对象
         *       2. public Date Date(long mills);距离标准基准时间 指定偏移毫秒数 对应的日期对象
         * 常见功能:
                1. public long getTime();获取当前日期对象距离标准基准时间的毫秒值
                2. public boolean after(Date when) 判断此日期是否在指定日期之后
                3. public boolean before(Date when) 判断此日期是否在指定日期之前
         * 需求：Date类的构造方法与常用方法
         */

        //当前系统时间对应的日期对象
        Date date = new Date();
        System.out.println(date);   //Thu Sep 16 18:05:56 CST 2021

        //距离标准基准时间 指定偏移毫秒数 对应的日期对象
        Date date1 = new Date(1000);
        System.out.println(date1);  //东八区标准基准时间: 1970年1月1日08:00:00------>Thu Jan 01 08:00:01 CST 1970

        //获取当前日期对象距离标准基准时间的毫秒值
        System.out.println(date.getTime()); //1631787060946

        //判断此日期是否在指定日期之后
        System.out.println(date.after(date1));  //true
        //判断此日期是否在指定日期之前
        System.out.println(date.before(date1)); // false


    }
}

3、DateFormat类

3.1、DateFormat类的概述

概述: java.text.DateFormat 该类可以使得在Date对象与String对象之间进行来回转换.
格式化:按照指定的格式，把Date对象转换为String对象。
解析: 按照指定的格式，把String对象转换为Date对象。
注意:DateFormat是一个抽象类,无法创建对象,应该使用其子类来实现Date和String之间的转换

3.2、SimpleDateFormat类

概述: java.text.SimpleDateFormat 该类继承DateFormat类,所以该类也可以使得在Date对象与String对象之间进行来回转换.
构造方法:
public SimpleDateFormat(String pattern)：传入日期指定格式,创建 SimpleDateFormat对象.
参数: 指定的日期格式
日期格式的组成元素:
y: 年
M: 月
d: 日
H: 时
m: 分钟
s: 秒 …
常见的日期格式:
yyyy-MM-dd HH:mm:ss
yyyy年MM月dd日 HH:mm:ss
…

3.3、DateFormat类中的常用方法

public String format(Date date)：将Date对象格式化为字符串。
public Date parse(String source)：将字符串解析为Date对象。

3. 注意:
日期格式化对象中指定的日期要和解析的字符串日期格式一致,否则会报解析异常 ParseException

日期类练习：
	import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Test {
    /**
     * 需求
     *  键盘输入一个字符串类型的时间，打印你来到世界多少天?
     */
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串的出生日期,格式为yyyy-MM-dd:"); //1999-06-05
        String birthday = sc.next();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthDay = sdf.parse(birthday);    //Sat Jun 05 00:00:00 CST 1999

        Date date = new Date();
        long dateTime = date.getTime(); //1631788244858
        long birthTime = birthDay.getTime();    //928512000000

        System.out.println("你来到世界"+ (dateTime - birthTime) /1000/60/60/24 +"天");    //你来到世界8139天
    }
}

4、Calendar类

Calendar类的概述 java.util.Calendar 类表示一个“日历类”，可以进行日期运算。
特点:Calendar类是一个抽象类,不能创建对象,所以只能使用其子类
子类: GregorianCalendar
获取日历对象:
方式一: 通过 GregorianCalendar 子类的构造方法不建议
方式二:通过Calendar类的静态方法getInstance()
Calendar类的注意事项
日历对象中的月份是0-11, 0表示1月,依次类推, 11表示12月
日历对象中的星期是1-7, 1表示星期天,依次类推,7表示星期六

public static Calendar getInstance();

public class Test {
    public static void main(String[] args) {
        /**
         * >  1. Calendar类的概述 java.util.Calendar 类表示一个“日历类”，可以进行日期运算。
         * >  2. 特点:Calendar类是一个抽象类,不能创建对象,所以只能使用其子类
         * >  3. 子类: GregorianCalendar
         * >  4. 获取日历对象:
         * >     方式一: 通过 GregorianCalendar 子类的构造方法 不建议
         * >     方式二:通过Calendar类的静态方法getInstance()
         */
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);
    }
}

常用练习：
	import java.util.Calendar;

public class CalendarTest {
    public static void main(String[] args) {
        /**
         * 常用方法
         *      public int get(int field)  获取某个字段的值。
         *      public void set(int field,int value)  设置某个字段的值
         *      public void add(int field,int amount)  为某个字段增加/减少指定的值
         *              field参数表示获取哪个字段的值，可以使用Calender中定义的常量来表示。
         *      Calendar.YEAR : 年 | Calendar.MONTH ：月 | Calendar.DAY_OF_MONTH：日
         *      Calendar.HOUR : 时 | Calendar.MINUTE：分 | Calendar.SECOND：秒
         *      Calendar.DAY_OF_WEEK：星期
         * 需求：按照下述需求，演示Calendar类的构造方法与常用方法
         *      1.获取当前日期对象，并展示当前日期详细时间。
         *      2.设置当前日期对象为一个月以后的第一天，查看当时的详细时间。
         *      3.将当前日期对象的月份增加100000分钟，查看当时的详细时间。
         */
        //1.获取当前日期对象，并展示当前日期详细时间。
        Calendar cal = Calendar.getInstance();
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH);
        int day = cal.get(Calendar.DAY_OF_MONTH);
        int hour = cal.get(Calendar.HOUR);
        int minute = cal.get(Calendar.MINUTE);
        int second = cal.get(Calendar.SECOND);
        int millis = cal.get(Calendar.MILLISECOND);
        System.out.println(year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second + ":" + millis);     //2021-8-16 6:59:7:649

        //2.设置当前日期对象为一个月以后的第一天，查看当时的详细时间。
        Calendar cal1 = Calendar.getInstance();
        cal1.set(Calendar.MONTH,10);
        cal1.set(Calendar.DAY_OF_MONTH,1);

        int year1 = cal1.get(Calendar.YEAR);
        int month1 = cal1.get(Calendar.MONTH);
        int day1 = cal1.get(Calendar.DAY_OF_MONTH);
        int hour1 = cal1.get(Calendar.HOUR);
        int minute1 = cal1.get(Calendar.MINUTE);
        int second1 = cal1.get(Calendar.SECOND);
        int millis1 = cal1.get(Calendar.MILLISECOND);
        System.out.println(year1 + "-" + month1 + "-" + day1 + " " + hour1 + ":" + minute1 + ":" + second1 + ":" + millis1);

        //3.将当前日期对象的月份增加100000分钟，查看当时的详细时间。
        Calendar cal2 = Calendar.getInstance();
        cal2.add(Calendar.MONTH,(100000/60/24/30));
        int year2 = cal2.get(Calendar.YEAR);
        int month2 = cal2.get(Calendar.MONTH);
        int day2 = cal2.get(Calendar.DAY_OF_MONTH);
        int hour2 = cal2.get(Calendar.HOUR);
        int minute2 = cal2.get(Calendar.MINUTE);
        int second2 = cal2.get(Calendar.SECOND);
        int millis2 = cal2.get(Calendar.MILLISECOND);
        System.out.println(year2 + "-" + month2 + "-" + day2 + " " + hour2 + ":" + minute2 + ":" + second2 + ":" + millis2);
    }
}

5、Math类

概述:
java.lang.Math(类): Math包含执行基本数字运算的方法的工具类。
构造方法:
Math类构造方法被私有修饰，不能创建对象。通过类名调用内部静态方法即可。
常用方法:
public static int abs(int a) 获取参数a的绝对值
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static double pow(double a, double b) 获取a的b次幂
public static long round(double a) 四舍五入取整
public static int max(int a, int b) 返回两个 int 值中较大的一个
public static int min(int a, int b) 返回两个 int 值中较小的一个

需求：演示Math类中的常用方法：
	public class Test {
    public static void main(String[] args) {
        /**
         * 概述:
         *      java.lang.Math(类): Math包含执行基本数字运算的方法的工具类。
         * 构造方法:
         *      Math类构造方法被私有修饰，不能创建对象。通过类名调用内部静态方法即可。
         * 常用方法:
             * public static int abs(int a)                   获取参数a的绝对值
             * public static double ceil(double a)            向上取整
             * public static double floor(double a)           向下取整
             * public static double pow(double a, double b)   获取a的b次幂
             * public static long round(double a)             四舍五入取整
             * public static int max(int a, int b)            返回两个 int 值中较大的一个
             * public static int min(int a, int b)            返回两个 int 值中较小的一个
         * 需求：演示Math类中的常用方法
         */
        //获取参数a的绝对值
        System.out.println(Math.abs(-2));       //2
        //向上取整
        System.out.println(Math.ceil(3.14));    //4.0
        //向下取整
        System.out.println(Math.floor(3.14));   //3.0
        //获取a的b次幂
        System.out.println(Math.pow(2, 5));     //32.0
        //四舍五入取整
        System.out.println(Math.round(3.14));   //3
        System.out.println(Math.round(3.54));   //4
        System.out.println(Math.round(-3.14));	// -3 
        System.out.println(Math.round(-3.54));	// -4
        //返回两个 int 值中较大的一个
        System.out.println(Math.max(10, 20));   //20
        //返回两个 int 值中较小的一个
        System.out.println(Math.min(10, 20));   //10
    }
}

6、System类

6.1、System类的概述

概述:
java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作；
特点:
System类构造方法被私有修饰，不能创建对象；
直接通过System类名调用该类的静态方法；

6.2、System类的常用方法

public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止;
public static long currentTimeMillis() 返回当前时间距离标准基准时间的毫秒值;

案例：
import java.util.Date;

public class Test {
    public static void main(String[] args) {
        /**
         * 需求
         *   在控制台输出1-10000，计算这段代码执行了多少毫秒
         */
        long start = new Date().getTime();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = new Date().getTime();
        System.out.println("这段代码执行了" + (end - start) + "毫秒");
    }
}

7、BigInteger类

7.1、BigInteger类的概述

概述: java.math.BigInteger 表示一个超大的整数

7.2、BigInteger类的构造方法

 1. public BigInteger BigInteger(String value); 根据字符串内容创建一个超大的整数对象 
 2. 注意:
    字符串参数一定要传整数的字符串

7.3、BigInteger类成员方法

public BigInteger add(BigInteger value) 加法运算
public BigInteger subtract(BigInteger value) 减法运算
public BigInteger multiply(BigInteger value) 乘法运算
public BigInteger divide(BigInteger value) 除法运算

案例：
import java.math.BigInteger;

public class Test {
    public static void main(String[] args) {
        /**
         * BigInteger类的构造方法
         *      public BigInteger BigInteger(String value); 根据字符串内容创建一个超大的整数对象
         * 注意: 字符串参数一定要传整数的字符串
         * BigInteger类成员方法
         *      public BigInteger add(BigInteger value) 加法运算
         *      public BigInteger subtract(BigInteger value) 减法运算
         *      public BigInteger multiply(BigInteger value) 乘法运算
         *      public BigInteger divide(BigInteger value) 除法运算
         */
        //int num = 2212345678;// 编译报错,因为等于号右边的数据超过了int类型 能表示的数据范围
        // 解决: long numL = 2212345678L;// 正确
        // long num = 22123456782212345678L;// 编译报错,因为等于号右边的数据 超过了long类型能表示的数据范围
        BigInteger big = new BigInteger("2212345678221234567822123456782212345678");
        BigInteger big1 = new BigInteger("1000000000000000000000000000000000000000");

        //加法运算
        System.out.println(big.add(big1));      //3212345678221234567822123456782212345678
        //减法运算
        System.out.println(big.subtract(big1)); //1212345678221234567822123456782212345678
        //乘法运算
        System.out.println(big.multiply(big1)); //2212345678221234567822123456782212345678000000000000000000000000000000000000000
        //除法运算
        System.out.println(big.divide(big1));   //2

    }
}

8、BigDecimal类

8.1、BigDecimal类的概述

概述:
java.math.BigDecimal类,表示一个超大的小数,并且可以解决小数运算的精度问题小数运算精度问题演示:

8.2、BigDecimal类构造方法

BigDecimal(double val) 将double类型的数据封装为BigDecimal对象,
不推荐使用,因为使用这个依然还是有精度问题

BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal

8.3、BigDecimal类常用方法

public BigDecimal add(BigDecimal value) 加法运算
public BigDecimal subtract(BigDecimal value) 减法运算
public BigDecimal multiply(BigDecimal value) 乘法运算
public BigDecimal divide(BigDecimal value) 除法运算

8.4、注意:如果使用上面的除法运算的方法,遇到除不尽的就会报数学运算异常,得使用下面重载的

方法 public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) 除法运算
参数1: 除数
参数2: 精确的位数
参数3: 取舍的模式 RoundingMode.HALF_UP: 四舍五入

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Test {
    public static void main(String[] args) {
        //出现精度丢失
//        System.out.println(0.09 + 0.01);    //理想值：0.1       ----------->0.09999999999999999
//        System.out.println(1.0 - 0.32);     //理想值：0.68      ----------->0.6799999999999999
//        System.out.println(1.015 * 100);    //理想值：101.5     ----------->101.49999999999999
//        System.out.println(1.301 / 100);    //理想值：0.01301   ----------->0.013009999999999999

        /**
         * 构造方法:
         *      BigDecimal(double val)  将double类型的数据封装为BigDecimal对象,不推荐使用
         *      BigDecimal(String val)  将 BigDecimal 的字符串表示形式转换为 BigDecimal
         *
         * 常用方法:
         *      public BigDecimal add(BigDecimal value)  		    加法运算
         *      public BigDecimal subtract(BigDecimal value)  		减法运算
         *      public BigDecimal multiply(BigDecimal value)  		乘法运算
         *      public BigDecimal divide(BigDecimal value)  		除法运算，不推荐
         *      public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) 除法
         *          divisor：除数对应的BigDecimal对象；
         *          scale:精确的位数；
         *          roundingMode取舍模式  枚举类型，示例： RoundingMode.HALF_UP 四舍五入
         * 需求：演示BigDecimal类的构造方法与常用方法
         */
        BigDecimal big = new BigDecimal("0.09");
        BigDecimal big1 = new BigDecimal("0.01");

        //加法运算
        System.out.println(big.add(big1));      //0.10
        //减法运算
        System.out.println(big.subtract(big1)); //0.08
        //乘法运算
        System.out.println(big.multiply(big1)); //0.0009
        //除法运算
        System.out.println(big.divide(big1));   //9


        //除不尽问题
        BigDecimal big2 = new BigDecimal("20");
        BigDecimal big3 = new BigDecimal("3");
//        System.out.println(big2.divide(big3));      //ArithmeticException: Non-terminating decimal expansion;
        
        //解决除不尽问题
        System.out.println(big2.divide(big3, 2, RoundingMode.HALF_UP));     //6.67

    }
}

9、Arrays类

9.1、Arrays类概述

java.util.Arrays类：该类包含用于操作数组的各种静态方法（如排序和搜索）。

9.2、Arrays类常用方法

public static void sort(int[] a)：按照数字顺序排列指定的数组升序
public static String toString(int[] a)：返回指定数组的内容的字符串表示形式

四、包装类

1、包装类的概述

概述: 为了更好的维护基本类型数据，java为基本类型创建了对应的引用类型，这些类称为包装类

| 基本类型 	| 	对应的包装类（位于java.lang包中） | 
| 	byte 	| 				Byte 		 		 | 
| 	short 	| 				Short 				 | 
| 	int 	| 				Integer 			 | 
| 	long 	| 				Long 				 | 
| 	float 	| 				Float 				 | 
| 	double 	| 				Double 				 | 
| 	char 	| 				Character 			 | 
| 	boolean | 				Boolean 			 |

2、自动装箱和自动拆箱

1、自动装箱:
基本类型自动转换为对应的包装类类型---->直接把基本类型的值赋值给对应的包装类类型变量
2、自动拆箱:
包装类类型自动转换为对应的基本类型---->直接把包装类的对象赋值给对应的基本类型的变量

public class Test { 
	public static void main(String[] args) { 
		// - 自动装箱: 基本类型自动转换为对应的包装类类型---->直接把基本类型的值赋 值给对应的包装类类型变量 
		Integer i1 = 10; 
		Double d = 3.14; 
		// - 自动拆箱: 包装类类型自动转换为对应的基本类型---->直接把包装类的对象 赋值给对应的基本类型的变量 
		int num = i1; 
		double numD = d; 
		System.out.println(num + 10);//20 
	} 
}

3、基本类型与字符串之间的转换

3.1、基本类型–>字符串:

方式一: 基本类型的数据 + 空的字符串("")
方式二: 字符串的静态方法 public static String valueOf(基本类型的值);

public class Test {
    public static void main(String[] args) {
        /**
         * 3.1、基本类型-->字符串:
         * > 方式一: 基本类型的数据 + 空的字符串("") 
         * > 方式二: 字符串的静态方法 public static String valueOf(基本类型的值);
         */
        
        //方式一: 基本类型的数据 + 空的字符串("") 
        String str = 10 + "";

        //方式二: 字符串的静态方法 public static String valueOf(基本类型的值);
        String str1 = String.valueOf(10);
    }
}

3.2字符串–>基本类型:

方式一: 通过包装类的静态方法 valueOf(String s) 得到包装类对象,然后包装类对象自动拆箱为基本类型—>除了Character包装类之外,所有包装类都有这个方法
方式二: 通过包装类的静态方法parseXXX类型(String s) 得到对应的基本类型—>除了 Character包装类之外,所有包装类都有这个方法


public class Test1 {
    public static void main(String[] args) {
        /**
         * 3.2字符串-->基本类型:
         *
         * > 方式一: 通过包装类的静态方法 valueOf(String s) 得到包装类对象,然后包装类对象自动拆箱为基本类型
         *          --->除了Character包装类之外,所有包装类都有这个方法 
         * > 方式二: 通过包装类的静态方法parseXXX类型(String s) 得到对应的基本类型
         *          --->除了 Character包装类之外,所有包装类都有这个方法
         */
        //通过包装类的静态方法 valueOf(String s) 得到包装类对象,然后包装类对象自动拆箱为基本类型
        String str = "123";
        int num = Integer.valueOf(str);
        
        //通过包装类的静态方法parseXXX类型(String s) 得到对应的基本类型
        int num1 = Integer.parseInt(str);

    }
}