包装类（wrapper）
八大基本数据类型的封装类：
- boolean—>Boolean
- char—>Character
- byte–>Byte
- int–>Integer
- long–>Long
- float–>Float
- double–>Double
- short–>Short
装箱和拆箱:
jdk5以前的都是手动装箱和拆箱。jdk5以后是自动装箱和拆箱。
自动装箱底层调用的是valueOf方法。比如，Integer.valueof(),其他包装类的用法类似。
Integer包装类：
public class Wrapper01 {
public static void main(String[] args) {
Integer integer = new Integer(1);//通过new出来的都是新的对象。
Integer integer1 = new Integer(1);
System.out.println(integer==integer1);//false
Integer i=1;//自动调用valueOf方法。
Integer j=1;//自动调用valueOf方法。
System.out.println(i==j);//true
Integer i1=128;
Integer j2=128;
System.out.println(i1==j2);//false
}
}
//valueOf方法。
//This method will always cache values in the range -128 to 127,
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
通过底层代码可知，在通过valueOf方法创建对象时，如果数值在-128-127之间，便返回IntegerCache.cache中已经存在的对象引用；否则创建一个新的对象。
Integer i2=127;
int j3=127;
System.out.println(i2==j3);//true.
只要有基本数据类型，则判断的是数值是否相等。
String
-
String对用于保存字符串，也就是一组字符序列。
-
String类有很多构造器，例如：
String s=new String(String original); String s1=new String(char[] a); String s2=new String(char[] a,int starIndex,int count); String s3=new String(byte[] b); -
String实现了接口Serializable,可以在网络传输。
-
String是final类，不能被其他类继承。
-
String有属性private final char value[] ，用于存放字符串内容。
-
value是一个final类型，不可以修改，即: 地址是不能修改的，但是单个字符内容是可以变化的。
两种创建String的区别：
方式一：String n1=“zhang”;
方式二：String n2=new String(“zhang”)；
第一种方式先从常量池中看是否有"zhang"的数据空间，如果有直接指向，如果没有则要创建然后指向。n1最终指向的是常量池的地址。
第二种方式先在堆中创建空间，指向常量池的的zhang空间，如果常量池没有，则重新创建，如果有直接通过value指向，最终指向的是堆中的空间。
例题：
String n3="zhang";//指向常量池。
String n4 = new String("zhang");//指向堆中对象。
System.out.println(n3.equals(n4));//true.
System.out.println(n3==n4);//false。
System.out.println(n3==n4.intern());//true
注意：b4.intern()方法最终返回的是常量池的地址。
面试题：
String是一个final类，代表不可变的字符序列。
String n1="hello";
n1="hi";
//先后在常量池中创建了"hello"对象和"hi"对象，最终n1指向的是"hi"对象。
String a="hello";
String b="abc";
//先创建一个StringBulider sb=new StringBuilder();
//执行 sb.append("hello"),在执行sb.append("abc")。
//String c=sb.toString(查看底层发现其实toString方法是new了一个新的对象。)
//最后c指向堆中的对象，对象中的value指向常量池中的"helloabc".
String c=a+b;
注意：String c=a+b;
String c=“hello”+“abc”;
两者区别: 前者是变量相加,看的是堆，后者是常量相加，看的是池。
public class StringExercise02 {
public static void main(String[] args) {
Test ex = new Test();
ex.change(ex.str,ex.ch);//调方法会产生一个新栈，当方法调用完毕就被销毁了。
System.out.print(ex.str+" and"+"\t");
System.out.print(ex.ch);
}
}
class Test{
String str=new String("hsp");
final char[] ch={'j','a','v','a'};
public void change(String str,char[] ch){
str="java";
ch[0]='h';
}
}
//hsp and hava
内存分布图如下:
String类的常用方法：
String s=new String("zhangz");
System.out.println(s.equalsIgnoreCase("ZHANG"));//大小写。false;
System.out.println(s.charAt(1));//获取某索引处的字符。h
System.out.println(s.indexOf("z"));//获取字符在字符串中第一次出现的索引位置。0
System.out.println(s.lastIndexOf("z"));//获取字符在字符串中最后出现的索引位置。5
System.out.println(s.substring(1));//截取索引后面的字符：hangz
System.out.println(s.substring(0,4));//从第0个开始截，截到第三个。zhan
String s="zhang";
System.out.println(s.toUpperCase());//转化成大写。ZHANG
System.out.println(s.toLowerCase());//转化成小写。zhang
System.out.println(s.concat("jian").concat("handsome").concat("great"));
//字符串拼接。zhangjianhandsomegreat
System.out.println(s.replace("zhang","jian"));//替代。jian
System.out.println("===================");
String poem="锄禾日当午，汗滴禾下土，谁之盘中餐，粒粒皆辛苦";
String[] split = poem.split("，");//分割字符串。以","为标准分割。
for (String s1 : split) {
System.out.println(s1+"\t");
}
String n="\\aaa\\bbb\\ccc\\ddd";
String[] split1 = n.split("\\\\");//在对字符串进行分割时，如果有特殊字符，需要加入转义字符"\"
for (String s1 : split1) {
System.out.println(s1);
}\\aaa
\\bbb
\\ccc
\\ddd
String s1="zhang";
char[] chars = s1.toCharArray();//转化成字符数组。
for (char aChar : chars) {
System.out.println(aChar);
}
String n1="zhnge";
String n2="zhang";
System.out.println(n1.compareTo(n2));//比较两个字符串的大小，如果长度相同，并且每个字符串都相同，就返回零；如果长度不相同或者相同，在进行比较时，当出现第一个不相同的字符时，ASCII值相减即为结果;如果前面的部分相同，就返回n1.length-n2.length
String name="张瑊";
int age=21;
double score=99.0;
char gender='男';
String format = String.format("我的名字是：%s ,年龄是：%d ,得分是：%.2f ,性别是：%c", name, age, score, gender);
//%s,%d,%.2f，%c,这些都称之为占位符，由后面的变量替代，%s表示后面由字符串替代，%d是整数替代，%.2f表示使用小数替代，保留两位小数，并且进行四舍五入。%c使用char类型替代。
System.out.println(format);
StringBuffer类
StringBuffer的直接父类是AbstractStringBuilder。
StringBuffer实现了Serializable,即对象可以串行化。
在父类中AbstractStringBuilder有属性char[] value,不是final,该value存放的字符串内容存放在栈中。
StringBuffer是一个final类，不能被继承。
例题：
//小数点的前面每三位用逗号隔开。
public static void main(String[] args) {
String s = "121343455.44";
StringBuffer stringBuffer = new StringBuffer(s);
for (int i1 = stringBuffer.lastIndexOf(".") - 3; i1 > 0; i1 -= 3) {
stringBuffer.insert(i1, ",");
}
System.out.println(stringBuffer);
}
String和StringBuffer对比：
String保存的是字符串常量，里面的值不能修改，每次String的更新实际上就是更该地址，效率比较低。
//private final char[] value 指向常量池。
StringBuffer保存的是字符串变量，里面的值可以修改，每次StringBuffer的更新是内容更新，不用更改地址，效率较高。
//char[] value 指向堆。
String和StringBuffer转换：
//String转StringBuffer
String s="zhang";
//1.使用构造器。
StringBuffer stringBuffer = new StringBuffer(s);
//2.使用append方法。
StringBuffer stringBuffer1 = new StringBuffer().append(s);
//StringBuffer转String。
StringBuffer stringBuffer2 = new StringBuffer("张瑊不帅");
//1.使用toString方法创建。
String string = stringBuffer2.toString();
//2.使用构造器。
String s1 = new String(stringBuffer2);
StringBuffer的常用方法：
StringBuffer stringBuffer = new StringBuffer("张瑊");
//添加。
stringBuffer.append(",");
stringBuffer.append("超级帅。");
stringBuffer.append("没错。");
System.out.println(stringBuffer);
//删除。删除[0,2)之间的字符。
stringBuffer.delete(0,2);
System.out.println(stringBuffer)；
//替换。[0,2)
stringBuffer.replace(0,2,"陈冠希");
System.out.println(stringBuffer);
//查找指定的字串第一次在字符串中出现的索引。如果找不到,就返回-1；
System.out.println(stringBuffer.indexOf("冠希"));
//指定位置插入
System.out.println(stringBuffer.insert(0, "吴彦祖，"));
//返回长度。
System.out.println(stringBuffer.length());
}
StringBuilder类
- StringBulider继承了AbstractStringBuilder类。
- 实现了Serializable,说明StringBulider对象可以串行化。
- StringBuilder是final类，不能被继承。
- StringBulider对象字符序列仍然是保存在父类的char[] value 中。
- StringBulider因为没有synchronized关键字，因此在单线程的情况下使用。
StringBuffer,StringBuilder和String的比较：
- StringBuffer和StringBuilder均为可变字符序列，而且方法也一样。
- String:不可变字符序列，效率低，但是复用率高。
- StringBuffer:可变字符序列，效率高，线程安全。
- StringBuilder:可变字符序列，效率高，线程不安全。
Math常用方法：
int abs = Math.abs(-34);//求绝对值。
System.out.println(abs);
double pow = Math.pow(2,4);//幂
System.out.println(pow);
double ceil = Math.ceil(-1.89);//向上取整。
System.out.println(ceil);
double floor = Math.floor(-4.49);//向下取整。
System.out.println(floor);
long round = Math.round(1.2);//四舍五入。
System.out.println(round);
double sqrt = Math.sqrt(4);//求开方。
System.out.println(sqrt);
for (int i = 0; i < 10; i++) {
System.out.println((int)(2+Math.random()*6));//求随机数，返回的是[2,8)上的数。
}
System.out.println(Math.max(2,3));
System.out.println(Math.min(2,3));
重点：随机数random()
Arrays类：
Integer[] array={1,22323,4,524,50};
System.out.println(Arrays.toString(array));//显示数组。
Arrays.sort(array);//排序数组。
System.out.println(Arrays.toString(array));//再次输出。
//二分查找数组的某个数的索引，数组必须有序。如果数不存在，则返回的是 //return -(low+1)。
Integer[] integer={1,3,4,5,};
int i = Arrays.binarySearch(integer, 1);
System.out.println("index="+i);
Integer[] array={1,2,34,324,34};
Integer[] integers =Arrays.copyOf(array,array.length);//数组复制。
System.out.println(Arrays.toString(integers));
Integer[] array={1,2,34,324,34};
Arrays.fill(array,10);//数组的填充。
System.out.println(Arrays.toString(array));
boolean equals=Arrays.equals(array,integers);//比较两个数组的元素是否一样，是，返回true,否，返回false。
System.out.println(equals);
例题：
public static void main(String[] args) {
Book[] books = new Book[4];
books[0]=new Book("红楼梦",100);
books[1]=new Book("新金瓶梅",90);
books[2]=new Book("新青年文摘",5);
books[3]=new Book("java从入门到放弃",300);
Arrays.sort(books, new Comparator<Book>() {
@Override
//重写compare方法，如果想改变排序方式直接修改return的值。
public int compare(Book o1, Book o2) {
int priceVal= o2.getPrice()-o1.getPrice();
if(priceVal>0){
return 1;
}else if(priceVal<0){
return -1;
}else {
return 0;
}
}
});
System.out.println(Arrays.toString(books));
System.out.println("=====================");
Arrays.sort(books, new Comparator<Book>() {
@Override
public int compare(Book o1, Book o2) {
return o1.getName().length()-o2.getName().length();
}
});
for (int i = 0; i <books.length ; i++) {
System.out.println(books[i].toString());
}
}
}
class Book{
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
private String name;
private int price;
@Override
public String toString() {
return "书名为："+ name + '\'' +
", 价格为：" + price ;
}
public Book(String name, int price) {
this.name = name;
this.price = price;
}
}
System类：
long l = System.currentTimeMillis();//当前时间
Integer[] integers={1,2,4,5};
Integer[] integers1 = new Integer[3];
//原数组从第一个元素，新数组第一个元素，复制3个
System.arraycopy(integers,0,integers1,0,3);
System.out.println(Arrays.toString(integers1));
BigInteger 类
当数据较大时，用BigInteger进行计算。
BigInteger bigInteger = new BigInteger("200000000000");
BigInteger bigInteger1 = new BigInteger("100000000000");
//相加
BigInteger add = bigInteger.add(bigInteger1);
System.out.println(add);
//相减
BigInteger subtract = bigInteger.subtract(bigInteger1);
System.out.println(subtract);
//相除
BigInteger divide = bigInteger.divide(bigInteger1);
System.out.println(divide);
//相乘。
BigInteger multiply = bigInteger.multiply(bigInteger1);
System.out.println(multiply);
BigDecimal类
当小数数据较大时，用BigDecimal类，
BigDecimal bigDecimal = new BigDecimal("1.2222222222222222222222222");
BigDecimal bigDecimal1 = new BigDecimal("7");
//相加
System.out.println(bigDecimal.add(bigDecimal1));
//相减
System.out.println(bigDecimal.subtract(bigDecimal1));
//相乘
System.out.println(bigDecimal.multiply(bigDecimal1));
//相除。如果无限循环，则在方法里面写BigDeciaml.ROUND_CEILING,即保留除数的位数。
System.out.println(bigDecimal.divide(bigDecimal1,BigDecimal.ROUND_CEILING));
Date类(第一代日期类)
Date date = new Date();
System.out.println(date);
//创建simpleDateFormat对象，可以指定相应的格式，不能乱写。
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss");
String format = simpleDateFormat.format(date);
System.out.println(format);//2021年10月29日 星期五 16:18:03
System.out.println("=================");
//将字符串转化成日期。
//得到的date仍然是国外的形式，需要转化输出。
//如果simpleDateFormat的格式和String的格式不一样，需要抛转换异常。
String s="2024年10月29日 星期五 16:14:54";
Date parse = simpleDateFormat.parse(s);
System.out.println(simpleDateFormat.format(parse));
System.out.println("================");
//通过指定的毫秒数得到时间
Date date1 = new Date(123456);
System.out.println(simpleDateFormat.format(date1));//1970年01月01日 星期四 08:02:03
}
Calendar 类（第二代日期类）
Calendar类是一个抽象类，并且构造器时private因此要调用getInstance方法获取实例。
Calendar类没有提供对应的格式化，需要程序员自己写格式化。
Calendar instance = Calendar.getInstance();
//获取年份
System.out.println(instance.get(Calendar.YEAR));
//获取月份+1
System.out.println(instance.get(Calendar.MONTH)+1);
//获取第几天。
System.out.println(instance.get(Calendar.DAY_OF_MONTH));
//获取小时数。
System.out.println(instance.get(Calendar.HOUR));
//获取分钟数。
System.out.println(instance.get(Calendar.MINUTE));
//自己写日期格式：
System.out.println(instance.get(Calendar.YEAR)+"-"+(instance.get(Calendar.MONTH)+1)+"-"+instance.get(Calendar.DAY_OF_MONTH)+"\t"+instance.get(Calendar.HOUR_OF_DAY)+":"+instance.get(Calendar.MINUTE)+":"+instance.get(Calendar.SECOND));//2021-10-30 13:1:18
（常用）LocalDateTime类（第三代日期类）
LocalDateTime now = LocalDateTime.now();
System.out.println(now);//获取当前日期。
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 E HH:mm:ss");//格式日期。
String format = dateTimeFormatter.format(now);
System.out.println(format);
//一年后的时间。
LocalDateTime localDateTime = now.plusYears(1);
//一年前的时间。
LocalDateTime localDateTime1 = now.minusYears(1);
System.out.println("一年前："+dateTimeFormatter.format(localDateTime1));
System.out.println("一年后："+dateTimeFormatter.format(localDateTime));
习题：
将字符串中指定部分进行反转。
public static void main(String[] args) {
String s = "abcdef";
System.out.println(reverse(s, 1, 4));//aedcbf
}
public static String reverse(String s, int start, int end) {
if(!(s!=null&&start>=0start<end&&end>start&&end<s.length())){
throw new ArrayIndexOutOfBoundsException("参数不正确。");
}
char[] chars = s.toCharArray();
char temp;
for (int i = start, j = end; i < j; i++, j--) {
temp = chars[i];
chars[i] = chars[j];
chars[j] = temp;
}
return new String(chars);
}