Java学习日记（八）String类、StringBuffer类、基本数据类型对象包装类
·String类是一个特殊的对象，是对字符串事物的描述，专门用于操作字符串
Stringstr=”abc”;//str是一个类类型变量，”abc”是一个对象
·字符串一旦初始化就不可以该改变
·String str1=”abc”;与String str2=new String(“abc”);有什么区别？
str1在内存中有一个对象，str2在内存中有两个对象
String类的常用方法：
◆获取：
1.int length()——字符串中的包含的字符数，字符串的长度
2.char charAt(int index)——根据位置获取位置上某个字符
3.int indexOf(int ch)——返回的是ch在字符串中第一次出现的位置
int indexOf(int ch,int fromIndex)——从fromIndex指定位置开始，获取ch在字符串中出现的位置
int indexOf(String srt)——返回的是str在字符串中第一次出现的位置
int indexOf(String str,int fromIndex)——从fromIndex指定位置开始，获取str在字符串中出现的位置。
int lastIndexOf(int ch)——返回指定字符在此字符串中最后一次出现处的位置
示例：
class StringDemo {
public static void main(String[] args) {
Strings1="abcdefgabcdefg";
//返回字符串的长度
System.out.println(s1.length()); //结果：14
//返回脚标为4的字符
System.out.println(s1.charAt(4)); //结果：e
//获取第一次出现的d的脚标
System.out.println(s1.indexOf("d")); //结果：3
//获取从脚标为4的元素开始第一次d的脚标
System.out.println(s1.indexOf("d",4)); //结果：10
//获取Unicode值为99在s1中出现的第一次位置
System.out.println(s1.indexOf(100)); //结果：3
//从脚本为6的元素开始获取Unicode值为99在s1中出现的第一次位置
System.out.println(s1.indexOf(100,6)); //结果：10
//获取Unicode值为103最后一次出现的位置
System.out.println(s1.lastIndexOf(103)); //结果：13
}
}◆判断：
1.boolean contains(str)——字符串中是否包含某一个子串
2.boolean isEmpty()——字符中是否有内容
3.boolean startsWith(str)——字符串是否是以指定内容开头
4.boolean endsWith(str)——字符串是否是以指定内容结尾
5.boolean equals(str)——判断字符串内容是否相同（复写了Object类中的equals方法）
6.boolean equalsIgnoreCase()——判断内容是否相同，并忽略大小写
示例：
class StringDemo {
publics tatic void main(String[] args) {
String s1 = "abcdefgabcdefg";
String s2="efgab";
String s3="";
String s4="abc";
String s5="efgab";
String s6="eFGaB";
//判断s1中是否包含指定内容
System.out.println(s1.contains(s2)); //结果：true
System.out.println(s1.contains("geavge")); //结果：false
//判断字符中是否有内容
System.out.println(s1.isEmpty()); //结果：false
System.out.println(s3.isEmpty()); //结果：true
//判断字符串是否是以指定内容开头
System.out.println(s1.startsWith(s2)); //结果：false
System.out.println(s1.startsWith(s4)); //结果：true
//判断字符串内容是否相同
System.out.println(s2.equals(s5)); //结果：true
System.out.println(s2.equals(s4)); //结果：false
//判断内容是否相同，并忽略大小写
System.out.println(s2.equalsIgnoreCase(s5)); //结果：true
System.out.println(s2.equalsIgnoreCase(s6)); //结果：true
}
}◆类型转换：
1.将字符数组转换为字符串
构造函数String(char[] arr)
String(char[] arr,int offset,int count)——从offset位置开始取count个转成数组
静态方法：static StringcopyValueOf(char[] arr)
static String copyValueOf(char[] data, intoffset, int count)
static String valueOf(char[])
2.将字符串转成字符数组——char[] toCharArray()
3.将字节数组转成字符串——String(byte[] bytes)
String(byte[] bytes,int offset,int count)——将字节数组中的一部分转成字符串
4.将字符串转成字节数组——byte[] getBytes()
5.将基本数据类型转成字符串
static Stirng vlaueOf(int a)——返回int参数的字符串表示形式
static String valueOf(double a)——返回double参数的字符串表示形式
示例：
class StringDemo {
public static void main(String[] args) {
//将字符数组转换成字符串（构造函数）
String s1 = new String(new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g' });
System.out.println(s1); // 结果：abcdefg
String s2 = new String(new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g','h','i', 'j', 'k', 'l', 'm', 'n' }, 4, 9);
System.out.println(s2); // 结果：efghijklm
//将字符数组转换成字符串（静态方法）
Strings3 = String.copyValueOf(new char[] { 'a', 'b', 'c', 'd', 'e','f','g' });
System.out.println(s3); // 结果：abcdefg
Strings4 = String.copyValueOf(new char[] { 'a', 'b', 'c', 'd', 'e','f','g', 'h', 'i', 'j', 'k', 'l', 'm', 'n' }, 4, 9);
System.out.println(s4); // 结果：efghijklm
//将字符串转成字符数组
char[] ch = s1.toCharArray(); //结果：[a,b,c,d,e,f,g]
System.out.print("[");
for(int x = 0; x < ch.length; x++) {
if(x != ch.length - 1)
System.out.print(ch[x]+ ",");
else
System.out.println(ch[x]+ "]");
}
//将字节数组转成字符串
String s5 = new String(new byte[] { 'a', 'b', 'c', 'd', 'e', 'f' });
System.out.println(s5); // 结果：abcdef
//将字符串转成字节数组
byte[] bytes = s5.getBytes(); //结果：[97,98,99,100,101,102]
System.out.print("[");
for(int x = 0; x < bytes.length; x++) {
if(x != bytes.length - 1)
System.out.print(bytes[x]+ ",");
else
System.out.println(bytes[x]+ "]");
}
//将基本数据类型转成字符串
System.out.println(String.valueOf(100)); // 结果：100
System.out.println(String.valueOf((char)100)); // 结果：d
System.out.println(String.valueOf(true)); //结果：true
}
}◆替换
String replace(char old,char new)
示例：
class StringDemo {
public static void main(String[] args) {
String s1 = "afadfefsdfefefe";
System.out.println(s1.replace('e','f')); //结果：afadfffsdffffff
}
}◆切割
String[] split(String regex)——用正则表达式将字符串分割成数组
示例：
class StringDemo {
public static void main(String[] args) {
String s = "a3fd5f8de6rerer6yrt";
//将s以数字分开
String[] temp = s.split("[0-9]"); //结果：[a,fd,f,de,rerer,yrt]
System.out.print("[");
for(int x = 0; x < temp.length; x++) {
if(x != temp.length - 1)
System.out.print(temp[x]+ ",");
else
System.out.println(temp[x]+ "]");
}
}
}◆子串
1.Stringsubstring(int begin)——返回从begin到结尾
2.Stringsubstring(int begin,int end)——返回从begin到end-1（包含头，不包含尾）
示例：
class StringDemo {
public static void main(String[] args) {
Strings1 = "abcdefg";
//从第2个开始截到最后
System.out.println(s1.substring(2)); //结果：cdefg
//从第2个开始截到第4个
System.out.println(s1.substring(2,5)); //结果：cde
}
}◆转换、取出空格、比较
1.String toUpperCase()——将字符串转成大写
String toLowerCase()——将字符串转成小写
2.String trim()——将字符串两端的多个空格去除
3.int compareTo(string s)——对两个字符串进行自然顺序的比较
示例：
class StringDemo {
public static void main(String[] args) {
String s1 = " abcdefgAB CDEFG ";
//将字符串转成大写
System.out.println(s1.toUpperCase());//结果：____ABCDEFGAB__CDEFG____(_代表空格)
//将字符串转成小写
System.out.println(s1.toLowerCase());//结果：____abcdefgab__cdefg____(_代表空格)
//将字符串两端的多个空格去除
System.out.println(s1.trim());//结果：abcdefgAB__CDEFG
//对两个字符串进行自然顺序的比较
String s2 = "agbfd";
String s3 = "abd";
String s4 = "bde";
String s5 = "bde";
System.out.println(s2.compareTo(s3));//结果：5意味着s2>s3
System.out.println(s3.compareTo(s4));//结果：-1意味着s3练习一：（获取一个字符串在另一个字符串中出现的次数）
思路：
1.定义一个计数器；
2.获取某个字符串第一次出现的位置；
3.从第一次出现位置后剩余的字符串中继续获取kk出现的位置；
4.当获取不到时，计数完成。
代码实现：
class StringCount {
public static void main(String[] args) {
String s = "aabbddfeaadfeddaaeedfeaa";
int x = getSubCount_1(s, "aa");
System.out.println(x);
int y = getSubCount_2(s, "aa");
System.out.println(y);
}
public static int getSubCount_1(String s, String key) {
int count = 0;
int index = 0;
while((index = s.indexOf(key)) != -1) {
System.out.println("s="+ s);
s= s.substring(index + key.length());
count++;
}
return count;
}
public static int getSubCount_2(String s, String key) {
int count = 0;
int index = 0;
while((index = s.indexOf(key, index)) != -1) {
System.out.println("index="+ index);
index= index + key.length();
count++;
}
return count;
}
}运行结果：
s=aabbddfeaadfeddaaeedfeaa
s=bbddfeaadfeddaaeedfeaa
s=dfeddaaeedfeaa
s=eedfeaa
4
index=0
index=8
index=15
index=22
4
练习二：（获取两个字符串中最大相同子串）
思路：
1.将短的那个字符串按照长度递减的方式获取到；
2.将每次取得的子串去判断长的字符串中是否包含，如果包含，已经找到。
代码实现：
class MaxSubStringDemo {
public static void main(String[] args) {
String s = "aabbddfeaadfeddaaeedfeaa";
//dfeddaaee
String s2="dfeddaaeefdagagadgaga";
System.out.println(getMaxSubString(s,s2));
}
public static String getMaxSubString(String s1, String s2) {
String max = "", min = "";
max= (s1.length() > s2.length()) ? s1 : s2;
min= (max == s1) ? s2 : s1;
for(int x = 0; x < min.length(); x++) {
for(int y = 0, z = min.length() - x; z != min.length() + 1; y++, z++) {
String temp = min.substring(y, z);
//System.out.println(temp);
if(max.contains(temp))
return temp;
}
}
return "";
}
}运行结果：dfeddaaee
练习三：（对字符串中字符进行自然顺序排序）
思路：
1.字符串变成字符数组
2.对数组排序
3.将排序后的数组变成字符串
代码实现：
class StringDemo {
public static void main(String[] args) {
String s="gheiuhgagvihgkgvhdu";
char[] ch=s.toCharArray();
Arrays.sort(ch);
System.out.println(newString(ch));
}
}运行结果：adeggggghhhhiikuuvv
练习四：（模拟一个trim方法，去除字符串两端的空格）
思路：
1.判断字符串第一个位置是否为空格，如果是继续向下判断，直到不是空格为止，结尾处判断空格也是一样的；
2.当开始和结尾都判断到不是空格时，就是要获取的字符串
代码实现：
class StringDemo {
public static void main(String[] args) {
String s=" dfa fdsaf ";
System.out.println(s);
System.out.println(myTrim(s));//结果：dfa fdsa
}
public static String myTrim(String s){
int start=0,end=s.length()-1;
while(start<=end&&s.charAt(start)==' ')
start++;
while(start<=end&&s.charAt(end)==' ')
end--;
return s.substring(start, end);
}
}练习五：（将一个字符串进行反转，将字符串中指定部分进行反转）
思路：
1.将字符串变成数组，对数组反转
2.将反转后的数组变成字符串
3.只要将要反转的部分的开始和结束位置作为参数传递即可
代码实现：
class StringDemo {
public static void main(String[] args) {
String s = "adfdsafdedae";
System.out.println(s);
System.out.println(reverseString(s,0, s.length()-3));
}
public static String reverseString(String s, int start, int end) {
char[] chs = s.toCharArray();
reverse(chs,start, end);
return new String(chs);
}
private static void reverse(char[] arr, int x, int y) {
for(int start = x, end = y - 1; start < end; start++, end--) {
swap(arr,start, end);
}
}
private static void swap(char[] arr, int x, int y) {
char temp = arr[x];
arr[x] = arr[y];
arr[y] =temp;
}
}运行结果：
adfdsafdedae
edfasdfdadae
二、StringBuffer
1.特点：
·StringBuffer是字符串缓冲区
·字符串的组成原理就是通过该类实现的
·StringBuffer可以对字符串内容进行增删
·StringBuffer是一个容器
·很多方法与String相同
·StringBuffer是可变长度的
·最终会通过toString方法变成字符串
2. StringBuffer类的常用方法：
◆存储
StringBufferappend()——将指定数据作为参数添加到已有数据结尾处
StringBufferinsert(int index,data)——可以将data插入到指定index位置
示例：
class StringBufferDemo {
public static void main(String[] args) {
StringBuffer sb1=new StringBuffer("abcdefg");
//在sb1结尾处添加数据add
sb1.append("add");
System.out.println(sb1); //结果：abcdefgadd
//从sb1的第三个脚本开始插入insert
sb1.insert(3,"insert");
System.out.println(sb1); //结果：abcinsertdefgadd
}
}◆删除
StringBuffer delete(intstart,int end)——删除缓冲区中的数据，包含start，不包含end
StringBufferdeleteCharAt(index)——删除指定位置的字符
示例：
class StringBufferDemo {
public static void main(String[] args) {
StringBuffer sb1 = new StringBuffer("abcdefghijklmn");
//删除脚标为5的元素
sb1.deleteCharAt(5);
System.out.println(sb1); // 结果：abcdeghijklmn
//删除脚标从2到4的元素
sb1.delete(2,5);
System.out.println(sb1); // 结果：abghijklmn
}
}◆获取
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start, int end)
这几个功能与String用法相同，不再举例说明
◆修改
String Bufferreplace(start,end,string)
void setCharAt(int index, char ch)
示例：
class StringBufferDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("abcdefghijk");
//将脚本从1到8的数据换成abc
sb.replace(1,9, "abc");
System.out.println(sb); // 结果：aabcjk
//将脚标为0的数据替换成r
sb.setCharAt(0,'r');
System.out.println(sb); // 结果：rabcjk
}
}◆反转
String Bufferreverse()
示例：
class StringBufferDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("abcdefghijk");
System.out.println(sb);
System.out.println(sb.reverse());
}
}运行结果：
abcdefghijk
kjihgfedcba
◆将缓冲区中指定数据存储到指定字符数组中
voidgetChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
示例：
class StringBufferDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("abcdefghijk");
char[] ch = new char[] { 'q', 'w', 'e', 'r', 't', 'y', 'u' };
//将sb中脚标从2到3的元素替换到ch中，ch从脚标为2开始替换，如果替换额长度超过了char数组的话，报出异常
sb.getChars(2,4, ch, 2);
System.out.print("[");
for(int x = 0; x < ch.length; x++) {
if(x != ch.length - 1)
System.out.print(ch[x]+ ",");
else
System.out.println(ch[x]+ "]");
}
}
}运行结果：
[q,w,c,d,t,y,u]
总结：
StringBuffer类特有的方法：
StringBuffer append(int x);
StringBuffer delete(int start,int end);
StringBuffer insert(int index,String str);
StringBuffer reverse();
JDK1.5出现一个StringBuilder，区别是StringBuffer是同步的，StringBuilder是非同步的。
建议在以后开发中使用StringBuilder。
三、基本数据类型对象包装类
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
·将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能来操作数据
·常用的操作：用于基本数据类型与字符串之间的转换
◆基本数据类型转换成字符串：
1.基本数据类型+””;
2.基本数据类型.toString(基本数据类型值);
比如：Integer.toStirng(45);//将45整数转成字符串”34”
◆字符串转成基本数据类型
Typea=Type.parseType(String);
int a=Integer.parseInt(“123”);
double b=Double.parseDouble(“123”);
boolean b=Boolean.parseBoolean(“true”) ;
Integer i = new Integer("123");
intnum = i.intValue();
◆十进制转成其他进制
String toBinaryString()——转成二进制
String toHexString()——转成十六进制
String toOctalString()——转成八进制
◆其他进制转成十进制
int parseInt(String,radix)
例如：
parseInt("0",10) 返回 0
parseInt("1100110",2) 返回 102
parseInt("-FF",16) 返回 -255
基本数据类型对象包装类新特性：
JDK1.5以后，简化了定义方式
Integer x=new Integer(4);//可以直接写成
Integer x=4;//自动装箱
x=x+5;//自动拆箱，通过intValue方法
示例：
IntegerDemo {
public static void main(String[] args) {
Integer x = new Integer(4);
Integer z = new Integer(4);
System.out.println(x== z);// 结果：false——这是两个对象
System.out.println(x.equals(z));//结果：true——值相等
System.out.println(x);//结果：4
Integer y = 4;
System.out.println(y);//结果：4
System.out.println(x== y);// 结果：flase
System.out.println(x.equals(y));//结果：true
//x = x.intValue() + 2;
x= x + 2;// 进行自动拆箱，变成int类型，再和2进行加法运算，再将结果进行装箱赋给x
System.out.println(x);//结果：6
y= y + 2;
System.out.println(y);//结果：6
Integer a = 12;
Integer b = 12;
System.out.println(a== b);// 结果为true。因为a和b指向了同一个Integer对象
Integer m = 128;
Integer n = 128;
System.out.println(m== n);// 结果为false。因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。
}
}需要注意：在使用时，Integer x=null;上面的代码就会出现NullPointException