常用类
讲解内容
包装类
String
StringBuffer、StringBuilder
包装类
包装类就是把基本数据类型封装到一个类中，并提供属性和方法方便未来操作该基本数据类型。
包装类位于java.lang包中。包装类的出现不是为了取代基本数据类型。继承结构
Number
Number 抽象类是所有数值类型(Byte、Short、Integer、Long、Float、Double)的抽象父类。并提供了把包装类转换成基本数据类型的抽象方法。
Integer
Integer 类在对象中包装了一个基本类型 int 的值，类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法.
常用属性方法
[1]静态属性
|
// Integer 静态属性
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
|
[2] 构造方法
|
public class Test01 {
public static void main(String[] args) {
// 构造方法
Integer i1 = new Integer(10);
System.out.println(i1.toString());
// 传递"abc"参数会产生NumberFormatException
Integer i2 = new Integer("123");
System.out.println(i2.toString());
}
}
|
常用方法
[1] xxxValue()把包装类转化成对象的xxx 基本数据类型。例如intValue()
|
Integer i1 = new Integer(10);
System.out.println(i1.intValue());
|
[2]Comparable 接口
Comparable 用于实现类对象的比较，比较此对象与指定对象的顺序。其定义的m.compareTo(n)方法返回一个int类型，表示
|
比较对象
|
比较结果
|
结论
|
|
m < n
|
负整数(-1)
|
升序
|
|
m == n
|
0
|
相等
|
|
m > n
|
正整数(1)
|
降序
|
|
public static void main(String[] args) {
Integer i1 = new Integer(20);
// System.out.println(i1.intValue());
Integer i2 = new Integer("20");
// 【1】compareTo
int r = 0;
r = i1.compareTo(i2);
System.out.println(r);
// 【2】equals
System.out.println(i1.equals(i2));
// 【3】compare
System.out.println(Integer.compare(10, 20));
}
|
[3] 把字符串转化成基本数据类型
|
public class Test03 {
public static void main(String[] args) {
// Integer i1 = new Integer(10);
// 10默认被指定为十进制
int a = Integer.parseInt("10");
// 1111被指定为二进制字符串
int b = Integer.parseInt("1111",2);
System.out.println(b);
}
}
|
[4] 把基本数据类型转化成字符串
|
public static void main(String[] args) {
// 把基本数据类型转化成字符串
String str = Integer.toString(10);
}
|
[5] valueOf() 快速构造Integer对象
|
public static void main(String[] args) {
Integer i1 = Integer.valueOf(10);
Integer i2 = Integer.valueOf("20");
}
|
总结
[1] int、String -> Integer
Integer(int/String) 、valueOf(int/String)
[2] Integer -> int、String
intValue()、toString()
[3] int Integer String
Integer.toString(int)
Integer.parseInt(String)
自动装箱/自动拆箱
自动装箱（auto-boxing）
基本数据类型可以自动转化成对于包装类
|
public class Test05 {
public static void main(String[] args) {
// 自动装箱
Integer i1 = 10; // Integer.valueOf(10) / new Integer(10)
System.out.println(i1);
}
}
|
自动拆箱（auto-unboxing）
把包装类自动转化成对应的基本数据类型
|
Integer i2 = new Integer(20);
// 自动拆箱
int r = i2; // int r = i2.intValue();
System.out.println(r);
|
注意:
[1] 自动装箱和自动拆箱 jdk 1.5+ 特性。(查资料jdk1.5 and later的新特性)
[2] 不要频繁的装箱、拆箱！！！
其他包装类学习思路
字符串
字符本质
String 类代表字符串,java中所有字符串字面量(“123”、“abc”)都是String类的实例。
字符串本质上、在内存中是字符数组 => 字符串类是字符数组的包装类。
通过字面量创建的字符串是常量，分配在常量区（常量池），它们的值在创建之后不能更改。
因为 String 对象是不可变的，所以可以共享
构造方法
通过构造方法构造出来的字符串分配在堆区。
|
package cn.sxt02.string02;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Arrays;
public class Test01 {
public static void main(String[] args) throws UnsupportedEncodingException {
// 构造一个空字符串
String str1 = new String();
System.out.println(str1.length());
//String(byte[] bytes)
byte[] bytes = {97,98,99};
// System.out.println(Charset.defaultCharset());
// 按照平台默认编码集解码
String str2 = new String(bytes);
System.out.println(str2);
// bgk编码的字节序列
byte[] bytes1 = {-42,-48};
String str3 = new String(bytes1);
System.out.println(str3);
//utf8编码的字节序列
byte[] bytes2 = {-28, -72, -83, -27, -101, -67};
String str4 = new String(bytes2,"utf8");
System.out.println(str4);
// 按照gbk并指定位置和长度
byte[] bytes5 = {97,98,99};
String str5 = new String(bytes5,1,2);
System.out.println(str5);
//utf8编码的字节序列
byte[] bytes6 = { -28, -72, -83, -27, -101, -67 };
String str6 = new String(bytes6,3,3, "utf8");
System.out.println(str6);
}
}
|
|
package cn.sxt02.string02;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Arrays;
public class Test02 {
public static void main(String[] args) throws UnsupportedEncodingException {
char[] c1 = {'中','国'};
String str1 = new String(c1);
System.out.println(str1);
char[] c2 = {'中','国'};
String str2 = new String(c2,0,1);
System.out.println(str2);
String str3 = "abc";
String str4 = new String(str3);
System.out.println(str4);
}
}
|
常用方法
[1]字符串的比较
|
public static void main(String[] args) {
String str1 = "Abcde";
String str2 = "ad";
System.out.println(str1.compareTo(str2));
System.out.println(str1.compareToIgnoreCase(str2));
System.out.println(str1.contentEquals(str2));
System.out.println(str1.equals(str2));
System.out.println(str1.equalsIgnoreCase(str2));
// 需求:请输入验证码
String validCode = "aCtD";
System.out.println("请输入验证码:"+validCode);
Scanner sc = new Scanner(System.in);
String str3 = sc.next();
if(str3.equalsIgnoreCase(validCode)) {
System.out.println("验证码正确");
}else {
System.out.println("验证码错误");
}
}
|
CharSequence 接口是 char 值的一个可读序列。
[2]是否包含子串
|
public static void main(String[] args) {
// 【1】字符串连接
String str1 = "hello";
String str2 = str1.concat(" world"); // +
System.out.println(str2);
String str3 = "world";
// 【2】查看字符串是否包含子串
System.out.println(str2.contains("d"));
String fileName = "abc.mp3";
// 以xxx为后缀
System.out.println(fileName.endsWith(".mp3"));
// 以xxx为前缀
System.out.println(fileName.startsWith("abc"));
// 从指定位置开始判断是否存在xxx前缀
System.out.println(fileName.startsWith("bc", 1));
}
|
[3] 查找子串位置
|
public static void main(String[] args) {
// 【3】 查找子串的位置
String str1 = "hello worlod";
// 从前向后查找指定字符第一次出现的位置，如果没找到，返回-1
int r = -1;
r = str1.indexOf('o');
// 从前向后自定位置（fromIndex）查找指定字符第一次出现的位置，如果没找到，返回-1
r = str1.indexOf('o', 5);
// 从前向后查找指定字符串第一次出现的位置，如果没找到，返回-1
r = str1.indexOf("lo");
// 从前向后自定位置（fromIndex）查找指定字符串第一次出现的位置，如果没找到，返回-1
r = str1.indexOf("lo",5);
System.out.println(r);
// 需求:不文明词语过滤
String str2 = "你是沙雕";
String str3 = "沙雕";
int loc = -1;
if( (loc=str2.indexOf(str3)) >=0 ) {
String newStr = str2.replace(str3, "**");
System.out.println(newStr);
}
String str4 = "hello java";
int r2 = -1;
// 从后向前查找指定字符第一次出现的位置，如果没找到，返回-1
r2 = str4.lastIndexOf('a');
/*
* str.lastIndexOf('xx',fromIndex)
* str.lastIndexOf("xx")
* str.lastIndexOf("xx",fromIndex)
*/
System.out.println(r2);
}
|
[4] 替换字符串
|
public static void main(String[] args) {
// 【4】 替换字符串
String str1 = "186-1234-1234";
/**
* ascii 空字符
* u0000 unicode 空字符
* char c = 'u4EC1';
* System.out.println(c);
* https://unicode-table.com/cn/#control-character
*/
String str2 = str1.replace('-',Character.MIN_VALUE);
String str3 = str1.replace("-","");
System.out.println(str3);
String str4 = "a1bc123cc11c";
// 通过正则全部替换
String str5 = str4.replaceAll("\d+", "");
// 通过正则替换第一次出现的字符串
str5 = str4.replaceFirst("\d+", "");
// str5 = str1.replaceAll("-", "");
System.out.println(str5);
String str6 = "123";
// 判断字符串是否符合指定正则表达式
System.out.println(str6.matches("\d*"));
}
|
[5] 分割字符串
|
public static void main(String[] args) {
// 【5】 分割字符串
String str1 = "186-1234-1234";
String[] arr1 = str1.split("-");
System.out.println(Arrays.toString(arr1));
// 需求:请创建大写26个字符存入数组中
String str2 = "ABCDEFGHI";
String[] arr2 = str2.split("");
System.out.println(Arrays.toString(arr2));
}
|
[6]求子串
|
public static void main(String[] args) {
// 【6】 求子串
String str1 = "abcdef";
// beiginIndex表示从指定位置开始截取，直到最后
String str2 = str1.substring(3);
// substring(beginIndex,endIndex)
// 从beginIndex开始截取到endIndex,但不包含endIndex位置的字符
// 含头不含尾
str2 = str1.substring(0, 3);
System.out.println(str2);
}
|
[7]其他
|
public static void main(String[] args) {
// 【7】 其他(大小写、去留白、格式化、返回指定编码的字节序列、判空、valueOf)
// 大小写
String str1 = "abc";
System.out.println(str1.toLowerCase());
System.out.println(str1.toUpperCase());
// 去留白
String str2 = " abc ";
System.out.println(str2.length());
System.out.println(str2.trim().length());
// 格式化
float price = 998.0f;
float price2 = 1998.0f;
char c = '￥';
String s = "中";
String str3 = String.format("$%f-$%f", price,price2);
str3 = String.format("$%c", c);
str3 = String.format("$%s", s);
System.out.println(str3);
// 返回指定编码的字节序列
String str4 = "国";
// byte[] byte4 = str4.getBytes();
byte[] byte4 = null;
try {
byte4 = str4.getBytes("utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
System.out.println(Arrays.toString(byte4));
// 判空
String str5 = "";
System.out.println(str5.isEmpty());
// valueOf
// 把其他数据类型->String
String str6 = String.valueOf(10);
System.out.println(str6);
}
|
格式化占位符
|
%*
|
描述
|
|
%d
|
整形
|
|
%f
|
浮点型
|
|
%c
|
字符
|
|
%s
|
字符串
|
StringBuffer和StringBuilder
String 提供的API都是对包装的字符数组进行读取操作，不能对内部的字符数组进行修改。如果要对字符串进行破坏性操作(增、删、改)，一定需要一个字符串的可变版本。java字符串的可变版本有StringBuffer和StringBuilder
StringBuffer
StringBuffer是字符串的可变序列，本质上是一个字符数组的包装类。内部维护了一个char[] value 默认长度是16。当需要向StringBuffer添加元素时，首先有无足够空间，如果有，直接添加元素；如果没有，先拓容，后添加。
拓容原则: value*2+2即是新数组的容量，内部通过数组复制完成拓容。
StringBuffer是线程安全的
构造方法
|
public class Test01 {
public static void main(String[] args) {
// 默认16个unicode字符的空间
StringBuffer sb1 = new StringBuffer();
StringBuffer sb2 = new StringBuffer(32);
StringBuffer sb3 = new StringBuffer("hello");
System.out.println(sb3.capacity());
}
}
|
常用方法
|
public class Test02 {
public static void main(String[] args) {
StringBuffer sb1 = new StringBuffer();
// 【1】追加
sb1.append('a');
sb1.append("bc");
sb1.append(10);
System.out.println(sb1.length());
// 【2】查看
// 可能会产生StringIndexOutOfBoundsException
//char c = sb1.charAt(5);
//System.out.println(c);
// 【3】删除(含头不含尾)
sb1.delete(0, 3);
System.out.println(sb1);
// 【4】修改
sb1.setCharAt(0, 'A');
System.out.println(sb1);
}
}
|
其他方法
|
public static void main(String[] args) {
StringBuffer sb1 = new StringBuffer();
// 【1】 自动拓容
sb1.append("0123456789abcdef");
System.out.println(sb1.capacity());
sb1.append('A');
System.out.println(sb1.capacity()); // 34 = 16*2+2
// 【2】insert 在指定位置添加元素
StringBuffer sb2 = new StringBuffer("abc");
// 可能会出现ArrayIndexOutOfBoundsException
sb2.insert(0, 'A');
System.out.println(sb2);
// 【3】replace(start,end,str) 含头不含尾
sb2.replace(0, 1, "中国");
System.out.println(sb2.toString());
// 中国abc
// 【4】setLength(len) => 清空数组=>效率高
sb2.setLength(0);
// 【5】优化存储空间
StringBuffer sb3 = new StringBuffer("abc");
sb3.append("12");
sb3.trimToSize();
System.out.println(sb3.capacity());
}
|
StringBuilder
相同点
[1] 都是字符串的可变序列
[2] API都一样
不同点
[1] StringBuffer线程安全(同步操作)、效率低;StringBuilder线程不安全(不保证同步)、效率高
[2] stringbuffer jdk1.0;stringbuilder jdk1.5
字符串使用陷阱
String s = “a”; 造成性能问题！！！
[1] s = s + “b”
[2] for{ s = s + “b”}
