三、StringBuilder
一、String1.1、String
String 类是final修饰的，是顶级类，不可被继承
String类代表字符串。java程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。
字符串是常量；它们的值在创建之后不能更改
String str="abc";
String类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。
1.2、String常用方法
方法摘要char
charAt(int index)
返回指定索引处的char值。
int
codePointAt(int index)
返回指定索引处的字符（Unicode 代码点）。
int
codePointBefore(int index)
返回指定索引之前的字符（Unicode 代码点）。
int
codePointCount(int beginIndex,
int endIndex)
返回此String的指定文本范围中的 Unicode
代码点数。
int
compareTo(String anotherString)
按字典顺序比较两个字符串。
int
compareToIgnoreCase(String str)
按字典顺序比较两个字符串，不考虑大小写。
String
concat(String str)
将指定字符串连接到此字符串的结尾。
boolean
contains(CharSequence s)
当且仅当此字符串包含指定的 char 值序列时，返回 true。
boolean
contentEquals(CharSequence cs)
将此字符串与指定的CharSequence比较。
boolean
contentEquals(StringBuffer sb)
将此字符串与指定的StringBuffer比较。
static String
copyValueOf(char[] data)
返回指定数组中表示该字符序列的 String。
static String
copyValueOf(char[] data,
int offset, int count)
返回指定数组中表示该字符序列的 String。
boolean
endsWith(String suffix)
测试此字符串是否以指定的后缀结束。
boolean
equals(Object anObject)
将此字符串与指定的对象比较。
boolean
equalsIgnoreCase(String anotherString)
将此String与另一个String比较，不考虑大小写。
static String
format(Locale l, String format, Object... args)
使用指定的语言环境、格式字符串和参数返回一个格式化字符串。
static String
format(String format, Object... args)
使用指定的格式字符串和参数返回一个格式化字符串。
byte[]
getBytes()
使用平台的默认字符集将此String编码为 byte 序列，并将结果存储到一个新的 byte
数组中。
byte[]
getBytes(Charset charset)
使用给定的 charset 将此String编码到 byte 序列，并将结果存储到新的 byte 数组。
void
getBytes(int srcBegin,
int srcEnd, byte[] dst, int dstBegin)
已过时。该方法无法将字符正确转换为字节。从 JDK 1.1 起，完成该转换的首选方法是通过getBytes()方法，该方法使用平台的默认字符集。
byte[]
getBytes(String charsetName)
使用指定的字符集将此String编码为 byte 序列，并将结果存储到一个新的 byte
数组中。
void
getChars(int srcBegin,
int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组。
int
hashCode()
返回此字符串的哈希码。
int
indexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引。
int
indexOf(int ch,
int fromIndex)
返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int
indexOf(String str)
返回指定子字符串在此字符串中第一次出现处的索引。
int
indexOf(String str,
int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
String
intern()
返回字符串对象的规范化表示形式。
boolean
isEmpty()
当且仅当length()为0时返回true。
int
lastIndexOf(int ch)
返回指定字符在此字符串中最后一次出现处的索引。
int
lastIndexOf(int ch,
int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
int
lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引。
int
lastIndexOf(String str,
int fromIndex)
返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
int
length()
返回此字符串的长度。
boolean
matches(String regex)
告知此字符串是否匹配给定的正则表达式。
int
offsetByCodePoints(int index,
int codePointOffset)
返回此String中从给定的index处偏移codePointOffset个代码点的索引。
boolean
regionMatches(boolean ignoreCase,
int toffset, String other, int ooffset,
int len)
测试两个字符串区域是否相等。
boolean
regionMatches(int toffset,
String other,
int ooffset, int len)
测试两个字符串区域是否相等。
String
replace(char oldChar,
char newChar)
返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。
String
replace(CharSequence target, CharSequence replacement)
使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String
replaceAll(String regex, String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String
replaceFirst(String regex, String replacement)
使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
String[]
split(String regex)
根据给定正则表达式的匹配拆分此字符串。
String[]
split(String regex,
int limit)
根据匹配给定的正则表达式来拆分此字符串。
boolean
startsWith(StringPRefix)
测试此字符串是否以指定的前缀开始。
boolean
startsWith(String prefix,
int toffset)
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
CharSequence
subSequence(int beginIndex,
int endIndex)
返回一个新的字符序列，它是此序列的一个子序列。
String
substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串。
String
substring(int beginIndex,
int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
char[]
toCharArray()
将此字符串转换为一个新的字符数组。
String
toLowerCase()
使用默认语言环境的规则将此String中的所有字符都转换为小写。
String
toLowerCase(Locale locale)
使用给定Locale的规则将此String中的所有字符都转换为小写。
String
toString()
返回此对象本身（它已经是一个字符串！）。
String
toUpperCase()
使用默认语言环境的规则将此String中的所有字符都转换为大写。
String
toUpperCase(Locale locale)
使用给定Locale的规则将此String中的所有字符都转换为大写。
String
trim()
返回字符串的副本，忽略前导空白和尾部空白。
static String
valueOf(boolean b)
返回boolean参数的字符串表示形式。
static String
valueOf(char c)
返回char参数的字符串表示形式。
static String
valueOf(char[] data)
返回char数组参数的字符串表示形式。
static String
valueOf(char[] data,
int offset, int count)
返回char数组参数的特定子数组的字符串表示形式。
static String
valueOf(double d)
返回double参数的字符串表示形式。
static String
valueOf(float f)
返回float参数的字符串表示形式。
static String
valueOf(int i)
返回int参数的字符串表示形式。
static String
valueOf(long l)
返回long参数的字符串表示形式。
static String
valueOf(Object obj)
返回Object参数的字符串表示形式。
1.3、String str="abc"与String str1=new String("abc")区别
packagecom.pb.string.demo1;publicclassDemo1 {publicstaticvoidmain(String[] args) {/** s1一个字符串类类型变量，abc是一个对象
* 一旦被初始化，就不可以被改变*/String str1="abc";/** new 就是在堆内存中再开辟一个新的空间
* s1只有一个对象abc
* s2有2个对象abc和new String("abc");*/String str2=newString("abc");
System.out.println(str1==str2);//false ==比较内存地址/** String 类重写了Object中的equals方法，用来比较字符串内容是否相同*/System.out.println(str1.equals(str2));//true 比较地址中的值}
}
1.4、获取和判断
获取
获取字符串长度length();
根据位置获取位置下的字符char charAt(int index);
根据字符获取该字字符串中位置 int indexOf(in ch)返回第一次出现的位置
从fromIndex（int ch,int fromIndex):获取ch在字符串中出现位置
从fromIndex（String str,int fromIndex):获取str在字符串中出现位置
packagecom.pb.string.demo1;publicclassStringDemo1 {publicstaticvoidmain(String[] args) {
String str="abcdefghijklmnab";//长度16//长度sop(str.length());//根据索引获取字符sop(str.charAt(5));//sop(str.charAt(33));//下标越界//根据字符获取索引sop(str.indexOf('b'));//从0开始查找//从指字位置开始sop(str.indexOf('b',5));//从索引为5的字符形开始查找//查找没的字符sop(str.indexOf('v',5));//-1 如果没有找到返回-1//从后向前查找sop(str.lastIndexOf('b'));
sop(str.lastIndexOf("b"));//}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
判断
字符串中是否包含某一个子串 boolean contains(String str); indexOf(str) 可以索引str第一次出现的位置，如果返回-1，表示不包含在字符串，也可以用于指定判断是否包含
字符串中是否有内容boolean isEmpty(),判断长度是否为0，
字符串是否以指字内容开头boolean startWith(String str)
字符串是否以指字内容结尾boolean endWith(String str)
判断字符内容是否相同equals(String str),重写Object中equals方法
判断字符内容是否相同忽略大小写equalsIgnoreCase(String str),
packagecom.pb.string.demo1;publicclassStringDemo2 {publicstaticvoidmain(String[] args) {
String str="ArrayDemo.java";
sop(str.startsWith("Array"));//判断是否以Array开头 truesop(str.endsWith(".java"));//判断是否以.java结尾 truesop(str.contains("Demo"));//判断是否有(包含)Demo子串 truesop(str.equals("ArrayDemo.java"));//判断字符串内容是否相同 truesop(str.equalsIgnoreCase("ArrayDemo.java"));//判断字符串内容是否相同并忽略大小字书 true}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
1.5、转换
将字符数组转成字符串--构造方法
packagecom.pb.string.demo1;publicclassStringDemo3 {publicstaticvoidmain(String[] args) {char[] ch={'a','b','c','d','e','f','g'};//将字符数组转换成字符串String str1=newString(ch);
sop(str1);
String str2=newString(ch,1,4);//第下标为1开始转换4个字符ssop(str2);//静态方法String str3=String.copyValueOf(ch);
sop(str3);
String str4=String.copyValueOf(ch,1,5);
sop(str4);
String str5=String.valueOf(ch);
sop(str5);
String str6=String.valueOf(ch,1,4);
sop(str6);
}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
将字符串，转换成字符数组
将字节数组转换成字符串
char[]
toCharArray()
将此字符串转换为一个新的字符数组
将字符串转换成字节数组
packagecom.pb.string.demo1;publicclassStringDemo4 {publicstaticvoidmain(String[] args) {
String str="abcdefg";//将字符串转换为字符数组char[] ch=str.toCharArray();//遍历for(inti = 0; i < ch.length; i++) {
System.out.print(ch[i]+",");
}//将字符串转换为字节数组byte[] b=str.getBytes();for(inti = 0; i < b.length; i++) {
System.out.print((char)b[i]);
}
}
}
将基本数组类型转换为字符串
packagecom.pb.string.demo1;publicclassStringDemo5 {publicstaticvoidmain(String[] args) {inti=3;//可以是double,float,short,long,char,byteString str1=i+"";
String str2=String.valueOf(i);
}
}
1.6、切割和替换,截取
分离
packagecom.pb.string.demo1;importjava.util.Arrays;publicclassSplitString {publicstaticvoidmain(String[] args) {
String str1="zhangsa,lisi,wangwu,zhaoliu";
String[] arr=str1.split(",");
System.out.println(Arrays.toString(arr));
}
}
结果：[zhangsa, lisi, wangwu, zhaoliu]
替换
packagecom.pb.string.demo1;publicclassReplaceDemo {publicstaticvoidmain(String[] args) {
String str1="Hello,Java!";
String str2=str1.replace('a', 'n');
String str3=str1.replace('q', 'n');//如果替换的不在,返回的还是原来的String str4=str1.replace("Java", "World");
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println(str4);
}
}
Hello,Java!
Hello,Jnvn!
Hello,Java!
Hello,World!
截取
packagecom.pb.string.demo1;publicclassSubStringDemo6 {publicstaticvoidmain(String[] args) {
String s="abcdef";
System.out.println(s.substring(2));//cdef,从第二开始到结尾System.out.println(s.substring(2, 4));//cd 从第二个到第4个但不包含第4个System.out.println(s.substring(0,s.length()));//获取全部System.out.println(s.substring(0));
}
}
1.7、比较和去除空格
比较
如果参数字符串等于此字符串，则返回值0；如果此字符串按字典顺序小于字符串参数，则返回一个小于0的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于0的值。
去空格
将字符串转换为大写或者小写
packagecom.pb.string.demo1;publicclassStringDemo6 {publicstaticvoidmain(String[] args) {
String s=" Hello Java! ";//转换为小写System.out.println(s.toLowerCase());//转换为大写System.out.println(s.toUpperCase());//去除2边的空格System.out.println(s.trim());
}
}
结果：
hello java!HELLO JAVA!Hello Java!
1.8、去掉字符串两边的空格
packagecom.pb.string.demo2;/*** 模拟一个trim方法，去除字符串2边的空格
*@authorDenny
* 判断字符串开始第一个位置是不是空格，是断续直到不是空格 为步
* 结尾处判断空格一样
* 当开始和结尾都不是空格时，就是要获取的字符串
*
**/publicclassStringDemo1 {publicstaticvoidmain(String[] args) {
String str=" Hello Java! ";
sop(str);//去空格前str=myTrim(str);
sop(str);//去空格后}publicstaticString myTrim(String str){intstart=0,end=str.length()-1;//开始的空格while(start<=end&&str.charAt(start)==' '){
start++;
}//结尾的空格while(start<=end&&str.charAt(end)==' '){
end--;
}returnstr.substring(start,end+1);//截取}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
Hello Java!Hello Java!
1.9、字符串反转
packagecom.pb.string.demo2;/*** 将一个字符串返转
*@authordenny
*思路：
*可以将字符串变成数组，对数组反转
*将反转后的数组，转换成字符串
*只要将或者反转的部分的开始和结束位置作为参数传递即可*/publicclassStringDemo2 {publicstaticvoidmain(String[] args) {
String str="abcdef";
sop(str);
str=reverseString(str,1,5);
System.out.println(str);
}//从某个位置开始反转到某个位置结束publicstaticString reverseString(String s,intstart,intend){char[] ch=s.toCharArray();
reverse(ch,start,end);returnnewString(ch);
}//方法重载，反转全部publicstaticString reverseString(String s){returnreverseString(s,0,s.length());
}//反转 参数，开始位到结束位置，但不包含结束位privatestaticvoidreverse(char[] arr,intx,inty){for(intstart=x,end=y-1;start<end;start++,end--){
swap(arr,start,end);//交换值}
}//交换privatestaticvoidswap(char[] arr,intstart,intend){chartmp=arr[start];
arr[start]=arr[end];
arr[end]=tmp;
}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
abcdef
aedcbf
1.10、获取字符串在另一个字符串中出现的次数
packagecom.pb.string.demo2;/*** 获取字符串在另一个字符串中出现的次数
*
*@authorDenny 定义一个计数器获取第一次出现的位置 从第一次出现的位置后，剩余的字符串中继续获取再现的位置 每获取一次就加1
* 当获取不到时计数完成*/publicclassStringDemo3 {publicstaticvoidmain(String[] args) {
String s1= "kkabkkcdkkefkkskk";
String s2= "kk";intcount =getCount_2(s1, s2);
System.out.println("count="+count);
}publicstaticintgetCount(String s1, String key) {intcount = 0;intindex=0;//下标while((index=s1.indexOf(key))!=-1){
sop("index="+index);
sop("s1="+s1);
s1=s1.substring(index+key.length());//截取字符串，再赋值给字符串count++;
}returncount;
}publicstaticintgetCount_2(String s1, String key) {intcount = 0;intindex=0;//下标while((index=s1.indexOf(key,index))!=-1){
index=index+key.length();
sop("index="+index);
count++;
}returncount;
}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
结果：
index=2index=6index=10index=14index=17count=5
1.11、获取2个字符串最大相同的串
packagecom.pb.string.demo2;/***
*@authorDenny 获取2个字符串最大相同的串， 将短的字符进行一长度递减的子串打印 将知的字符串按照长度弟减的方式获取到 如果包含就找到!*/publicclassStringDemo4 {publicstaticvoidmain(String[] args) {
String s1= "abcwerthelloyuiodef";
String s2= "cvhelloybnm";
sop("最大相同的是:"+getMaxString(s2,s1));
}publicstaticString getMaxString(String s1, String s2) {
String max= "", min = "";//判断哪个字符串长max = (s1.length() > s2.length()) ?s1 : s2;
min=(max==s1)?s2:s1;//System.out.println("max="+max+",min="+min);//使用小的字符串做循环for(inti = 0; i < min.length(); i++) {//每次都从0开始，从后减少for(inty=0,z=min.length()-i;z!=min.length()+1;y++,z++){
String temp=min.substring(y,z);
sop(temp);if(max.contains(temp)){returntemp;
}
}
}return"";
}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
cvhelloybnm
cvhelloybn
vhelloybnm
cvhelloyb
vhelloybn
helloybnm
cvhelloy
vhelloyb
helloybn
elloybnm
cvhello
vhelloy
helloyb
elloybn
lloybnm
cvhell
vhello
helloy
最大相同的是:helloy
二、StringBuffer2.1、StringBuffer
首先StringBuffer是字符串缓冲区，是一个容器。
每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即StringBuilder。与该类相比，通常应该优先使用StringBuilder类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。
1.长度是可以变化的
2.可以操作多个数据类型
3.最终会通过toString()方法变成字符串.
容器：增加，删除，改，查
c----create append()将指定字符串，添加到现在的字符串末尾
u----update
r-----read
d----delete
append()将指定字符串，添加到现在的字符串末尾
insert插入到指定位置append(索引，要插入的字符串或者其它类型）
delete 删除
2.2、示例
添加,插入
packagecom.pb.stringbuffer.demo1;publicclassStringBufferDemo1 {publicstaticvoidmain(String[] args) {
StringBuffer sb=newStringBuffer();
sb.append("abcd").append(123).append("mmmmmmmm");//插入sb.insert(2, "QQqqqqqqqqq");
System.out.println(sb);
}
}
删除 包含start不包含end
StringBuffer
delete(int start, int end)
移除此序列的子字符串中的字符。
StringBuffer
deleteCharAt(int index)
移除此序列指定位置的char。
packagecom.pb.stringbuffer.demo1;publicclassStringBufferDemo2 {publicstaticvoidmain(String[] args) {
getChar();
}//获取指定字符串，并存放在字符数组中publicstaticvoidgetChar(){
StringBuffer sb=newStringBuffer("abcdef");char[] ch=newchar[8];
sb.getChars(1, 4, ch, 2);for(inti = 0; i < ch.length; i++) {
sop("ch["+i+"]="+ch[i]);
}
}//修改publicstaticvoidupdate(){
StringBuffer sb=newStringBuffer("abcdef");
sb.replace(1, 4, "33333333333");
sop(sb);//替换一个sb.setCharAt(1, 'k');
sop(sb);
}publicstaticvoiddel(){
StringBuffer sb=newStringBuffer("abcdefghi");
sb.delete(1, 3);
sop(sb);//删除一个sb.deleteCharAt(sb.indexOf("i"));
sop(sb);//清空缓冲区sb.delete(0, sb.length());
sop(sb);
}//添加，插入publicstaticvoidadd_insert(){
StringBuffer sb=newStringBuffer();
sb.append("abcd").append(123).append("mmmmmmmm");//插入sb.insert(2, "qqqqqqqqqqq");
System.out.println(sb);
}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
2.3、常用方法
构造方法摘要StringBuffer()
构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
StringBuffer(CharSequence seq)
public java.lang.StringBuilder(CharSequence seq)
构造一个字符串缓冲区，它包含与指定的CharSequence相同的字符。
StringBuffer(int capacity)
构造一个不带字符，但具有指定初始容量的字符串缓冲区。
StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
方法摘要StringBuffer
append(boolean b)
将boolean参数的字符串表示形式追加到序列。
StringBuffer
append(char c)
将char参数的字符串表示形式追加到此序列。
StringBuffer
append(char[] str)
将char数组参数的字符串表示形式追加到此序列。
StringBuffer
append(char[] str,
int offset, int len)
将char数组参数的子数组的字符串表示形式追加到此序列。
StringBuffer
append(CharSequence s)
将指定的CharSequence追加到该序列。
StringBuffer
append(CharSequence s, int start,
int end)
将指定CharSequence的子序列追加到此序列。
StringBuffer
append(double d)
将double参数的字符串表示形式追加到此序列。
StringBuffer
append(float f)
将float参数的字符串表示形式追加到此序列。
StringBuffer
append(int i)
将int参数的字符串表示形式追加到此序列。
StringBuffer
append(long lng)
将long参数的字符串表示形式追加到此序列。
StringBuffer
append(Object obj)
追加Object参数的字符串表示形式。
StringBuffer
append(String str)
将指定的字符串追加到此字符序列。
StringBuffer
append(StringBuffer sb)
将指定的StringBuffer追加到此序列中。
StringBuffer
appendCodePoint(int codePoint)
将codePoint参数的字符串表示形式追加到此序列。
int
capacity()
返回当前容量。
char
charAt(int index)
返回此序列中指定索引处的char值。
int
codePointAt(int index)
返回指定索引处的字符（统一代码点）。
int
codePointBefore(int index)
返回指定索引前的字符（统一代码点）。
int
codePointCount(int beginIndex,
int endIndex)
返回此序列指定文本范围内的统一代码点。
StringBuffer
delete(int start,
int end)
移除此序列的子字符串中的字符。
StringBuffer
deleteCharAt(int index)
移除此序列指定位置的char。
void
ensureCapacity(int minimumCapacity)
确保容量至少等于指定的最小值。
void
getChars(int srcBegin,
int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组dst。
int
indexOf(String str)
返回第一次出现的指定子字符串在该字符串中的索引。
int
indexOf(String str,
int fromIndex)
从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
StringBuffer
insert(int offset,
boolean b)
将boolean参数的字符串表示形式插入此序列中。
StringBuffer
insert(int offset,
char c)
将char参数的字符串表示形式插入此序列中。
StringBuffer
insert(int offset,
char[] str)
将char数组参数的字符串表示形式插入此序列中。
StringBuffer
insert(int index,
char[] str, int offset, int len)
将数组参数str的子数组的字符串表示形式插入此序列中。
StringBuffer
insert(int dstOffset,
CharSequence s)
将指定CharSequence插入此序列中。
StringBuffer
insert(int dstOffset,
CharSequence s, int start,
int end)
将指定CharSequence的子序列插入此序列中。
StringBuffer
insert(int offset,
double d)
将double参数的字符串表示形式插入此序列中。
StringBuffer
insert(int offset,
float f)
将float参数的字符串表示形式插入此序列中。
StringBuffer
insert(int offset,
int i)
将int参数的字符串表示形式插入此序列中。
StringBuffer
insert(int offset,
long l)
将long参数的字符串表示形式插入此序列中。
StringBuffer
insert(int offset,
Object obj)
将Object参数的字符串表示形式插入此字符序列中。
StringBuffer
insert(int offset,
String str)
将字符串插入此字符序列中。
int
lastIndexOf(String str)
返回最右边出现的指定子字符串在此字符串中的索引。
int
lastIndexOf(String str,
int fromIndex)
返回最后一次出现的指定子字符串在此字符串中的索引。
int
length()
返回长度（字符数）。
int
offsetByCodePoints(int index,
int codePointOffset)
返回此序列中的一个索引，该索引是从给定index偏移codePointOffset个代码点后得到的。
StringBuffer
replace(int start,
int end, String str)
使用给定String中的字符替换此序列的子字符串中的字符。
StringBuffer
reverse()
将此字符序列用其反转形式取代。
void
setCharAt(int index,
char ch)
将给定索引处的字符设置为ch。
void
setLength(int newLength)
设置字符序列的长度。
CharSequence
subSequence(int start,
int end)
返回一个新的字符序列，该字符序列是此序列的子序列。
String
substring(int start)
返回一个新的String，它包含此字符序列当前所包含的字符子序列。
String
substring(int start,
int end)
返回一个新的String，它包含此序列当前所包含的字符子序列。
String
toString()
返回此序列中数据的字符串表示形式。
void
trimToSize()
尝试减少用于字符序列的存储空间。
三、StringBuilder3.1、StringBuilder简述
用法与StringBuffer一样
将StringBuilder的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用StringBuffer。
从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即StringBuilder。与该类相比，通常应该优先使用StringBuilder类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。
3.2、String、StringBuffer和StringBuilder区别
String 长度是固定不变的
StringBuffer和StringBuilder是容器，长度是可变
StringBuffer是同步的是线程安全的。效率低 。多线程
StringBuilder是没有同步的，非线程安全的，效率高. 单线程，或者手动加锁 也可以用于多线程
升级：提高效率，提高安全，简化写代码效率。建议使用StringBuilder
四、包装类
4.1、基本数据类型对应的包装类
byte Byte
shortShort
int Interget
longLong
boolean Boolean
floatFloat
double Double
charCharacter
4.2、以int为类
字段摘要static int
MAX_VALUE
值为 231－1 的常量，它表示int类型能够表示的最大值。
static int
MIN_VALUE
值为 －231的常量，它表示int类型能够表示的最小值。
static int
SIZE
用来以二进制补码形式表示int值的比特位数。
static Class<Integer>
TYPE
表示基本类型int的Class实例。
构造方法摘要Integer(int value)
构造一个新分配的Integer对象，它表示指定的int值。
Integer(String s)
构造一个新分配的Integer对象，它表示String参数所指示的int值。
packagecom.pb.demo.packclass.demo1;publicclassInterger {publicstaticvoidmain(String[] args) {
Integer max=Integer.MAX_VALUE;//最大值Integer min=Integer.MIN_VALUE;//最小值System.out.println("max="+max);
System.out.println("min="+min);
}
}
常用操作
用于基本数据类型和字符串类型之间做转换
4.3、基本数据类型转换成字符串
基本数据类型+"";
toString(基本数据类型);
String.ValueOf(基本数据类型）
packagecom.pb.demo.packclass.demo1;/*** 转换为字符串
*@authorDenny
**/publicclassDemo1 {publicstaticvoidmain(String[] args) {doubled=33.4;
String s1=d+"";
String s2=Double.toString(d);
String s3=String.valueOf(d);
}
}
4.4、字符串转换成基本数据类型
基本数据类型 值=基本类型类型的包装类.parseXxx(String);
int a=Integer.parseInt("123");
packagecom.pb.demo.packclass.demo1;publicclassDemo2 {publicstaticvoidmain(String[] args) {
String s1="32";inti=Integer.parseInt(s1);//转换为int类型String s2="22.4";doubled=Double.parseDouble(s2);//转换为doubleString s3="11.3";floatf=Float.parseFloat(s3);//转换为float类型longl=Long.parseLong("88888888");booleanb=Boolean.parseBoolean("true");//或者falseInteger x=newInteger(33);intnum=x.intValue();//动态方法 转换为基本数据类型}
}
4.5、进制转换
packagecom.pb.demo.packclass.demo1;publicclassDemo3 {publicstaticvoidmain(String[] args) {//转换为二进制System.out.println(Integer.toBinaryString(10));//八进制System.out.println(Integer.toOctalString(10));//十六进制System.out.println(Integer.toHexString(10));//转换为2进制System.out.println(Integer.parseInt("110", 2));//转换为8进制System.out.println(Integer.parseInt("17", 8));//转换为16进制System.out.println(Integer.parseInt("af", 16));
}
}
结果：
1010
12a6
15
175
4.6、新特性
自动装箱和自动拆箱
packagecom.pb.demo.packclass.demo1;publicclassDemo4 {publicstaticvoidmain(String[] args) {
Integer x=4;//自动装箱，==new Integer(4)，x=x+2;//自对拆箱 x.intValue()转换为int类型，+2运算，再进行自动装箱}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
packagecom.pb.demo.packclass.demo1;publicclassDemo5 {publicstaticvoidmain(String[] args) {
Integer i=128;
Integer j=128;
sop("i==j: "+(i==j));//false/** 如果指向同一个Integr对象
* 当数值在byte范围内里-128-127之间
* 1.5后的新特性
* 如果该值已经存在，就不会开辟新的空间*/Integer x=127;
Integer y=127;
sop("x==y:"+(x==y));//true}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}
int
compareTo(Integer anotherInteger)
在数字上比较两个Integer对象。
packagecom.pb.demo.packclass.demo1;publicclassDemo6 {publicstaticvoidmain(String[] args) {
Integer x=3;
Integer y=8;
sop(x.compareTo(y));//-1 小于sop(Integer.compare(y, x));//大于1sop(Integer.compare(5, 5));//等于 0}publicstaticvoidsop(Object obj){
System.out.println(obj);
}
}