黑马程序员— 4000 —Java要点笔记——String类

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

String类-StringBuffer类-StringBuilder类
day15 01-常用对象API（String类-特点）
1、String类的特点：字符串的内容一旦被声明，则不可改变。
2、代码示例
public class Demo24 {
public static void main(String[] args) {
String str = "Hello";
str += "World";
str = str + "!!!";
System.out.println(str);
}
}
运行结果：Hello World！！！
2、图解







实际上，每一次str进行字符串连接的操作时都会存在垃圾。并且字符串的内容没有任何改变。改变的只是字符串的内存地址指向。以上一段程序，一共生成了5段字符串。
3、字符串常量是String类的匿名对象。
4、观察以下代码
public class Demo24 {
public static void main(String[] args) {
String str1 = "abc";
String str2 = new String("abc");
System.out.println(str1==str2);
System.out.println(str1.equals(str2));
}
}
运行结果：
    false
    true
5、String类中的equals方法，覆写了Object类中的equals方法。String类中的equals方法——比较字符串的内容。Object类中的equals方法——比较的是地址。
6、String str = new String("abc");这句话产生几个字符串对象？
    答：
day15 02-常用对象API（String类-构造函数）
1、String类的构造方法
（1）String()
         初始化一个新创建的String对象，使其表示一个空字符序列。
         String s=new String();等效于String s=””;但不等效于String s=null;
（2）String(byte[] bytes, int  offset, int  length)
    String(int[]  codePoints, int  offset, int length)
    String(char[]  value, int  offset, int length)
    String(byte[]  bytes)
    String(char[]  bytes)
     代码示例：
public class Demo24 {
public static voidmain(String[] args) {
byte[] b = {97,98,99,100};
String s1 = new String(b,1,3);
System.out.println("s1= "+s1);

int[] i = {97,98,99,100};
String s2 = new String(i,1,3);
System.out.println("s2= "+s2);

char[] c1= {97,98,99,100};
String s3 = new String(c1,1,3);
System.out.println("s3 = "+s3);

char[] c2 = {e,f,g,h};
String s4 = new String(c2,1,3);
System.out.println("s4 = "+s4);

String s5 = newString(b);
System.out.println("s5 = "+s5);

String s6 = newString(c);
System.out.println("s6 = "+s6);
}
}
运行结果：
s1 = bcd
s2 = bcd
s3 = bcd
s4 = fgh
s5 = abcd
s6 =abcd
（3）String(String original)
    String(StringBuffer buffer)
    String(StringBuilder builder)
day15 03~07常用对象API（String类-常见功能-获取）
①  、获取
1.1、获取字符串中字符的个数（长度）
    int length()
    注解：与取数组的长度进行区分：取数组的长度，直接数组名.length;取字符串的长度，用字符串.length();
1.2、根据位置获取字符
    char charAt(int index)
1.3、根据字符/字符串 获取在字符串中的位置
    int indexOf(int ch) 'a'能索引，int 97也能索引
    int lastIndexOf(int ch)
    intindexOf(int ch,int fromIndex)
    intlastIndexOf(int ch,int fromIndex)
 
    int indexOf(String str)
    intlastIndexOf(String str)
    int indexOf(String str,int fromIndex)
    intlastIndexOf(String str,int fromIndex)
1.4、获取字符串中的一部分字符串，也叫字串
    String subString(int beginIndex,int endIndex)
    StringsubString(int beginIndex)
    注解：beginIndex——起始索引（包括）；endIndex——结束索引（不包括）
②转换
2.1、将字符串变成字符串数组（字符串的切割）
    String[] split(String regex)
    注解：根据给定的正则表达式的匹配，拆分此字符串
2.2、将字符串打散成字符数组
    char[] toCharArray()
2.3、再往碎了打，打成最小单位——字节。将字符串变成字节数组。
    byte[] getBytes()
2.4、将字符串中的字母进行大小写转换
    String toUpperCase()
    注解：小写转大写
    String toLowerCase()
    注解：大写转小写
2.5、将字符串中指定的内容进行替换
    String replace(char oldChar,char newChar)
    注解：字符替换、全部替换
    String replaceAll(String regex,String replacement)
    注解：字串替换、全部替换（即使前后长度不一致，也可替换）
    String replaceFirst(String regex,String replacement)
    注解：字串替换、第一个替换（即使前后长度不一致，也可替换）
2.6、去头去尾的空格
    String trim()
2.7、将字符串进行连接
    String concat(String str)
2.8、把基本数据类型变成字符串
    valueOf系列的方法
    注解：String类的静态函数，直接用类名调用即可。
③判断
    3.1、判断两个字符串的内容是否相同
    boolean equals(Object obj)
    booleanequalsIgnoreCase(String anotherString)忽略大小写判断
    3.2、字符串中是否包含指定字符串
    boolean contains(String str)
    3.3、字符串是否以指定字符串开头，是否以指定字符串结尾
    boolean startsWith(String prefix)
    booleanendsWith(String suffix)
④比较（比较与判断有什么区别？判断只有对错，但是比较有3个结果——大于、小于、相等）
int compareTo（String anotherString）
    注解：返回-如果参数字符串等于此字符串，返回0
             如果此字符串按字典顺序小于字符串参数，返回一个小于0的值
             如果此字符串案子点顺序大于字符串参数，返回一个大于0的值
       可以理解为：主串 - 被比串
       无需关注返回的数值本身，只需关注“正、负、零”即可。
day15 08常用对象API（String类-intern方法）
1、String intern()
    当调用intern方法时，如果池中已经包含一个等于此String对象的字符串（通过equals方法确定），则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用。
2、代码示例
public class Demo31 {
public static void main(String[] args) {
String s1 = "abc";
String s2 = s1.intern();
System.out.println(s1==s2);
}
}
运行结果：false
day15 09常用对象API（String类-练习1-字符串数组排序）
1、练习1：给定一个字符串数组，按照字典顺序进行从小到大的排序
    {"nba","abc","cba","zz","qq","haha"}
2、思路：
①、对数组排序。可以用选择，冒泡都行。

②、for嵌套和比较以及换位。

③、问题：以前排的是整数，比较用的比较运算符，可是现在是字符串对象。

  字符串对象怎么比较呢？爽了，对象中提供了用于字符串对象比较的功能。

3、代码示例
public class Demo31 {
public static void main(String[] args) {
String[] arr = {"nba","abc","cba","zz","qq","haha"};
printArray(arr);
}
public static void printArray(String[] arr){
System.out.print("{");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1)
System.out.print(arr[i]+",");
else
System.out.print(arr[i]+"}");
}
}
public static void sort(String[] arr){
for(int i=0;i<arr.length;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i].compareTo(arr[j]) > 0){
swap(arr,i,j);
}
}
}
}
public static void swap(String[] arr,int i,int j){
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
day15 10常用对象API（String类-练习2-子串的次数）
1、练习2：一个子串在整串中出现的次数。
"nbaernbatynbauinbaopnba"

2、思路：

①要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。

②如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，而剩余字符串的起始位是出现位置+子串的长度.

③以此类推，通过循环完成查找，如果找不到就是-1，并对每次找到用计数器记录。

3、代码示例
public class Demo32 {
public static void main(String[] args) {
String str = "nbaernbatynbauinbaopnba";
String key = "nba";
int count = getKeyStringCount(str,key);
System.out.println("count= "+count);
}
public static int getKeyStringCount(String str,String key){
int count = 0;
int index = 0;
while((index = str.indexOf(key, index))!=-1){
index = index + key.length();
count++;
}
return count;
}
}
day15 11常用对象API（String类-练习3-最大相同子串）
1、练习3：两个字符串中最大相同子串
2、思路：
1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。如果存在，短的那个字符串就是最大子串。

2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。

  如果存在就已找到，就不用在找了。
3、子串例子
xcabcdvbn
len = 9    xcabcdvbn
len = 8    xcabcdvb   cabcdvbn
len = 7    xcabcdv    cabvdvb    abcdvbn
……
4、代码示例
public class Demo33 {
public static void main(String[] args) {
String s1 = "qwerabcdtyuiop";
String s2 = "xcabcdvbn";
String s = getMaxSubstring(s1,s2);
System.out.println("s= "+s);
}
public static String getMaxSubstring(String s1, String s2) {
//此处应该加一个判断，谁是大的是谁小的
String max = null,min = null;
max = (s1.length()>s2.length())?s1:s2;
min = max.equals(s1)?s2:s1;
System.out.println("max="+max);
System.out.println("min="+min);

for (int i = 0; i < min.length(); i++) {
for(int a = 0,b = min.length()-i; b != min.length()+1;a++,b++){ String sub = min.substring(a, b);
// System.out.println(sub);
if(max.contains(sub))
return sub;
}
}
return null;
}
}
day15 12常用对象API（String类-练习4-去除两端空白）
1、练习4：模拟一个trim功能一致的方法。去除字符串两端的空白。
2、思路
  1，定义两个变量。 一个变量作为从头开始判断字符串空格的角标。不断++。一个变量作为从尾开始判断字符串空格的角标。不断--。

  2
c125
,判断到不是空格为止，取头尾之间的字符串即可。

3、代码示例
public class Demo34 {
public static void main(String[] args) {
String s = " ab c ";
s = myTrim(s);
System.out.println("-" + s + "-");
}
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);
}
}
day15 09常用对象API（StringBuffer类-特点&增）
1、StringBuffer（字符串缓冲区）——他是一个线程安全的可变字符序列。用于存储数据的容器。
2、StringBuffer类的特点：
    ①、长度是可变的
    ②、可以存储不同类型的数据
    ③、最终要转变成字符串进行使用。
    ④、可以对字符串进行修改。
3、StringBuffer 类——“增”
    方法(1)：StringBuffer append(数据)——依次往后面贴
    方法(2)：StringBuffer insert(插入的位置,数据)
4、代码示例append方法
public class Demo25 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
StringBuffer s1 = sb.append(4);
System.out.println(sb);
System.out.println(s1);
System.out.println(sb==s1);

sb = sb.append(4).append(false);
System.out.println(sb);
}
}
运行结果：4 4   true   4falsehaha
5、代码示例insert方法
public class Demo26 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("abcd");
sb.insert(1,"qq");
System.out.println(sb);
}
}
运行结果：aqqbcd
6、StringBuffer和String的区别
    StringBuffer类和String类一样，也用来代表字符串，只是由于StringBuffer的内部实现方式和String不同，所以StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类（String类是一旦声明，其内容不可被改变）。
    所以在实际使用时，如果经常需要对一个字符串修改，例如：插入、删除等操作，使用StringBuffer要更加合适一些。
    在StringBuffer类中还存在很多和String类一样的方法，这些方法在功能上和String类中的功能是完全一样的。
    但是有一个最显著的区别在于，对于StringBuffer对象的每次修改都会改变对象自身。这点是和String类的最大区别。
    另外由于StringBuffer是线程安全的（关于线程的概念，后续有专门的章节进行介绍），所以在多线程中也可以很方便的进行使用。但是程序的执行效率相对来说就要稍微慢一些。
day15 10常用对象API（StringBuffer类-删&改&查）
1、StringBuffer类——删
    方法（1）：StringBuffer delete(start,end)——删除一段数据，包含头，不包含尾
    方法（2）：StringBuffer deleteCharAt(int index)——删除单个数据（指定位置的元素）
2、代码示例delete方法
public class Demo27 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("abcd");
sb = sb.delete(1, 3);
System.out.println(sb);
}
}
运行结果：ad
3、清空缓冲区
    （1）sb.delete(0,sb.length());——更靠谱
    （2）sb = new StringBuffer();
4、StringBuffer类——改
    方法（1）：StringBuffer replace(start,end,String)——包含头，不包含尾
    方法（2）：void setCharAt(int index,char ch)
5、代码示例replace方法
public class Demo27 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("abcd");
sb = sb.replace(1, 3, "nba");
System.out.println(sb);
}
}
运行结果：anbad
6、代码示例setCharAt
public class Demo27 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("abcd");
sb.setCharAt(2,'q');
System.out.println(sb);
}
}
代码示例：abqd
7、StringBuffer类——查
    方法（1）：char charAt(index)
    方法（2）：int indexOf(String)
    方法（3）：int lastIndexOf(String)
8、StringBuffer类其他方法
    方法（1）：void setLength(int newLength)——设置StringBuffer这一长度可变数组的长度
    方法（2）：StringBuffer reserve()——反转StringBuffer
9、代码示例——setLength方法
public class Demo27 {
public static void main(String[] args) {
int i = 0;
StringBuffer sb = new StringBuffer("abcd");
sb.setLength(i);
System.out.println("sb="+sb+";length="+sb.length());
}
}
当i=0时，运行结果：sb=; length=0
    当i=2时，运行结果：sb=ab; length=2
    当i=10时，运行结果：sb=abcd__________; length=10 (d后面有6个空格)
10、操作容器，删除时，一般离不开deleteXXX或removeXXX。
11、delete和remove有什么区别？
    答：delete是删除，不存在，相当于从硬盘中彻底抹去。
       remove是移除，但还存在，相当于拉到回收站。
       QQ的话，delete相当于从列表中清除，remove相当于黑名单。
day15 11常用对象API（StringBuffer类-可变长度数组）
1、数组必须是固定长度，可变长度数组的原理



2、StringBuffer()，初始容量为16个字符
day15 12常用对象API（StringBuilder类）
1、StringBuilder和StringBuffer是一回事，功能一模一样，用法一模一样。那为什么要造StringBuilder呢？
    答：StringBuffer是线程同步的，通常用于多线程，安全。
StringBuilder是线程不同步的，通常用于单线程，不用每次判断同步锁，它的出现是为了提高效率。
day15 13常用对象API（StringBuilder类-练习）
1、将一个int数组变成字符串
2、代码示例（1）——字符串连接
public static String arrayToString(int[] arr){
String str = "[";
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1){
str+=arr[i]+",";
}else{
str+=arr[i]+"]";
}
}
return str;
}
3、代码示例（2）——StringBuffer连接
public static String arrayToString(int[] arr){
StringBuffer sb = new StringBuffer();
sb.append("[");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1){
sb.append(arr[i]+",");
}else{
sb.append(arr[i]+"]");
}
}
return sb.toString();
}
4、用StringBuffer更好。字符串只要新加一个东西，就在池中产生一个新字符串，而StringBuffer自始至终只是一个容器，最后才变成一个字符串，整个输出出来。
附：StringBuffer类重点方法总结
1、StringBuffer 类——“增”
    方法(1)：StringBuffer append(数据)——依次往后面贴
    方法(2)：StringBuffer insert(插入的位置,数据)
2、StringBuffer类——删
    方法（1）：StringBuffer delete(start,end)——删除一段数据，包含头，不包含尾
    方法（2）：StringBuffer deleteCharAt(int index)——删除单个数据（指定位置的元素）
3、StringBuffer类——改
    方法（1）：StringBuffer replace(start,end,String)——包含头，不包含尾
    方法（2）：void setCharAt(int index,char ch)
4、StringBuffer类——查
    方法（1）：char charAt(index)
    方法（2）：int indexOf(String)
    方法（3）：int lastIndexOf(String)
5、StringBuffer类其他方法
    方法（1）：void setLength(int newLength)——设置StringBuffer这一长度可变数组的长度
    方法（2）：StringBuffer reserve()——反转StringBuffer