java学习笔记（十三） - 常用类

执笔2022-06-132024-06-10

一、包装类

1. 基本数据类型的包装类

八种基本数据类型相应的引用类型—包装类

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

2. 包装类和基本数据类型转换

2.1 int <——> Integer

2.1.1 手动装箱

在jdk5前为手动装箱和手动拆箱装箱：基本数据类型 —> 包装类型；反之拆箱

//基本数据类型 -----> 包装类型 [手动装箱]
int i = 10;
Integer i1 = new Integer(i);
Integer i2 = Integer.valueOf(i); 

//包装类型 ------> 基本数据类型[手动拆箱]
Integer j = new Integer(99);
int j1 = j.intValue();

2.1.2 自动装箱

jdk5及以后进行自动装箱和自动拆箱，自动装箱底层调用 valueOf()方法

int n2 = 200;
//自动装箱 int->Integer
Integer integer2 = n2;//底层调用的是 Integer.valueOf(n2);
//自动拆箱 Integer->int
int n3 = integer2;//底层调用 intValue()方法

2.2 String 和包装类

2.2.1 包装类型 -> String

//包装类型 -> String 类型
Integer i = 10;
//方式一
String s1 = i.toString();
//方式二
String s2 = String.valueOf(i);
//方式三
String s3 = i + " ";

2.2.2 String - >包装类

//String - >包装类
//方式一
Integer j = new Integer(s1);
//方式二
Integer j2 = Integer.valueOf(s2);
//方式三
Integer j3 = Integer.parseInt(s3);

3. Integer类常用方法

1 2	System.out.println(Integer.MIN_VALUE);//返回最小值 System.out.println(Integer.MAX_VALUE);//返回最大值

4. Character类常用方法

System.out.println(Character.isDigit('a'));//判断是不是数字
System.out.println(Character.isLetter('a'));//判断是不是字母
System.out.println(Character.isUpperCase('a'));//判断是不是大写
System.out.println(Character.isLowerCase('a'));//判断是不是小写
System.out.println(Character.isWhitespace('a'));//判断是不是空格
System.out.println(Character.toUpperCase('a'));//转成大写
System.out.println(Character.toLowerCase('A'));//转成小写

二、String类

1. 定义

String 对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起来的字符序列，如”你好”
字符串的字符常用Unicode编码，一个字符(不区分字母还是汉字)占两个字节
String 类常用的构造方法：

String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndext, int count);

String 是final类不能被继承
String 有属性 private final char value[]; 用于存放字符串内容
value 是一个final类型，不能被修改：即value不能指向新的地址，但是单个字符内容可以变化

String name = "jack";
name = "tom";
final char[] value = {'a', 'b', 'c'};
char[] v2 = {'t', 'o', 'm'};
value[0] = 'H';
//value = v2; 错误 不可以修改value的地址

2. 创建String 对象

2.1 直接赋值

1	String s = "执笔";

先从常量池查看是否有”执笔” 数据空间，如果有，直接指向；没有就从新创建，然后指向。s最终指向的是常量池的空间地址

2.2 调用构造器

1	String s2 = new String("执笔");

先在堆中创建空间，里面维护了value属性，指向常量池的执笔空间，如果常量池没有“执笔”，重新创建；如果有，直接通过value指向。最终指向的是堆中的空间地址

2.3 字符串的特性

String 是一个final类，代表不可变的字符序列
字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的
intern()方法指向对应字符串的常量池

3. 常用方法

第一组

equals //区分大小写，判断内容是否相等
equalslgnoreCase//忽略大小写的判断内容是否相等
length//获取字符的个数，字符串的长度
indexOf //获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1
lastIndexOf//获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1
substring//截取指定范围的子串
trim//去前后空格
charAt//获取某索引处的字符,注意不能使用Str[index]这种方式.

//1. equals 区分大小写，判断内容是否相等
String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equals(str2));

//2. equalsIgnoreCase 忽略大小写的判断内容是否相等
String username = "john";
if("john".equalsIgnoreCase(username)){
	System.out.printin("sucess! ");
}else{
	System.out.println( "Failure ! ");
}

//3. length获取字符的个数，字符串的长度
System.out.println("执笔".length());

//4. index0f 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到就返回-1 
String s1 = "wer@terwe@g";
int index = s1.indexOf( '@');
system.out.println(index); // 3
System.out.println("weIndex=" + s1.indexOf("we"));//0

// 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
s1 = "wer@terwe@g@";
index = s1.lastIndexOf( ' @');
System.out.println(index);//11
System.out.println("ter的位置=" + s1.lastIndexOf( "ter "));//4

// 6.substring截取指定范围的子串
string name = "hello,张三";
//下面name.substring(6)从索引6开始截取后面所有的内容
System.out.println(name.substring(6));//截取后面的字符
//name.substring(0,5)表示从索引@开始截取，截取到索引5-1=4位置
System.out.println(name.substring(2,5));//llo

第二组

toUpperCase//转换成大写
toLowerCase//转换成小写
concat//拼接字符串
replace//替换字符串中的字符
split//分割字符串，对于某些分割字符，如| \\
compareTo //比较两个字符串的大小
toCharArray //转换成字符数组
format //格式字符串，%s字符串 %c字符 %d整型 %.2f浮点型

//1. toUpperCase转换成大写
String s = "heLLo";
System.out.println(s.toUpperCase();//HELLO
                   
//2. toLowerCase 转换成小写
System.out.println(s.toLowerCase();//hello
                   
//3. concat拼接字符串
String s1 ="宝玉";
s1 = s1.concat("林黛玉").concat("薛宝钗").concat( "together");
System.out.println(s1);//宝玉林黛玉薛宝钗
                   
//4. replace替换字符串中的字符
s1 ="宝玉 and 林黛玉林黛玉林黛玉";
//在s1中，将 所有的林黛玉替换成薛宝钗
// s1.replace()方法执行后，返回的结果才是替换过的,注意对s1没有任何影响
String s11 = s1.replace("宝玉","jack");
System.out.printLn(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
System.out.printin(s11);//jack and 林黛玉 林黛玉 林黛玉

//5. split分割字符串，对于某些分割字符，我们需要转义比如| \\等
String poem =“锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
//(1) 以，为标准对 poem进行分割，返回一个数组
//(2) 在对字符串进行分割时，如果有特殊字符，需要加入转义符 \
String[] split = poem.split(" , ");
poem = "E:\\laaa\\bbb";
split =poem.split("\\\\");
// string[] split = poem.split("\\\\ ");
System.out.println("==分割后内容===");
for (int i = 0; i< split.length; i++) {
	System.out.println(split[i]);
}
                   
//6. toCharArray 转换成数组
s = "happy";
char[] chs = s.toCharArray();
for(int i = 0; i < chs.length; i++) {
    System.out.println(chs[i]);
}
                   
//7. compareTo 比较两个字符串的大小，如果前者大，则返回正数，后者大，则返回负数，如果相等，返回0
//(1) 如果长度相同，并且每个字符也相同，就返回0
//(2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
//		就返回if (c1 != c2) {
//				return c1 - c2;
//			 }
//(3) 如果前面的部分都相同，就返回str1.len - str.len
String a = "jcck";// len = 3
String b = "jack"; // len = 4
System.out.println(a.compareTo(b));//返回值是'c' - 'a' =2的值
                   
//8. format //格式字符串，%s字符串 %c字符 %d整型 %.2f浮点型
//(1) %s, %d , %.2f %c称为占位符
//(2) 位符由后面变量来替换
//(3) %s 表示后面由字符串来替换
//(4) %d是整数来替换
//(5) %.2f 表示使用小数来替换，替换后，只会保留小数点两位，并且进行四舍五入的处理
//(6) %c使用char类型来替换
String formatStr = "我的姓名是%s年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我!";
String info2 = String.format(formatstr，name,age，scdre,gender);
system.out.println( "info2=" + info2);

三、StringBuffer

1. 介绍

java.lang.StringBuffer代表可变的字符序列,可以对字符串内容进行增删
很多方法与String相同，但StringBuffer是可变长度的
StringBuffer是一个者器
StringBuffer是final类
实现了Serializable接口，可以保存到文件，或者网络传输
继承了抽象类AbstractStringBulider，AbstractStringBulider属性char[] value 存放的字符序列

//1. StringBuffer的直接父类是 AbstractStringBuilder
//2. StringBuffer实现了Serializable, 即StringBUffer的对象可以串行化
//3．在父类中 AbstractStringBuilder有属性 char[] value ,不是final；该value 数组存放字符串内容
//4. StringBuffer是一个 final类，不能被继承
//5，因为StringBuffer字符内容是存在 char[] value，所有在变化(增加/删除)；不用每次都更换地址(即不是每次创建新对象)，所以效率高于String]
StringBufferstringBuffer = new StringBuffer( "hello");

2. String 和 StringBuffer对比

String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低
StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高

3. 构造器

//1. 创建一个大小为16的char[] ,用于存放字符内容
StringBuffer stringBuffer = new StringBuffer() ;
//2. 通过构造器指定char[] 大小
StringBuffer stringBuffer1 = new StringBuffer(100);
//3. 通过给一个String 创建StringBuffer, char[] 大小就是str.Length() + 16
StringBuffer hello = new StringBuffer("heLlo");

4. String 和 StringBuffer互相转换

4.1 String —> StringBuffer

//String --> StringBuffer
String str = "hello tom";
//方式1使用构造器
//注意：返回的才是StringBuffer对象，对str本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式2使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);

4.2 StringBuffer —> String

//StringBuffer ->String
StringBuffer stringBuffer3 = new StringBuffer("执笔");
//方式1：使用StringBuffer提供的toString方法
String s = stringBuffer3.toString();
//方式2：使用构造器
String s1 = new String(stringBuffer3);

5. 常用方法

1) append//增加
2) delete(start,end)//删除
3) replace(start,end,string)//修改，将start----end间的内容替换掉,不含end
4) indexOf //查找子串在字符串第1次出现的索引,如果找不到返回-1
5) insert//插入
6) length//获取长度

StringBuffer s = new StringBuffer("hello");
//增加
s.append(',');//"hello,"
s.append("你好");//"hello,你好"
s.append("执笔").append(true).append(10);//"hello,你好执笔true10"

//删除 索引为 >= strat && <end处的字符
//删除 5~8的字符
s.delete(5,8);
System.out.println(s);//"hello,执笔true10"

//修改
//使用jack替换索引9-12的字符[9,12)
s.replace(9,12,"jack");
System.out.println(s);//"hello,执笔jack10"

//查找子串在字符串第1次出现的索引,如果找不到返回-1
int indexOf = s.indexOf("执笔");
System.out.println(indexOf);//6

//插入
//在索引为6的位置插入 "你好" 原来索引为6的内容自动后移
s.insert(6,"你好");
System.out.println(s);//"hello,你好执笔jack10"
//长度
System.out.println(s.length);//16

四、StringBuilder

1. 介绍

StringBuilder 继承AbstractStringBuilder 类
实现了Serializable，说明StringBuilder对象是可以串行化(对象可以网络传输，可以保存到文件)
StringBuilder 是final类，不能被继承
StringBuilder 对象字符序列仍然是存放在其父类AbstractStringBuilder的 char[] vaLue；因此，字符序列是堆中
StringBuilder 的方法，没有做互斥的处理,即没有synchronized 关键字，因此在单线程的情况下使用

1	StringBuilder stringBuilder = new StringBuilder();

2. String、StringBuffer、StringBuilder比较

StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
2) String：不可变字符序列，效率低，但是复用率高
3) StringBuffer：可变字符序列、效率较高(增删)、线程安全
4) StringBuilder：可变字符序列、效率最高、线程不安全
String使用注意说明：
- string s=”a”; //创建了一个字符串
- s += “b”; //实际上原来的” a”字符串对象已经丢弃了，现在又产生了一个字符串s+ “b” (也就是”ab”)。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能=>结论：如果我们对String做大量修改，不要使用String

3. String、StringBuffer、StringBuilder的选择

如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder
如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder
如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer
如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等

五、Math类

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

1. 方法

1) abs//绝对值
2) pow//求幂
3) ceil//向上取整
4) floor//向下取整
5) round//四舍五入
6) sqrt//求开方
7) random//求随机数
8) max//求两个数的最大值
9) min//求两个数的最小值

public class MathMethod {
    public static void main(String[] args) {
        //1.abs绝对值
        int abs = Math.abs(9);
        System.out.println(abs);
        //2.pow求幂
        double pow = Math.pow(-3.5,4);
        System.out.println(pow);
        //3.ceil向上取整,返回>=该参数的最小整数(转成double);
        double ceil = Math.ceil(-3.0001);
        System.out.println(ceil);
        //4.floor向下取整，返回<=该参数的最大整数(转成double)
        double floor = Math.floor(-4.999);
        System.out.println(floor);
        //5.round四舍五入Math.floor(该参数+0.5)
        long round = Math.round(-5.001);
        System.out.println(round);
        //6.sqrt求开方
        double sqrt = Math.sqrt(-9.0);
        System.out.println(sqrt);

        //7.random返回随机数[0—1)
        //获取a-b之间的一个随机整数，a,b均为整数(2,7)
        //1、先取左边 = a：(int)a
        //2、[a-b):int num = (int)(Math.random()*(b-a+1) +a)
        double random = Math.random();
        System.out.println(random);
        for (int i = 0; i < 10; i++) {
            System.out.println((int)(2 + Math.random() * (7 - 2 + 1)));
        }

        //max min返回最大值 和最小值
        int min = Math.min(1, 9);
        int max = Math.max(5, 9);
        System.out.println(min);
        System.out.println(max);
    }
}

六、Arrays类

1. 方法

//(1) toString 返回数组的字符串形式
Arrays.toString(arr);
//(2) sort排序(自然排序和定制排序)
Integer arr[] = {1,-1,7,0,89}
//(3) binarySearch通过二分搜索法进行查找，要求必须排好序
int index = Arrays.binarySearch(arr,3);
//(4) copyOf数组元素的复制
Integer[] newArr = Arrays.copyOf(arr,arr.length);
//(5) fill数组元素的填充
Integer[] num = new Integer[]{9,3,2};
Arrays.fill(num,99);
//(6) equals比较两个数组元素的内容是否完全一致
boolean equals = Arrays.equals(arr,arr2);
//(7) asList将一组值，转换成list
List<Integer> asList = Arrays.asList(2,3,4,5,6);

public class ArraysMethod02 {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 6, 89};

        //1、使用binarySearch 二叉查找
        //2、要求数组是有序的 ；无序不能使用
        //3、如果数组中不存在该元素，就返回 return -(low + 1); //key not found;
             //即为该元素应该存在的位置 - 1 取负数
        int index = Arrays.binarySearch(arr, 99);
        System.out.println("index= " + index);


        //copyOf 数组元素的复制

        //1、如果拷贝的长度 > arr.length 就在新数组的后面 增加null
        //2、如果拷贝的长度 < 0 就抛出异常NegativeArraySizeException
        Integer[] newArr = Arrays.copyOf(arr, arr.length - 1);
        System.out.println(Arrays.toString(newArr));

        //fill 数组元素的填充
        //1、使用9去填充数组 即为替换原来的元素
        Integer[] num = new Integer[]{2, 5, 3};
        Arrays.fill(num, 9);
        System.out.println("====填充后的数组====");
        System.out.println(Arrays.toString(num));

        //equals 比较两个数组的内容是否一致
        //1、相等为true 不相等为false
        Integer[] arr2 = {1, 2, 6, 89};
        boolean equals = Arrays.equals(arr, arr2);
        System.out.println("比较后的数组：" + equals);

        //asList 将一组值，转成list
        //1、asList 方法 会将(2, 3, 4, 5, 6)数据转成一个List集合
        //2、返回的asList 编译类型 List(接口)
        //3、运行类型 java.util.Arrays$ArrayList 是Arrays类的静态内部类

        List asList = Arrays.asList(2, 3, 4, 5, 6);
        System.out.println("asList= " + asList);
        System.out.println("asList的运行类型：" + asList.getClass());
    }
}

2. 排序

public class ArraysSortCustom {
    public static void main(String[] args) {
        int[] arr = {1, 5, -1, 9};
        bubble01(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //向上转型 自动拆箱 Integer 转成int 类型
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        System.out.println(Arrays.toString(arr));
    }

    //冒泡排序
    public static void bubble02(int[] arr) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //从小到大排序
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    //冒泡排序 + 定制
    public static void bubble01(int[] arr, Comparator c) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //从小到大排序
                if (c.compare(arr[j], arr[j + 1]) > 0) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

}

七、System类

1. 方法

(1) exit//退出当前程序
(2) arraycopy//复制数组元素，适合底层使用，一般使用Arrays.copyOf完成数组复制
	int[] src = {1,2,3};
	int[] dest = new int[3]
    System.arraycopy(src,0,dest,0,3);
(3) currentTimeMillens//返回当前时间距离1970-1-1的毫秒数
(4) gc//运行垃圾回收机制 System.gc();

//exit
//1. exit(0) 表示程序退出
//2. 0表示一个状态，正常的状态
System.exit(0);

//源数组

//* @param src the source array .
// srcPos: 从源数组的哪个索引位置开始拷贝
//* @param srcPos starting position in the source array 。
// dest:目标数组，即把源数组的数据拷贝到哪个数组
//* @param dest the destination array .
// destPos:把源数组的数据拷贝到目标数组的哪个索引
//* @param destPos starting position in the destination data 。
//Length:从源数组拷贝多少个数据到目标数组
//* @param Length the number of array eLements to be copied.
System.arraycopy(src, 0,dest, 0, src.Length);
// int[] src={1,2,3};
System.out.printLn("dest=" + Arrays.toString(dest));//[0, 2, 3]

八、BigInteger BigDecimal类

BigInteger适合保存比较大的整型
BigDecimal适合保存精度更高的浮点型(小数)

1. 方法

add//加
subtract//减
multiply//乘
divide//除

BigInteger b1 = new BigInteger(" 1234567890");
BigInteger b2 = new BigInteger(" 200");
// 2.调用常见的运算方法
// System.out.println(b1+ b2);不能使用这样的+方法运行
System.out.println(b1.add(b2));//加
System.out.println(b1.subtract(b2));//减
System.out.println(b1.multiply(b2));//乘
System.out.println(b1.divide(b2));//除

BigDecimal b1 = new BigDecimal("1234567890.567");
BigDecimal b2 = new BigDecimal("123");
// 2.调用常见的运算方法
// System.out.println(b1 + b2);不能使用+号运算.
System.out.println(b1.add(b2));//加
System.out.println(b1.subtract(b2));//减
System.out.println(b1.multiply(b2));//乘
//后面这个BigDecimal.ROUND CEILING 需要指定，是精度
//没有这个参数，则会提示:错误
System.out.println(b1.divide(b2, BigDecimal.ROUND_CEILING);// 除

九、日期类

1. 第一代日期类

Date：精确到毫秒，代表特定的瞬间
SimpleDateFormat：格式和解析日期的类，允许进行格式化(日期 - > 文本)，解析(文本 - > 日期)和规范化

public class Date01 {
    public static void main(String[] args) throws ParseException {

        //1、这里的Date 类在java.util包

        Date date = new Date();//获取当前日期
        System.out.println("当前日期：" + date);

        Date date1 = new Date(123456);//通过毫秒数来指定时间
        System.out.println("date1=" + date1);

        //1、创建SimpleDateFormat对象 可以指定相应的格式
        //2、格式字母是规定好的
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        String format = sdf.format(date);//format：将日期转换成指定的格式
        System.out.println("转换后的时间：" + format);

        //1、可以把一个格式化的String 转成相应的Date
        //2、得到Date 默认为国外的格式 指定输出需要转换
        String s = "2022年01月18日 21:35:30 星期二";
        Date parse = sdf.parse(s);
        System.out.println("字符串转换后的时间：" + parse);
    }
}

2. 第二代日期

主要是Calendar（日历）

1 2	public abstract class Calendar extends Object implements Serializable, Cloneable, Comparable < Calendar >

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY OF MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(例如获得下星期的日期)提供了一些方法。

Calendar C = Calendar.getInstance(); //创建日历类对象//比较简单，自由
System.out.println(c);
//2.获取日历对象的某个日历字段
System.out.println("年: "+c.get(Calendar.YEAR));
System.out.println("月: "+(c.get(Calendar.MONTH)+1));
System.out.println("日: "+c.get(Calendar.DAY_ OF_MONTH));
System.out.println("小时: "+c.get(Calendar.HOUR));
System.out.println("分钟: "+c.get(Calendar.MINUTE));
System.out.println("秒: "+c.get(Calendar.SECOND));
//Calender没有专门的格式化方法，所以需要程序员自己来组合显示
System.out.println(c.get(Calendar.YEAR) + "年" + (c.get(Calendar.MONTH)+1) +"月" + C.get(Calendar.DAY OF MONTH)+"日");

3. 第三代日期类

1. 方法

(1) LocalDate//获取日期字段
(2) LocalTime//获取时间字段
(3) LocalDateTime//获取日期和时间字段
(4) DateTimeFormatter//格式日期类
    DateTimeFormat dft = DateTimeFormatter.ofPattern(格式);
	String str = dtf.format(日期对象);
(5) Instant//时间戳
//Instant-->Date
	Date date = Date.from(instant);
//Date-->Instant
	Instant instant = date.toInstant();
//案例
//1. 通过静态方法now()获取表示当前时间戳的对象
Instant now = Instant.now();
System.out.printLn(now);
//2. 通过from 可以把Instant转成Date
Date date = Date.from(now);
//3. 通过date的toInstant() 可以把date转成Instant对象
Instant instant = date.toIhstant();
(6) MonthDay//类检查重复事件
(7) plus()//测试增加时间的某个部分
(8) minus()//查看一年前和一年后的日期

一、包装类

1. 基本数据类型的包装类

2. 包装类和基本数据类型转换

2.1 int <——> Integer

2.1.1 手动装箱

2.1.2 自动装箱

2.2 String 和 包装类

2.2.1 包装类型 -> String

2.2.2 String - >包装类

3. Integer类常用方法

4. Character类常用方法

二、String类

1. 定义

2. 创建String 对象

2.1 直接赋值

2.2 调用构造器

2.3 字符串的特性

3. 常用方法

第一组

第二组

三、StringBuffer

1. 介绍

2. String 和 StringBuffer对比

3. 构造器

4. String 和 StringBuffer互相转换

4.1 String —> StringBuffer

4.2 StringBuffer —> String

5. 常用方法

四、StringBuilder

1. 介绍

2. String、StringBuffer、StringBuilder比较

3. String、StringBuffer、StringBuilder的选择

五、Math类

1. 方法

六、Arrays类

1. 方法

2. 排序

七、System类

1. 方法

八、BigInteger BigDecimal类

1. 方法

九、日期类

1. 第一代日期类

2. 第二代日期

3. 第三代日期类

1. 方法

执笔

2.2 String 和包装类