黑马程序员——java学习7(152-165)——String类和StringBuffer,StringBuilder

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1、字符串String

是一个对象，

最大特点，一旦被初始化，就不可被改变，即使改变，只是指针改变

常量池中已经存在的数据，不会再开辟空间，即第二个"abc"是指向同一个对象

1.1、获取

　　1.1.1字符串中的包含的字符数，也就是字符串的长度

　　　　int length();获取长度

　　1.1.2根据位置获取位置上某个字符

　　　　char charAt(int index);

　　1.1.3根据字符获取该字符在字符串中位置

　　　　int indexof(int ch): 返回的是ch在字符串中第一次出现的位置

　　　　int indexof(int n,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置

　　　　int indexof(String str): 返回的是str在字符串中第一次出现的位置

　　　　int indexof(String str,int fromIndex): 从fromIndex指定位置开始，获取str在字符串中出现的位置

　　　　int lastIndexof(int ch): 倒叙获取位置

1.2、判断

　　1.2.1、字符串中是否包含某一个子串

　　　　boolean contains(str)

　　　　特殊之处: indexOf(str)可以索引str第一次出现位置，如果返回-1,表示该str不在字符　　　　串中存在，所以，也可用于对指定判断是否包含

　　　　if(str.indexOf("aa")!=-1)

　　　　而且该方法既可判断，也可以获取出现位置

　　1.2.2、字符串中是否有内容

　　　　boolean isEmpty();原理就是判断长度是否为0

　　1.2.3、字符串是否是以指定内容开头

　　　　boolean startsWith(str);

　　1.2.4、字符串是否是以指定内容结尾

　　　　boolean endsWith(str);

　　1.2.5、判断字符串内容是否相同。覆写Object类中的equals方法

　　　　boolean equals(str)

　　1.2.6、判断内容是否相同，并忽略大小写

　　　　boolean equalsIgnoreCase();

1.3转换

　　1.3.1、将字符数组转成字符串

　　　　　　构造函数: String(char[])

　　　　　　　　　　　String(char[],offset ,count)：将字符数组中的一部分转成字符串

　　　　　　静态方法：static String copyValueOf(char[]);

　　　　　　　　　　　static String copyValueOf(char[] data,int offset,int count)

　　　　　　　　　　　static String valueOf(char[]);

　　1.3.2、将字符串转成字符数组

　　　　char[] toCharArray();

　　1.3.3、将字节数组转成字符串

　　　　String(byte[])

　　　　String(byte[],offset,count)：将字节数组中的一部分转成字符串

　　1.3.4、将字符串转成字节数组

　　　　byte[] getBytes();

　　1.3.5、将基本数据类型转成字符串

　　　　　static String valueOf(int)

　　　　　static String valueOf(double)

1.4、替换

　　String replace(old char,newchar)

返回的是新串，原串不变

替换的字符不存在，返回原串

1.5、切割

　　String[] split(regex);

1.6、子串

获取字符串的一部分

　　String subString(begin);//从指定位置到尾

　　String subString(begin,end);//包含头，不包含尾,所以整串是0到String.length

1.7、转换，去空格，比较

　　1.7.1、将字符串转成大写或小写

　　　　String toUpperCase();

　　　　String toLowerCase();

　　1.7.2、将字符串两端的多个空格去掉

　　　　String trim()

　　1.7.3、对两个字符串进行自然顺序的比较

　　　　int compareTo(string);

package learn;
/*
* 获取两个字符串的最大相同子串
* 将短的串长度依次递减打印
* */
public class StringTest3 {
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<max.length();x++)
{
for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)
{
String temp=min.substring(y,z);
//                sop(temp);
if(s1.contains(temp))//if(s1.indexof(temp)!=-1)
return temp;
}
}
return "";
}
public static void main(String[] args) {
String s1="abcwerthelloyuiodef";
String s2="cvhellobnm";
sop(getMaxSubString(s1,s2));
}
public static void sop(String str)
{
System.out.println(str);
}
}

1.8、StringBuffer

是字符串缓冲区，是一个容器。

特点

（1）长度可变化

（2）可以字节操作多个数据类型

（3）最终会通过toString方法编程字符串

1.8.1.存储

　　StringBuffer append(): 将指定数据作为参数添加到已有数据结尾处

　　StringBuffer insert(index,任意数据类型);可以将数据插入到指定index位置

1.8.2.删除

　　StringBuffer delete(start,end): 删除缓冲区中的数据，包含start,不含end

　　StringBuffer deleteCharAt(index): 删除指定位置的字符

1.8.3.获取

　　char charAt(int index);

　　int indexOf(String str);

　　int lastIndexOf(String str);

　　int length();

　　String substring(int start,int end)

1.8.4.修改

　　StringBuffer replace(start,end,string)

　　void setCharAt(ine index,char ch)

1.8.5.反转

　　StringBuffer reverse();

1.8.6、将缓冲区中的指定数据，存储到指定数组中

　　getChar(int srcBegin, int srcEnd, char[] dst, int dstBegin);

JDK1.5后出现了StringBuilder,不同在于StringBuffer线程同步，StringBuilder线程不同步

package learn;

public class StringBufferDemo {
public static void main(String[] args)
{
StringBuffer sb=new StringBuffer();
sb.append("abc").append(true).append(34);

sb.insert(1,"qq");
sop(sb.toString());
}
public static void sop(String str)
{
System.out.println(str);
}
}

1.9、升级三因素

　　(1)提高效率

　　(2)简化书写

　　(3)提高安全性

2、基本数据类型对象包装类

int Integer

char Character

其他都是首字母大写

最常见作用

就是用于基本数据类型和字符串之间做转换

基本数据类型转成字符串

　　基本数据类型+""

　　基本数据类型.toString(基本数据类型值);

　　如:Integer.toString(34);//将34转成"34"；

字符串转成基本数据类型

　　xxx a = Xxx.parseXxx(String);//静态调用方式

　　int a = Int.parseInt("123");

　　double b = Double.parseDouble("12.23");

　　boolean b = Boolean.parseBoolean("true");

　　Integer i = new Integer("123");//非静态，对象调用方式

　　int num = i.intValue();

十进制转成其他进制

　　toBinaryString();

　　toHexString();

　　toOctalString();

其他进制转成十进制

　　parseInt(String,radix);

package learn;

public class IntegerDemo {
public static void main(String[] args) {
Integer x=4;
x=x/*x.intValue()*/+2;//进行了自动拆箱，相加，自动装箱赋给x
Integer m=128;
Integer n=128;
sop("m==n:"+(m==n));//false

Integer a=127;
Integer b=127;
sop("a==b:"+(a==b));//true 因为a和b只想了同一个对象
//因为当数值在byte范围内，对于新特性，该数值已经存在，则不会开辟新空间
}
public static void sop(String str)
{
System.out.println(str);
}

}