Java—常用API

最新推荐文章于 2025-04-06 19:42:50 发布

CSM97119

最新推荐文章于 2025-04-06 19:42:50 发布

阅读量462

点赞数

CC 4.0 BY-SA版权

分类专栏： java

本文链接：https://blog.youkuaiyun.com/weixin_42426779/article/details/101082159

java 专栏收录该内容

5 篇文章

订阅专栏

文章目录

- 二十一、常用API

二十一、常用API

API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。

21.1 static关键字

关于 static关键字的使用，它可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。既然属于类，就可以不靠创建对象来调用了。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
static关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。

类变量
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。
格式：

static 数据类型 变量名

eg:

public class Student {
    private int id; // 学号
    private String name; // 姓名
    private int age; // 年龄
    static String room; // 所在教室
    private static int idCounter = 0; // 学号计数器，每当new了一个新对象的时候，计数器++

    public Student() {
        this.id = ++idCounter;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }
}

public class Demo01StaticField {
    public static void main(String[] args) {
        Student two = new Student("黄蓉", 16);
        two.room = "101教室";
        System.out.println("姓名：" + two.getName()
                + "，年龄：" + two.getAge() + "，教室：" + two.room
                + "，学号：" + two.getId());

        Student one = new Student("郭靖", 19);
        System.out.println("姓名：" + one.getName()
                + "，年龄：" + one.getAge() + "，教室：" + one.room
                + "，学号：" + one.getId());
    }

}

静态方法
一旦使用static修饰成员方法，那么这就成为了静态方法，也称为类方法。静态方法不属于对象，而是属于类的。
定义格式：

修饰符 static 返回值类型 方法名(参数列表){
	//执行语句
}

注意：

静态方法可以直接访问类变量和静态方法。
静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
原因：在内存当中是【先】有的静态内容，【后】有的非静态内容。
静态方法中，不能使用this关键字。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

eg:

public class MyClass {
    int num; // 成员变量
    static int numStatic; // 静态变量

    // 成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(numStatic);
    }

    // 静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法。");
        // 静态方法可以访问静态变量
        System.out.println(numStatic);
        // 静态不能直接访问非静态【重点】
//        System.out.println(num); // 错误写法！

        // 静态方法中不能使用this关键字。
//        System.out.println(this); // 错误写法！
    }

}

public class Demo02StaticMethod {
    public static void main(String[] args) {
        MyClass obj = new MyClass(); // 首先创建对象
        // 然后才能使用没有static关键字的内容
        obj.method();

        // 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
        obj.methodStatic(); // 正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
        MyClass.methodStatic(); // 正确，推荐

        // 对于本来当中的静态方法，可以省略类名称
        myMethod();
        Demo02StaticMethod.myMethod(); // 完全等效
    }

    public static void myMethod() {
        System.out.println("自己的方法！");
    }

}

调用格式
被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，但是多个对象均属于一个类，共享使用同一个静态成员，所以不建议，而且会出现警告信息。
格式：

//访问类变量
类名.类变量名
//调用静态方法
类名.静态方法(参数)

静态原理图解
static修饰的内容：
- 是随着类的加载而加载的，且只加载一次。
- 存储于一块固定的内存区域（静态区），所以可以直接被类名调用。
- 他优先于对象存在，所以可以被所有对象共享。

注意：根据类名称访问静态成员变量的时候，全程和对象没关系，只和类有关系。

在这里插入图片描述

静态代码块
定义在成员位置，使用static修饰的代码块{}。

位置：类中方法外
执行：随着类的加载而执行且只执行一次，优先于main方法和构造方法的执行。

格式：

public class 类名称 {
    static {
        // 静态代码块的内容
    }
}

典型用途：用来一次性地对静态成员变量进行赋值。
eg:

public class Game {   
	public static int number;   
	public static ArrayList<String> list;     
	static {     
		// 给类变量赋值     
		number = 2;     
		list = new ArrayList<String>();     
		// 添加元素到集合中     
		list.add("张三");     
		list.add("李四");   
	} 
}

21.2 引用类型步骤

导包
使用import关键字导包，在类的所有代码之前导包，引入要使用的类型。

注意：

如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
只有java.lang包下的内容不需要导包，其他的包都需要import语句。

格式：

import 包名.类名;

创建对象
使用该类的构造方法，创建一个该类的对象。
格式：

数据类型 变量名 = new 数据类型(参数列表);

调用方法
调用该类的成员方法，完成指定功能。
格式：

变量名.方法名();

21.3 Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。

Scanner使用步骤：

查看类
java.util.Scanner：该类需要import导入后使用。
查看构造方法
public Scanner(InputStream source)：构造一个新的Scanner，它生成的值是从指定的输入流扫描的。
查看成员方法
public int nextInt()：将输入信息的下一个标记扫描为一个int值。

eg:
键盘录入三个数据并获取大值。

//1. 导包 
import java.util.Scanner; 
public class Test02Scanner {   
	public static void main(String[] args) {     
		// 创建对象     
		Scanner sc = new Scanner(System.in);     
		// 接收数据     
		System.out.println("请输入第一个数据：");     
		int a = sc.nextInt();     
		System.out.println("请输入第二个数据：");     
		int b = sc.nextInt();     
		System.out.println("请输入第三个数据：");     
		int c = sc.nextInt();       
		// 如何获取三个数据的大值     
		int temp = (a > b ? a : b);     
		int max = (temp > c ? temp : c);       
		System.out.println("max:" + max);   
	} 
}

21.4 Random类

此类的实例用于生成伪随机数。

Random使用步骤：

查看类
java.util.Random：该类需要import导入后使用。
查看构造方法
public Random()：创建一个新的随机数生成器。
查看成员方法
public int nextInt(int n)：返回一个伪随机数，范围在0（包括）和指定值n（不包括）之间的int值。

获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt();
获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3);

练习：
eg:
猜数字小游戏：
游戏开始时，会随机生成一个1-100之间的整数 number 。玩家猜测一个数字 guessNumber ，会与 number 作比较，系统提示大了或者小了，直到玩家猜中，游戏结束。

// 导包 
import java.util.Random; 
public class Test02Random {   
	public static void main(String[] args) {     
		// 系统产生一个随机数1‐100之间的。     
		Random r = new Random();     
		int number = r.nextInt(100) + 1;     
		while(true){       
			// 键盘录入我们要猜的数据       
			Scanner sc = new Scanner(System.in);       
			System.out.println("请输入你要猜的数字(1‐100)：");       
			int guessNumber = sc.nextInt();         
			// 比较这两个数据(用if语句)       
			if (guessNumber > number) {         
				System.out.println("你猜的数据" + guessNumber + "大了");       
			} else if (guessNumber < number) {         
				System.out.println("你猜的数据" + guessNumber + "小了");       
			} else {         
				System.out.println("恭喜你,猜中了");         
				break;       
			}     
		}   
	} 
}

21.5 ArrayList类

java.util.ArrayList是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。ArrayList中可不断添加元素，其大小也自动增长。

ArrayList使用步骤：

查看类
java.util.ArrayList <E> ：该类需要 import导入使后使用。

<E>表示一种指定的数据类型，叫做泛型（也就是装在集合当中的所有元素，全都是统一的类型）。在出现E的地方，我们使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。

查看构造方法
public ArrayList()：构造一个内容为空的集合。

基本格式：

ArrayList<String> list = new ArrayList<String>();

在JDK 7后,右侧泛型的尖括号之内可以留空，但是<>仍然要写。简化格式：

ArrayList<String> list = new ArrayList<>();

查看成员方法
public boolean add(E e)：将指定的元素添加到此集合的尾部。

参数 E e ，在构造ArrayList对象时， <E> 指定了什么数据类型，那么 add(E e) 方法中，只能添加什么数据类型的对象。

常用方法：

public boolean add(E e)：将指定的元素添加到此集合的尾部，参数的类型和泛型一致。返回值代表添加是否成功。
public E remove(int index)：移除此集合中指定位置上的元素，参数是索引编号，返回值是被删除的元素。
public E get(int index)：返回此集合中指定位置上的元素，参数是索引编号，返回值是获取的元素。
public int size()：返回此集合中的元素数。

注意：

泛型只能是引用类型，不能是基本类型。
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容，如果内容是空，得到的是空的中括号：[ ]
对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用，但是对于其他集合来说，add添加动作不一定成功。

eg:

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list); // []

        // 向集合中添加元素：add
        boolean success = list.add("柳岩");
        System.out.println(list); // [柳岩]
        System.out.println("添加的动作是否成功：" + success); // true

        list.add("高圆圆");
        list.add("赵又廷");
        list.add("李小璐");
        list.add("贾乃亮");
        System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 李小璐, 贾乃亮]

        // 从集合中获取元素：get。索引值从0开始
        String name = list.get(2);
        System.out.println("第2号索引位置：" + name); // 赵又廷

        // 从集合中删除元素：remove。索引值从0开始。
        String whoRemoved = list.remove(3);
        System.out.println("被删除的人是：" + whoRemoved); // 李小璐
        System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 贾乃亮]

        // 获取集合的长度尺寸，也就是其中元素的个数
        int size = list.size();
        System.out.println("集合的长度是：" + size);
    }

如何存储基本数据类型：
ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似<int>不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据，<> 中的数据类型，必须转换后才能编写，转换写法如下：

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

从JDK 1.5+开始，支持自动装箱、自动拆箱。
自动装箱：基本类型 --> 包装类型
自动拆箱：包装类型 --> 基本类型

eg:

public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        // 错误写法！泛型只能是引用类型，不能是基本类型
//        ArrayList<int> listB = new ArrayList<>();

        ArrayList<Integer> listC = new ArrayList<>();
        listC.add(100);  //自动装箱
        listC.add(200);  //自动装箱
        System.out.println(listC); // [100, 200]

        int num = listC.get(1);  //自动拆箱
        System.out.println("第1号元素是：" + num);
    }

练习：

eg:
用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中。
要求使用自定义的方法来实现筛选。

分析：

需要创建一个大集合，用来存储int数字：
随机数字就用Random nextInt
循环20次，把随机数字放入大集合：for循环、add方法
定义一个方法，用来进行筛选。
筛选：根据大集合，筛选符合要求的元素，得到小集合。
三要素
返回值类型：ArrayList小集合（里面元素个数不确定）
方法名称：getSmallList
参数列表：ArrayList大集合（装着20个随机数字）
判断（if）是偶数：num % 2 == 0
如果是偶数，就放到小集合当中，否则不放。

import java.util.ArrayList;
import java.util.Random;
public class DemoArrayListReturn {

    public static void main(String[] args) {
        ArrayList<Integer> bigList = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100) + 1; // 1~100
            bigList.add(num);
        }

        ArrayList<Integer> smallList = getSmallList(bigList);

        System.out.println("偶数总共有多少个：" + smallList.size());
        for (int i = 0; i < smallList.size(); i++) {
            System.out.println(smallList.get(i));
        }
    }

    // 这个方法，接收大集合参数，返回小集合结果
    public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) {
        // 创建一个小集合，用来装偶数结果
        ArrayList<Integer> smallList = new ArrayList<>();
        for (int i = 0; i < bigList.size(); i++) {
            int num = bigList.get(i);
            if (num % 2 == 0) {
                smallList.add(num);
            }
        }
        return smallList;
    }

}

21.6 String类

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实例。

特点：

字符串的内容永不可变。
正是因为字符串不可改变，所以字符串是可以共享使用的。
字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

使用步骤：

查看类：
java.lang.String：此类不需要导入。
创建字符串的常见3+1种方式：
三种构造方法：
1. public String()：创建一个空白字符串，不含有任何内容。
2. public String(char[] value)：根据字符数组的内容，来创建对应的字符串。
3. public String(byte[] bytes)：根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = "Hello";

注意：直接写上双引号，就是字符串对象。

eg:

// 使用空参构造
String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。

// 根据字符数组创建字符串
char[] charArray = { 'A', 'B', 'C' };
String str2 = new String(charArray);

// 根据字节数组创建字符串
byte[] byteArray = { 97, 98, 99 };
String str3 = new String(byteArray);

// 直接创建
String str4 = "Hello";

拓展：

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。
在这里插入图片描述

注意：
对于基本类型来说，==是进行数值的比较。
对于引用类型来说，==是进行【地址值】的比较。

常用方法：

判断功能的方法：
public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。

注意：

Object是一种引用类型，任何对象都能用Object进行接收。
equals方法具有对称性，即a.equals(b)和b.equals(a)效果一样。
如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
推荐：“abc”.equals(str);
不推荐：str.equals(“abc”);

eg:

public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {'H', 'e', 'l', 'l', 'o'};
        String str3 = new String(charArray);

        System.out.println(str1.equals(str2)); // true
        System.out.println(str2.equals(str3)); // true
        System.out.println(str3.equals("Hello")); // true
        System.out.println("Hello".equals(str1)); // true

        String str4 = "hello";
        System.out.println(str1.equals(str4)); // false
        System.out.println("=================");

        String str5 = null;
        System.out.println("abc".equals(str5)); // 推荐：false
//        System.out.println(str5.equals("abc")); // 不推荐：报错，空指针异常NullPointerException
        System.out.println("=================");

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB)); // false，严格区分大小写
        System.out.println(strA.equalsIgnoreCase(strB)); // true，忽略大小写
}

获取功能的方法：
public int length()：获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index)：获取指定索引位置的单个字符。
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

eg:

public static void main(String[] args) {
        // 获取字符串的长度
        int length = "asdasfeutrvauevbueyvb".length();
        System.out.println("字符串的长度是：" + length);

        // 拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1); // Hello，原封不动
        System.out.println(str2); // World，原封不动
        System.out.println(str3); // HelloWorld，新的字符串

        // 获取指定索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是：" + ch);

        // 查找参数字符串在本来字符串当中出现的第一次索引位置
        // 如果根本没有，返回-1值
        String original = "HelloWorldHelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次索引值是：" + index); // 2
        System.out.println("HelloWorld".indexOf("abc")); // -1
    }

字符串的截取方法：
public String substring(int index)：返回一个新字符串，截取从begin一直到字符串末尾。
public String substring(int begin, int end)：返回一个新字符串，从begin到 end截取字符串。含begin，不含end。

eg:

public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1); // HelloWorld，原封不动
        System.out.println(str2); // World，新字符串

        String str3 = str1.substring(4, 7);
        System.out.println(str3); // oWo
    }

转换功能的方法：
public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层字节数组。
public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换成为新字符串，返回替换之后的新字符串。（CharSequence是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中）

eg:

public static void main(String[] args) {
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); // H
        System.out.println(chars.length); // 5

        // 转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }

        // 字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1); // How do you do?
        System.out.println(str2); // H*w d* y*u d*?

        String lang1 = "会不会玩儿呀！你大爷的！你大爷的！你大爷的！！！";
        String lang2 = lang1.replace("你大爷的", "****");
        System.out.println(lang2); // 会不会玩儿呀！****！****！****！！！
    }

分割字符串的方法：
public String[] split(String regex)：按照参数的规则，将字符串切分成为若干部分。

注意：
split方法的参数其实是一个“正则表达式”。
如果按照英文句点.进行切分，必须写\\.（两个反斜杠）。

eg:

public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }

        String str2 = "aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }

        String str3 = "XXX.YYY.ZZZ";
        String[] array3 = str3.split("\\.");
        System.out.println(array3.length); // 0
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
    }

练习：
eg:
定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。

分析：

首先准备一个int[]数组，内容是：1、2、3
定义一个方法，用来将数组变成字符串
三要素
返回值类型：String
方法名称：fromArrayToString
参数列表：int[]
格式：[word1#word2#word3]
用到：for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个
调用方法，得到返回值，并打印结果字符串

public class Demo06StringPractise {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};

        String result = fromArrayToString(array);
        System.out.println(result);
    }

    public static String fromArrayToString(int[] array) {
        String str = "[";
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                str += "word" + array[i] + "]";
            } else {
                str += "word" + array[i] + "#";
            }
        }
        return str;
    }

}

eg:
键盘输入一个字符串，并且统计其中各种字符出现的次数。
种类有：大写字母、小写字母、数字、其他

分析：

既然用到键盘输入，肯定是Scanner
键盘输入的是字符串，那么：String str = sc.next();
定义四个变量，分别代表四种字符各自的出现次数。
需要对字符串一个字、一个字检查，String–>char[]，方法就是toCharArray()
遍历char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。
打印输出四个变量，分别代表四种字符出现次数。

import java.util.Scanner;
public class Demo07StringCount {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String input = sc.next(); // 获取键盘输入的一个字符串

        int countUpper = 0; // 大写字母
        int countLower = 0; // 小写字母
        int countNumber = 0; // 数字
        int countOther = 0; // 其他字符

        char[] charArray = input.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i]; // 当前单个字符
            if ('A' <= ch && ch <= 'Z') {
                countUpper++;
            } else if ('a' <= ch && ch <= 'z') {
                countLower++;
            } else if ('0' <= ch && ch <= '9') {
                countNumber++;
            } else {
                countOther++;
            }
        }

        System.out.println("大写字母有：" + countUpper);
        System.out.println("小写字母有：" + countLower);
        System.out.println("数字有：" + countNumber);
        System.out.println("其他字符有：" + countOther);
    }

}

21.7 Arrays类

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

操作数组的方法
public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3…]）。
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

注意：

如果是数值，sort默认按照升序从小到大。
如果是字符串，sort默认按照字母升序。
如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。

eg:

public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        // 将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); // [10, 20, 30]

        int[] array1 = {2, 1, 3, 10, 6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]

        String[] array2 = {"bbb", "aaa", "ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
    }

练习：
请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。

public static void main(String[] args) {
        String str = "asv76agfqwdfvasdfvjh";
        // 如何进行升序排列：sort
        // 必须是一个数组，才能用Arrays.sort方法
        // String --> 数组，用toCharArray
        char[] chars = str.toCharArray();
        Arrays.sort(chars); // 对字符数组进行升序排列

        // 需要倒序遍历
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.print(chars[i]);
        }
    }

21.8 Math类

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，如初等指数、对数、平方根和三角函数等，完成与数学运算相关的操作。

基本运算方法：
public static double abs(double num)：获取绝对值，有多种重载。
public static double ceil(double bum)：向上取整。
public static double floor(double num)：向下取整。
public static long round(double num)：四舍五入。

Math.PI代表近似的圆周率常量（double）。
eg:

public static void main(String[] args) {
        // 获取绝对值
        System.out.println(Math.abs(3.14)); // 3.14
        System.out.println(Math.abs(0)); // 0
        System.out.println(Math.abs(-2.5)); // 2.5

        // 向上取整
        System.out.println(Math.ceil(3.9)); // 4.0
        System.out.println(Math.ceil(3.1)); // 4.0
        System.out.println(Math.ceil(3.0)); // 3.0

        // 向下取整，抹零
        System.out.println(Math.floor(30.1)); // 30.0
        System.out.println(Math.floor(30.9)); // 30.0
        System.out.println(Math.floor(31.0)); // 31.0

        System.out.println(Math.round(20.4)); // 20
        System.out.println(Math.round(10.5)); // 11
    }

练习；
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

分析：

既然已经确定了范围，for循环
起点位置-10.8应该转换成为-10，两种办法：
2.1 可以使用Math.ceil方法，向上（向正方向）取整
2.2 强转成为int，自动舍弃所有小数位
每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的。
如何拿到绝对值：Math.abs方法。
一旦发现了一个数字，需要让计数器++进行统计。

如果使用Math.ceil()方法，-10.8可以变成-10.0。注意double也是可以进行++的。

public class Demo04MathPractise {
    public static void main(String[] args) {
        int count = 0; // 符合要求的数量
        double min = -10.8;
        double max = 5.9;
        // 这样处理，变量i就是区间之内所有的整数
        for (int i = (int) min; i < max; i++) {
            int abs = Math.abs(i); // 绝对值
            if (abs > 6 || abs < 2.1) {
                System.out.println(i);
                count++;
            }
        }
        System.out.println("总共有：" + count); // 9
    }
}

21.8 Object类

java.lang.Object是类层次结构的根(父)类，每个类都使用 Object作为超(父)类。所有对象（包括数组）都实现这个类的方法。

方法：
public String toString()：返回该对象的字符串表示。

注意：

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
直接打印对象的名字,其实就是调用对象的toString()。

eg:

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

   /*@Override
    public String toString() {
       //return "abc";
       return "Person{name="+name+" ,age="+age+"}";
    }*/
    /*@Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }*/

    // 省略构造器与Getter Setter
}

public class Demo01ToString{
    public static void main(String[] args) {
        /*
            Person类默认继承了Object类,所以可以使用Object类中的toString方法
            String toString() 返回该对象的字符串表示。
         */
        Person p = new Person("张三",18);
        String s = p.toString();
        System.out.println(s);//com.itheima.demo01.Object.Person@75412c2f | abc | Person{name=张三 ,age=18}

        //直接打印对象的名字,其实就是调用对象的toString  p=p.toString();
        System.out.println(p);//com.itheima.demo01.Object.Person@5f150435 | abc | Person{name=张三 ,age=18}

        //看一个类是否重写了toString,直接打印这个类的对象即可,如果没有重写toString方法那么打印的是对象的地址值
        Random r = new Random();
        System.out.println(r);//java.util.Random@3f3afe78  没有重写toString方法

        Scanner sc = new Scanner(System.in);
        System.out.println(sc);//java.util.Scanner[delimiters=\p{javaWhitespace}+..  重写toString方法

        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);//[1, 2, 3]  重写toString方法
    }
}

public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。
equals方法源码：

public boolean equals(Object obj) {
                    return (this == obj);
                }

参数:
Object obj:可以传递任意的对象
== 比较运算符,返回的是一个布尔值 true / false
基本数据类型:比较的是值
引用数据类型:比较的是两个对象的地址值
this是谁?那个对象调用的方法,方法中的this就是那个对象;p1调用的equals方法所以this就是p1
obj是谁?传递过来的参数p2 thisobj -->p1p2

eg:

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

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /*
        Object类的equals方法,默认比较的是两个对象的地址值,没有意义
        所以我们要重写equals方法,比较两个对象的属性(name,age)
        问题:
            隐含着一个多态
            多态的弊端:无法使用子类特有的内容(属性和方法)
            Object obj = p2 = new Person("古力娜扎",19);
            解决:可以使用向下转型(强转)把obj类型转换为Person
     */
    /*@Override
    public boolean equals(Object obj) {
        //增加一个判断,传递的参数obj如果是this本身,直接返回true,提高程序的效率
        if(obj==this){
            return true;
        }

        //增加一个判断,传递的参数obj如果是null,直接返回false,提高程序的效率
        if(obj==null){
            return false;
        }

        //增加一个判断,防止类型转换一次ClassCastException
        if(obj instanceof Person){
            //使用向下转型,把obj转换为Person类型
            Person p = (Person)obj;
            //比较两个对象的属性,一个对象是this(p1),一个对象是p(obj->p2)
            boolean b = this.name.equals(p.name) && this.age==p.age;
            return b;
        }
        //不是Person类型直接返回false
        return false;
    }*/
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        //getClass() != o.getClass() 使用反射技术,判断o是否是Person类型  等效于 obj instanceof Person
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    // 省略构造器与Getter Setter
}

public class Demo02Equals {
    public static void main(String[] args) {
        Person p1 = new Person("迪丽热巴",18);
        //Person p2 = new Person("古力娜扎",19);
        Person p2 = new Person("迪丽热巴",18);
        System.out.println("p1:"+p1);//p1:com.itheima.demo01.Object.Person@58ceff1
        System.out.println("p2:"+p2);//p2:com.itheima.demo01.Object.Person@7c30a502

        //p1=p2;//把p2的地址值赋值给p1
        
        ArrayList<String> list = new ArrayList<>();

        boolean b = p1.equals(p1);
        System.out.println(b);
    }
}

Objects类的equals方法:对两个对象进行比较,防止空指针异常（NullPointerException）。

public static boolean equals(Object a, Object b) {
                return (a == b) || (a != null && a.equals(b));
            }

eg:

public class Demo03Objects {
    public static void main(String[] args) {
        String s1 = "abc";
        //String s1 = null;
        String s2 = "abc";
        //boolean b = s1.equals(s2); // NullPointerException null是不能调用方法的,会抛出空指针异常
        //System.out.println(b);
        
        boolean b2 = Objects.equals(s1, s2);
        System.out.println(b2);

    }
}

21.9 Date类

java.util.Date类表示日期和时间的类（表示特定的瞬间，精确到毫秒）。

日期转换为毫秒：就是计算机当前日期到时间原点之间一共经历了多少毫秒。
时间原点（0毫秒）：1970年1月1日 00:00:00（英国格林威治）
注意：中国属于东八区，会把时间增加8个小时，即1970年1月1日 08:00:00

毫秒转换为日期：
1天 = 246060 = 86400秒 = 86400*1000 = 86400000毫秒

Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

构造方法：
public Date()：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
public Date(long date)：分配Date对象并初始化此对象，以表示标准基准时间（称为“历元（epoch）”）加上指定毫秒数的时间。

eg:

import java.util.Date;
public class Demo01Date {
    public static void main(String[] args) {
        demo01();
        demo02();
    }

	/*
        Date类的带参数构造方法
        Date(long date) :传递毫秒值,把毫秒值转换为Date日期
     */
    private static void demo02() {
        Date date = new Date(0L);
        System.out.println(date);// Thu Jan 01 08:00:00 CST 1970

        date = new Date(3742767540068L);
        System.out.println(date);// Sun Aug 08 09:39:00 CST 2088
    }

    /*
        Date类的空参数构造方法
        Date() 获取当前系统的日期和时间
     */
    private static void demo01() {
        Date date = new Date();
        System.out.println(date);//Sun Aug 08 12:23:03 CST 2088
    }
}

常用方法：
public long getTime() 把日期转换为毫秒值(相当于System.currentTimeMillis()方法，返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此Date对象表示的毫秒数。)

eg:

private static void demo03() {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);//3742777636267
    }

21.10 DateFormat类

java.text.DateFormat 是日期/时间格式化子类的抽象类，通过这个类可以完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。
格式化：日期→文本
解析：文本→日期

DateFormat类是一个抽象类,无法直接创建对象使用,可以使用其的子类java.text.SimpleDateFormat （extends DateFormat）。
构造方法：SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
参数：String pattern传递指定的模式
模式：区分大小写


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

写对应的模式，会把模式替换为对应的日期和时间"yyyy-MM-dd HH:mm:ss"，模式中的字母不能更改，连接模式的符号可以改变"yyyy年MM月dd日 HH时mm分ss秒"。

成员方法：
public String format(Date date)：按照指定的模式,把Date日期,格式化为符合模式的字符串。
使用步骤:

创建SimpleDateFormat对象，构造方法中传递指定的模式；
调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串(文本)。

eg:

import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo01DateFormat {
    public static void main(String[] args) throws ParseException {
        demo01();
    }

    private static void demo01() {
        //1.创建SimpleDateFormat对象,构造方法中传递指定的模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
        //String format(Date date)  按照指定的模式,把Date日期,格式化为符合模式的字符串
        Date date = new Date();
        String d = sdf.format(date);
        System.out.println(date);//Sun Aug 08 15:51:54 CST 2088
        System.out.println(d);//2088年08月08日 15时51分54秒
    }
}

public Date parse(String source)：把符合模式的字符串,解析为Date日期。
使用步骤：

创建SimpleDateFormat对象,构造方法中传递指定的模式；
调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期。

注意：
public Date parse(String source) throws ParseException
parse方法声明了一个异常叫ParseException
如果字符串和构造方法的模式不一样，那么程序就会抛出此异常。
调用一个抛出了异常的方法,就必须的处理这个异常，要么throws继续抛出这个异常,要么try catch自己处理

eg:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo01DateFormat {
    public static void main(String[] args) throws ParseException {
        demo02();
    }
    
    private static void demo02() throws ParseException {
        //1.创建SimpleDateFormat对象,构造方法中传递指定的模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
        //Date parse(String source)  把符合模式的字符串,解析为Date日期
        Date date = sdf.parse("2088年08月08日 15时51分54秒");
        System.out.println(date);
    }
}

练习：
请使用日期时间相关的API，计算出一个人已经出生了多少天。
分析：

使用Scanner类中的方法next,获取出生日期；
使用DateFormat类中的方法parse，把字符串的出生日期，解析为Date格式的出生日期；
把Date格式的出生日期转换为毫秒值；
获取当前的日期,转换为毫秒值；
使用当前日期的毫秒值-出生日期的毫秒值；
把毫秒差值转换为天(s/1000/60/60/24)；

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class Demo02Test {
    public static void main(String[] args) throws ParseException {
        //1.使用Scanner类中的方法next,获取出生日期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的出生日期,格式:yyyy-MM-dd");
        String birthdayDateString = sc.next();
        //2.使用DateFormat类中的方法parse,把字符串的出生日期,解析为Date格式的出生日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sdf.parse(birthdayDateString);
        //3.把Date格式的出生日期转换为毫秒值
        long birthdayDateTime = birthdayDate.getTime();
        //4.获取当前的日期,转换为毫秒值
        long todayTime = new Date().getTime();
        //5.使用当前日期的毫秒值-出生日期的毫秒值
        long time = todayTime-birthdayDateTime;
        //6.把毫秒差值转换为天(s/1000/60/60/24)
        System.out.println(time/1000/60/60/24);
    }
}

21.11 Calendar类

java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的类。

获取方法：
Calendar为抽象类，无法直接创建对象使用,里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象。
public static Calendar getInstance()：使用默认时区和语言环境获得一个日历。

import java.util.Calendar;

public class Demo01Calendar {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();//多态
        System.out.println(c);
    }
}

常用方法：
public int get(int field)：返回给定日历字段的值。
public void set (int field, int value)：将给定的日历字段设置为给定的值。
public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

int field：日历类的字段，可以使用Calendar类的静态成员变量获取。

字段值	含义
`public static final int YEAR`	年
`public static final int MONTH`	月（从0开始）
`public static final int DATE`	月中的某一天
`public static final int DAY_OF_MONTH`	月中的某一天
`public static final int HOUR`	时（12小时制）
`public static final int HOUR_OF_DAY`	时（24小时制）
`public static final int MINUTE`	分
`public static final int SECOND`	秒
`public static final int DAY_OF_DAY`	周中的天（周日为1，可以-1使用）

eg：

public int get(int field)：
参数:传递指定的日历字段(YEAR,MONTH…)
返回值:日历字段代表的具体的值

private static void demo01() {
        //使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month);//西方的月份0-11 东方:1-12

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

public void set (int field, int value)：
参数:
int field:传递指定的日历字段(YEAR,MONTH…)
int value:给指定字段设置的值

private static void demo02() {
        //使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        //设置年为9999
        c.set(Calendar.YEAR,9999);
        //设置月为9月
        c.set(Calendar.MONTH,9);
        //设置日9日
        c.set(Calendar.DATE,9);

        //同时设置年月日,可以使用set的重载方法
        c.set(8888,8,8);

        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month);//西方的月份0-11 东方:1-12

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

public abstract void add(int field, int amount)：
参数:
int field:传递指定的日历字段(YEAR,MONTH…)
int amount:增加/减少指定的值
正数:增加
负数:减少

private static void demo03() {
        //使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        //把年增加2年
        c.add(Calendar.YEAR,2);
        //把月份减少3个月
        c.add(Calendar.MONTH,-3);


        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month);//西方的月份0-11 东方:1-12

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

public Date getTime()：把日历对象,转换为日期对象

private static void demo04() {
        //使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        Date date = c.getTime();
        System.out.println(date);
    }

21.12 System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。

常用方法：
public static long currentTimeMillis()：返回以毫秒为单位的当前时间（实际上是获取当前系统时间与1970年01月01日00:00点之间的毫秒差值）。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中（数组的拷贝动作是系统级的，性能很高）。

eg:

public static long currentTimeMillis():

/*
用来程序的效率，验证for循环打印数字1-9999所需要使用的时间（毫秒）
*/
private static void demo01() {
        //程序执行前,获取一次毫秒值
        long s = System.currentTimeMillis();
        //执行for循环
        for (int i = 1; i <=9999 ; i++) {
            System.out.println(i);
        }
        //程序执行后,获取一次毫秒值
        long e = System.currentTimeMillis();
        System.out.println("程序共耗时:"+(e-s)+"毫秒");//程序共耗时:106毫秒
    }

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：
参数:
src - 源数组。
srcPos - 源数组中的起始位置(起始索引)。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。

/*
将src数组中前3个元素，复制到dest数组的前3个位置上
   复制元素前：
   src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]
   复制元素后：
   src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]
*/
private static void demo02() {
        //定义源数组
        int[] src = {1,2,3,4,5};
        //定义目标数组
        int[] dest = {6,7,8,9,10};
        System.out.println("复制前:"+ Arrays.toString(dest));
        //使用System类中的arraycopy把源数组的前3个元素复制到目标数组的前3个位置上
        System.arraycopy(src,0,dest,0,3);
        System.out.println("复制后:"+ Arrays.toString(dest));
    }

21.13 StringBuilder类

String和StringBuilder的区别
在这里插入图片描述
构造函数
public StringBuilder()：构造一个不带任何字符的字符串生成器，其初始容量为16个字符。
public StringBuilder(String str)：构造一个字符串生成器，并初始化为指定的字符串内容。

eg:

public class Demo01StringBuilder {
    public static void main(String[] args) {
        //空参数构造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);//bu1:""

        //带字符串的构造方法
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);//bu2:abc
    }
}

常用方法

public StringBuilder append(...)：添加任何类型数据的字符串形式，并返回当前对象自身。
eg:

public class Demo02StringBuilder {
    public static void main(String[] args) {
        //创建StringBuilder对象
        StringBuilder bu = new StringBuilder();
        //使用append方法往StringBuilder中添加数据
        //append方法返回的是this,调用方法的对象bu,this==bu
        //StringBuilder bu2 = bu.append("abc");//把bu的地址赋值给了bu2
        //System.out.println(bu);//"abc"
        //System.out.println(bu2);//"abc"
        //System.out.println(bu==bu2);//比较的是地址 true

        //使用append方法无需接收返回值
//        bu.append("abc");
//        bu.append(1);
//        bu.append(true);
//        bu.append(8.8);
//        bu.append('中');
//        System.out.println(bu);//abc1true8.8中

        /*
            链式编程:方法返回值是一个对象,可以继续调用方法
         */
        System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase());
        bu.append("abc").append(1).append(true).append(8.8).append('中');
        System.out.println(bu);//abc1true8.8中

    }
}

public String toString()：将当前StringBuilder对象转换为String对象。

StringBuilder和String可以相互转换：
String→StringBuilder：可以使用StringBuilder的构造方法public StringBuilder(String str)；
StringBuilder→String：可以使用StringBuilder的toString方法public String toString()。

eg:

public class Demo03StringBuilder {
    public static void main(String[] args) {
        //String->StringBuilder
        String str = "hello";
        System.out.println("str:"+str);
        StringBuilder bu = new StringBuilder(str);
        //往StringBuilder中添加数据
        bu.append("world");
        System.out.println("bu:"+bu);

        //StringBuilder->String
        String s = bu.toString();
        System.out.println("s:"+s);
    }
}

21.14 包装类

基本数据类型使用起来很方便，但是没有对应的方法来操作这些基本类型的数据。可以使用一个类把基本类型的数据装起来，在类中定义一些方法来操作这些基本类型的数据，这个类就是包装类。

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

用Integer与 int为例：

装箱：把基本类型的数据包装到包装类中（基本类型的数据→包装类）

构造方法：
Integer(int value)构造一个新分配的 Integer 对象，它表示指定的 int 值。
Integer(String s)构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值（传递的字符串必须是基本类型的字符串，否则会抛出异常）。
静态方法：
static Integer valueOf(int i)返回一个表示指定的int值的Integer实例。
static Integer valueOf(String s)返回保存指定的 String 的值的 Integer 对象。

eg:

//装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
//构造方法
Integer in1 = new Integer(1);//方法上有横线,说明方法过时了
System.out.println(in1);//1 重写了toString方法

Integer in2 = new Integer("1");
System.out.println(in2);//1

//静态方法
Integer in3 = Integer.valueOf(1);
System.out.println(in3);

//Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化异常
Integer in4 = Integer.valueOf("1");
System.out.println(in4);

拆箱：在包装类中取出基本类型的数据(包装类->基本类型的数据)

成员方法:
int intValue()以int类型返回该Integer的值。

eg:

//拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
Integer in1 = new Integer(1);
int i = in1.intValue();
System.out.println(i);

自动装箱与自动拆箱：基本类型的数据和包装类之间可以自动的相互转换（JDK1.5之后出现的新特性）。
eg:

public class Demo02Ineger {
    public static void main(String[] args) {
        /*
            自动装箱:直接把int类型的整数赋值包装类
            Integer in = 1; 就相当于 Integer in = new Integer(1);
         */
        Integer in = 1;

        /*
            自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算
            in+2;就相当于 in.intVale() + 2 = 3
            in = in.intVale() + 2 = 3 又是一个自动装箱
         */
        in = in+2;

        ArrayList<Integer> list = new ArrayList<>();
        /*
            ArrayList集合无法直接存储整数,可以存储Integer包装类
         */
        list.add(1); //-->自动装箱 list.add(new Integer(1));

        int a = list.get(0); //-->自动拆箱  list.get(0).intValue();
    }
}

基本类型与字符串类型之间的相互转换：

基本类型→字符串（String）
1. 基本类型的值+" "，最简单的方法（工作中常用）；
2. 包装类的静态方法toString(参数)，不是Object类的toString()重载，static String toString(int i)；
3. String类的静态方法valueOf(参数)，static String valueOf(int i)。
字符串（String）→基本类型
使用包装类的静态方法parseXXX(“字符串”)
Integer类：static int parseInt(String s)
Double类：static double parseDouble(String s)

注意：如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

eg:

public class Demo03Integer {
    public static void main(String[] args) {
        //基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1+"";
        System.out.println(s1+200);//100200

        String s2 = Integer.toString(100);
        System.out.println(s2+200);//100200

        String s3 = String.valueOf(100);
        System.out.println(s3+200);//100200

        //字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i-10);

        int a = Integer.parseInt("a");//NumberFormatException
        System.out.println(a);
    }
}