黑马程序员——学习日记之--String类常用方法示例

——- android培训、java培训、期待与您交流！ ———-

1—String简述

特点：

(1)String是类类型变量。

(2)String类是final类，一旦赋值就不能被改变。

(3)字符串是由字符组成的，可以看成是字符数组。

(4)字符串在内存中存储在常量池中。

(5)凡是被双引号圈起来的内容全是字符串常量。

String在内存中的特点：

看下面两条语句：

String s1="abc";
String s2=new String("abc");

如果内存中没有字符串常量”abc”，s1会新建一个常量并指向它。

如果内存中已经有常量”abc”,s1就不再新建，而是直接指向该常量。

而第二条语句 s2，不论内存中有没有该常量，都新建一个。

String的比较方法 equals ：

boolean b1= s1==s2;
boolean b2= s1.equals(s2);

第一句，因为s1和s2存储的是字符串的地址，所以比较的也是两个字符串的地址。

第二句中，因为String 复写了equals方法，所以这里比较的是两个字符串内容是否相同。

注意：

字符串s1指向”abc”,字符串s2指向一个new对象，对象指向一个字符串常量。

2—字符串常见方法

常用构造方法：

String()                    //无参构造函数
String(s)                   //新建一个字符串。
String(char [])             //用全部字符数组元素顺序组成一个字符串。
String(char [],offset,len)  //用部分字符数组元素顺序组成一个字符串。
String(byte [])             //用全部字节数组元素顺序组成一个字符串。需要解码为字符。
String(byte [],offset,len)  //用部分字节数组元素顺序组成一个字符串。需要解码为字符。

常用方法：

boolean  s.equals(Object oo)    //将字符串与指定对象比较。
boolean  s.equalsIgnoreCase(str)//将字符串与指定对象比较并忽略大小写。
boolean  s.contains(str)        //判断字符串是否包含指定字符串。
boolean  s.isEmpty()            //判断字符串是否为空字符串。
boolean  s.startsWith(str)      //判断字符串是否以指定字符串开头。
boolean  s.endsWith(str)        //判断字符串是否以指定字符串结尾。

char    charAt(index)           //获取字符串在指定角标位的字符。
int     s.length()              //获取字符串的长度。
int     s.indexOf(str)          //获取s中str的开头角标位，不存在返回-1 。
int     s.indexOf(str,from)     //获取s中从指定角标开始的str的角标位。
int     s.lastIndexOf(str)      //逆向获取角标位。
int     s.compareTo(str)        //比较两字符串的每个字符，如果全相等，返回0。
String  s.substring(index)      //截取字符串，从指定位置到结尾。
String  s.substring(from,to)    //截取指定始末角标的字符串。
String  s.toLowerCase()         //字符串转成全小写。
String  s.toUpperCase()         //字符串转成全大写。
String  s.trim()                //字符串去掉首尾的多个空格。
String  s.concat(str)           //将指定字符串连接到当前字符串。
String  s.replace(char1,char2)  //将字符串中的char1替换为char2。
String  s.replace(str1,str2)    //将字符串中的str1替换为str2。
String  String.valueOf(Object oo)//获取对象的字符串表示形式。

String      s.replaceAll(reg,str)   //将符合正则规则的字符串替换成str。
char []     s.toCharArray()         //将字符串转成字符数组。
byte []     s.getBytes()            //将字符串转成字节数组。
String []   s.split(reg)            //将符合正则规则的字符串作为切割符，切割成字符串数组。
boolean     s.matches(reg)          //判断字符串是否与正则表达式匹配。

字符串的常用获取功能。

class Demo
{
public static void main(String [] args)
{
String s="abcdabcd";
System.out.println(s.length());         //打印字符串长度。8
System.out.println(s.charAt(4));        //打印字符串4角标位上的字符。a
System.out.println(s.indexOf('a'));     //打印a字符第一次出现的角标位。0
System.out.println(s.indexOf('a',2));   //打印a字符从2角标位以后第一次出现的位置。4
System.out.println(s.lastIndexOf('a')); //打印a字符从右往左第一次出现的位置。4
System.out.println(s.substring(2));     //截取子字符串，从2角标到末尾。cdabcd
System.out.println(s.substring(2,5));   //截取子字符串，从2角标到5角标。cda
System.out.println(s.compareTo("abc")); //比较两个字符串，返回一个正整数。5
System.out.println(s.concat("abc"));    //打印两字符串连接起来的字符串形式。abcdabcdabc
System.out.println(s.trim());           //打印字符串去掉首尾空格的表示形式。abcdabcd
System.out.println(s.replace('a','A')); //打印替换所有a字符的新字符串。AbcdAbcd
System.out.println(s.replace("cd","CD"));//打印替换所有cd字符串的新字符串。abCDabCD
System.out.println(String.valueOf(s));  //打印s的字符串表示形式。abcdabcd
}
}

注意：

s.length() 一定要加括号，这和数组的length不同。

lastIndexOf(str) 虽然是反向索引字符串，但返回的还是找到的子字符串的开头角标位。

(3)substring(from) 只有一个参数时，截取的是从from到末尾的新字符串。注意此方法名全小写。

(4)s.compreTo(str) 该方法返回整数，只有在两字符串相等时，才返回0，

否则返回第一个对应字符不相等的ASCII码整数差。

如：abcd 与 abad 第三个字符不相等，并且c比a的ASCII码整数大2，所以返回2.

(5)字符串是final类，所有返回字符串的方法放回的都是一个新字符串。

知识点：

–模拟 trim方法，去掉字符串两端空格

class Demo
{
public static void main(String [] args)
{
String s="   ni hao   ";
System.out.println(myTrim(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);
}
}

注意：

截取字符串时，两个参数包含头不包含尾。

字符串的常用判断功能，如下示例：

class Demo
{
public static void main(String [] args)
{
String s="Demo.java";
System.out.println(s.isEmpty());            //s是否为空，false
System.out.println(s.contains("java"));     //s是否包含java，true
System.out.println(s.startsWith("Demo"));   //s是否以Demo开头，true
System.out.println(s.endsWith(".java"));    //s是否以 .java 结尾，true
System.out.println(s.equals("demo.java"));  //s是否内容和demo.java 相等，false
System.out.println(s.equalsIgnoreCase("demo.java"));//不区分大小写时s是否和demo.java 相等，true
}
}

字符串中的常用转换功能，如下示例：

class Demo
{
public static void main(String [] args)
{
char [] chArr={'a','b','c','d','e','f'};
String s1=new String(chArr);
String s2=new String(chArr,2,3);    //从0+2角标开始，取三个数组元素组成字符串。
System.out.println(s1.toUpperCase());//打印s1的大写表示形式。
System.out.println(s2);

char [] ch=s2.toCharArray();        //将字符串转成字符数组。

byte [] byteArr={11,26,48,56,67,78,89};
String s3=new String(byteArr);
String s4=new String(byteArr,2,4);
System.out.println(s3);
System.out.println(s4);
}
}

字符串切割功能。

(1)字符串切割是以指定的字符串作为切割符，把字符串切成短字符串，并添加到一个字符串数组中。

(2)切割符是一种正则规则，这里只简单看做一个短字符串，不考虑复杂的正则规则。

字符串切割方法示例：

class Demo
{
public static void main(String [] args)
{
String s="zhangsan,lisi,wangwu,zhaoliu";
String [] arr=s.split(","); //对包含多个姓名的字符串切割分段成每个姓名字符串。
for (String str : arr)      //高级for 循环
{
System.out.println(str);
}
}
}

注意：
(1)切割符如果是小数点，需要转义字符转义。

(2)高级for循环是for循环的一种简写形式。

(3)split方法实际传递的参数是正则表达式。

3—扩展知识

StringBuilder ：字符串缓冲区。

特点：长度可变，可以添加字符串以及一系列操作。

常用方法：

int   sb.length()               //缓冲区的长度
int   sb.indexOf(str)           //str在缓冲区中第一次出现的位置索引
int   sb.indexOf(str,from)      //str在缓冲区中指定角标以后第一次出现位置的索引
char  sb.charAt(index)          //缓冲区指定角标上的字符

StringBuilder   sb.reverse()                //将缓冲区内容反转
StringBuilder   sb.append(Object oo)        //缓冲区添加元素
StringBuilder   sb.delete(start,end)        //缓冲区指定角标的内容删除
StringBuilder   sb.deleteCharAt(index)      //删除缓冲区指定角标上的字符
StringBuilder   sb.insert(offset,Object oo) //从起始位偏移指定长度插入一个元素
StringBuilder   sb.replace(start,end,str)   //将缓冲区中指定始末的内容替换成字符串str

String  sb.substring(start)         //从指定位置截取字符串内容并返回新的缓冲区
String  sb.substring(start,end)     //从指定始末位置截取字符串返回到新的缓冲区
String  sb.toString()               //缓冲区的字符串表示形式

StringBuilder 方法示例：

class Demo
{
public static void main(String [] args)
{
StringBuffer sb=new StringBuffer();
sb.append("123");           //添加一个字符串
sb.append(987);             //添加一个整数值
sb.append(true);            //添加一个布尔值

System.out.println(sb.length());        //打印缓冲区长度
System.out.println(sb.toString());      //打印缓冲区字符串表示形式
System.out.println(sb.delete(0,3));     //删除0,1,2角标的字符

System.out.println(sb.replace(3,7,"false"));//替换3,4,5,6角标 "true" 为"false"。
System.out.println(sb.insert(0,"AAA"));     //从0角标插入字符串
System.out.println(sb.substring(6));        //截取字符串打印
}
}

注意：
(1)StringBuilder 也是可以直接打印的，但是需要用String类型时，需要转成 String 。

(2)添加的元素都以字符串表示。

StringBuffer: 字符串缓冲区。

StringBuffer 和 StringBuilder 用法基本一致。

区别： StringBuffer是线程安全的，但是效率低；

StringBuilder 是线程不安全的，但是效率比较高。

一般使用 StringBuilder 。

4—String 练习

练习一：

将字符串指定部分反转。

先将要反转的部分取出，然后反转，然后replace替换。

class Demo
{
public static void main(String [] args)
{
String str="abcd1234abcd";
String s=reverse(str,4,7);
System.out.println(s);
}
public static String reverse(String str,int start,int end)
{
String s=str.substring(start,end+1);    //截取字符串包含头不包含尾，所以要多截取一位。
StringBuilder sb=new StringBuilder();   //新建一个字符缓冲区。
for (int x=0;x<s.length();x++)
{
sb.append(s.charAt(x));             //往字符缓冲区添加元素。
}
return str.replace(s,sb.reverse().toString());    //返回原字符串替换后的字符串。
}
}

练习二：

获取一个字符串在另一个字符串中出现的次数。

class Demo
{
public static void main(String [] args)
{
String str="nidnshiwodnsdeshednsme";
System.out.println(time(str,"dns"));
}
public static int time(String str,String s)
{
int index=0,count=0;
while (index!=-1)
{
count++;
index=str.indexOf(s,index+s.length());
}
return count;
}
}

练习三：

获取两个字符串中最大相同子串

class Demo
{
public static void main(String [] args)
{
String str="chfoyhellodutjg";
String s="dofhelloxga";
System.out.println(time(str,s));
}
public static String time(String str,String s)
{
int L = s.length();
String s0=s;
while (str.indexOf(s0)==-1)  //当不是整串包含时，才会进入循环。
{
L--;
for (int n=0;n+L<=s.length();n++)
{
s0=s.substring(n,n+L);
if (str.indexOf(s0)!=-1)
return s0;      //这里返回的只有一个字符子串，也有可能包含相同长度的多个字串。
}
}
return s;                  //如果原字符串包含在另一个字符串，就会在这里直接返回。
}
}