JAVA学习之 34-JAVA中的字符串知识点整理(一)

旧城等待， 2022-06-14 05:55 103阅读 0赞

在前面我们接触过char类型，它只能表示单个字符，不能表示由多个字符连接而成的字符串，在JAVA语言中将字符串作为对象来处理，可以通过JAVA.LANG包中的String类来创建字符串对象。  
**一、String类：**  
**1.声明字符串**  
语法：

String str;

String:指定该变量为字符串类型；  
声明字符串变量必须经过初始化才能使用，否则编译器会报出“变量未被初始化错误”。

**2.创建字符串**  
(1)String(char a\[\])  
用一个字符数组a创建String对象。

char a[] ={
       'g','o','o','d'}; 
    String s = new String(a);

等价于：

String s = new String("good");

(2)String (char a\[\],int offset,int length)  
提取字符数组a中的一部分创建一个字符串对象，参数offset 表示开始截取字符串的位置，length表示截取字符串的长度。

char a[] ={
       's','t','u','d','e','n','t'}; 
     String s = new String(a,2,4);

等价于：

String s = new String("uden");

(3)String(char\[\] value)  
该构造方法可分配一个新的String 对象，使其表示字符数组参数中所有元素连接的结果。

char a[] = {
       's','t','u','d','e','n','t'}; 
    String s = new String(a);

等价于：

String s = new String("student");

--------------------

**二、连接字符串**  
**1.连接多个字符串**  
使用“+”运算符可实现连接多个字符串的功能，“+”运算可以连接多个运算符并可产生一个String对象。

public class Join{
         public static void main(String args[]){
                String s1= new String("hello"); 
                String s2= new String("world"); 
                String s = s1+" "+s2; 
                System.out.println(s); 
          }
    }

结果:  
hello world

JAVA中的一句相连的字符串不能分开在两行中写，例如：  
System.out.println(“I like  
java”) ;  
这种写法是错误的，如果一个字符串太长，为了便于阅读，可以将这个字符串分在两行上书写，此时就可以使用“+”将两个字符串联起来，之后在加号处换行。因此，上面的语句可以修改为：  
System.out.println(“I like “+  
“java”);  
**2.连接其他数据类型**  
字符串也可以同其他基本数据类型进行连接，如果将字符串同这些数据类型数据进行连接，会将这些数据直接转换成字符串。

Public class { 
        Public static void main(String args[]){
            int booktime =4; 
            float practice = 2.5f; 
            System.out.println("我每天花费"+booktime+"小时看书；"+ practice +"小时上机练习；"）；
            }
    }

结果：  
我每天花费4小时看书；2.5小时上机练习；  
注意：  
只要“+”运算符的一个操作数是字符串，编译器会将另一个操作数转移为字符串形式，所以应谨慎地将其他数据类型与字符串相连，以免出现意想不到的结果 。  
如果将上述代码改为：

System.out.println("我每天花费"+booktime+"小时看书，"+（booktime+practice）+"小时上机练习")；

结果：  
我每天花费4小时看书，6.5小时上机练习  
为什么会是这样呢？这是由于运算符是有优先级的，圆括号的优先级最高，所以先被执行，然后再将结果与字符串相连。

--------------------

**三、获取字符串信息**  
**1.获取字符串长度**  
使用String类的 length()方法可以获取字符串对象的长度。  
语法如下：

str.length();

str:表示字符串对象；  
案例代码：

String str = "we are students"; 
    int size = str.length(str);

此代码是将字符串str的长度赋值给int整型变量size,此时变量size的值为15，这表示 length()方法返回的字符串的长度包括字符串中的空格。  
**2.字符串查找**  
String 提供了两种字符串查找的方法，即indexOf()与lastIndexOf()方法。  
这两种方法都允许在字符串中搜索指定条件的字符或字符串。  
indexOf()方法返回的是搜索的字符或字符串首次出现的位置；lastIndexOf()方法返回的是搜索的字符或字符串最后一次出现的位置。  
(1)IndexOf(String s)  
该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用字符中的indexOf()方法时，会从当前字符串的开始位置搜索s的位置；  
如果没有检索到字符串s，该方法的返回值是-1.  
语法如下：

str.indexOf(substr)

str:任意字符串对象；  
substr:要搜索的字符串；  
案例代码：

String str="we are students"; 
    int size = str.indexOf("a");

//变量size的值是3  
(2)lastIndexOf(String str)  
该方法用于返回指定字符串最后一次出现的索引位置。当调用字符串的lastIndexOf()方法时，会从当前字符串的开始位置检索字符串str,并将最后一次出现str的索引位置返回，如果没有检索到该字符串str,该方法返回-1。  
语法如下：

str.lastIndexOf(substr);

str:任意字符串对象；  
substr:要搜索的字符串；  
如果lastIndexOf() 方法中的参数是空字符串“”（注意没有空格），则返回的结果与调用该字符串length()方法的返回值相同。  
案例代码：

public class  Text{
        public static void main(String args[]){
            String str="we are students"; 
            int size = str.lastIndexOf(""); 
            System.out.println("空字符在字符串str中的索引位置是："+size); 
            System.out.println("字符串str的长度是："+str.length()); 
        }
    }

结果：  
空字符在字符串str中的索引位置是：15  
字符串str的长度是：15  
**3.获取指定索引位置的字符**  
使用charAt()方法可将指定索引处的字符返回。  
语法如下：

str.charAt(int index);

str:表示任意字符串；  
index:整型值，用于指定要返回字符串的下标；  
案例代码：

public class{
        public static void main(String args[]){
            String str="hello world"; 
            char mychar = str.charAt(6); 
            System.out.println("字符串str中索引位置是6的字符为："+mychar); 
        }
    }

结果：  
字符串str中索引位置是6的字符为：w

--------------------

**四、字符串操作**  
**1.获取子字符串**  
通过String类的substring()方法可对字符串进行截取。这些方法的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。  
substring()方法被两种不同的方法重载，来满足不同的需要。  
(1)substring(int beginIndex)  
该方法返回的是从指定的索引位置开始截取直到该字符串的结尾的子串。  
语法：

str.substring(int beginIndex);

其中，beginIndex指定从某一索引处开始截取字符串。  
案例代码：

String str= "hello world"; 
    String substr = str.substr(3);

//获取的substr的值为：lo world  
在字符串的空格点用一个索引位置。  
(2)substring(int beginIndex,int endIndex)  
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。  
语法：

substring(int beginIndex,int endIndex);

beginIndex:表示开始截取子字符串的索引位置；  
endIndex:表示子字符串在整个字符串中的结束位置。  
案例代码：

public class Subs{
        public static void main(String args[]) {
            String str = "hello word"; 
            String substr= str.substring(0,3); 
            System.out.println(substr); 
        }
    }

结果：  
hel

**2.去掉空格**  
trim()方法返回字符串的副本，忽略前导空格和尾部空格。  
语法：  
str.trim();  
其中，str为任意字符串对象；  
案例代码：

public class Blak{
        public static void main(String args[]){
            String str= " java class "; 
            System.out.println("字符串原来的长度："+str.length()); 
            System.out.println("去掉空格以后的长度："+str.trim().length()); 
        }
    }

结果：  
字符串原来的长度：16  
去掉空格以后的长度：11  
补充：  
**去掉所有的空格的语法：**  
使用 replaceAll()方法（当然也包括去掉了字符串内的空格，不只是前后的空格）。  
案例代码：

String str = " a b c d e f "; 
    String shortstr= str.replaceAll("\\s","");           
    //这里的\\s 是转义字符，\s表示空格，将其替换为空字符串；
    System.out.println(shortstr);

结果：  
abcdef  
**3.字符串替换**  
replace() 方法可实现将指定的字符或字符串替换成新的字符或字符串。  
语法：

str.replace(char oldchar, char newchar);

oldchar: 表示要替换的字符或字符串；  
newchar：表示用于替换原来字符串的内容；  
replace()方法返回的结果是一个新的字符串。如果字符串oldchar 没有出现在该对象表达式的字符串序列中，则将原字符串返回。  
案例代码：

public class NewStr{
        public static void main(String args[]){
                String str = "address"; 
                String newstr = str.replace("a","A");
                System.out.println(newstr); 
        }
    }

结果：  
Address  
说明：  
如果要替换的字符oldchar在字符串中重复出现多次，replace()方法将所有的oldchar全部替换为newchar。例如：  
String str = “java project”;  
String newstr = str.replace(“j”,”J”);  
此时，newchar的值为：Java proJect  
需要注意的是，要替换的字符oldchar的大小写要与原字符串中字符的大小写保持一致，否则不能成功地替换。例如，上面的实例如果写成如下语句，则不能成功替换。  
String str= “java project”;  
String newstr = str.replace(“P”,”t”);  
//这里的P是大写的，在定义的字符串str中找不到  
**4.判断字符串的开始与结尾**  
startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值类型都是boolean类型。  
(1)startsWith()方法  
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。  
语法：

str.startsWith(String prefix);

其中，prefix表示的是前缀的字符。  
(2)endsWith()方法  
该方法用于判断当前字符是否以给定的子字符串结束 。  
语法：  
str.endsWith(String suffix);  
其中，suffix是指作为后缀的字符串。  
案例代码：

public class StartorEnd{
        public static void main(String args[]){
            String num1= "22045612"; 
            String num2="21304578"; 
            boolean b = num1.startsWith("22"); 
            boolean b2=num1.endsWith("78"); 
            boolean b3 =num2.startsWith("22"); 
            boolean b4 =num2.endsWith("78"); 
            System.out.println("字符串 num1 是以“22”开始的吗？"+b); 
            System.out.println("字符串 num1 是以“78”结束的吗？"+b2); 
            System.out.println("字符串 num2 是以“22”开始的吗？"+b3); 
            System.out.println("字符串 num2 是以“78”结束的吗？"+b4); 
        }
    }

结果：  
字符串 num1 是以“22”开始的吗？ true  
字符串 num1 是以“78”结束的吗？ false  
字符串 num2 是以“22”开始的吗？ false  
字符串 num2 是以“78”结束的吗？ true

**5.判断字符串是否相等**  
对字符串对象进行比较不能简单地使用比较运算符“=”，因为比较运算符比较的是两个字符串的地址是否相同。  
即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false.  
**特殊情况：**

String str1= new String("abc"); 
    String str2= new String("abc");         //使用new方法
    System.out.println(str1.equals(str2));     //true
    System.out.println(str1==str2);           //false
    //但是：
    String str1= "abc"; 
    String str2= "abc";                     //没有使用new方法
    System.out.println(str1.equals(str2));     //true
    *System.out.println(str1==str2);          //true*

因此，要比较两个字符串是否相等，应采用equals()方法和equalsIgnoreCase()方法。  
(1)equals()方法  
语法：

str.equals(String otherstr);

其中，str、otherstr 是要比较的两个字符串对象。且此方法比较的字符串是区分大小写的。  
(2)equalsIgnoreCase()方法  
使用equals()方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为boolean类型。  
语法：

str.equalsIgnoreCase(String otherstr);

其中，str、otherstr是要比较的两个字符串对象。  
案例代码：

public class Opinion{
        public static void main(String args[]){
            String s1=new String("abc"); 
            String s2=new String("ABC");
            String s3=new String("abc"); 
            boolean b = s1.equals(s2);    //false
            boolean b2=s1.equalsIgnoreCase(s2);   //true
            System.out.println(s1+"equals"+s2+":"+b);       System.out.println(s1+"equalsIgnoreCase"+s2+":"+b2);
            }
    }

结果：  
abc equals ABC:false  
abc equalsIgnoreCase ABC: true  
**6.按字典的顺序比较两个字符串**  
compareTo()方法为按字典的顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将此String对象表示的字符序列进行比较。  
如果按字典顺序此String对象位于参数字符之前，则比较结果为一个负整数；  
如果按字典顺序此String对象位于参数字符之后 ，则比较结果为一个正整数；  
如果这两个字符串相等，则结果为0。  
语法：

str.compare(String otherchar);

其中，str、otherchar是比较的两个字符串对象。  
说明：  
compareTo()方法只在equals(Object)方法返回 true时才返回0。  
案例代码：

public class Wordbook{
        public static void main (String args[]){
            String str= new String("b"); 
            String str2= new String("a"); 
            String str3= new String("c");   System.out.println(str+"compareTo"+str2+":"+str.compareTo(str2));
    System.out.println(str+"compareTo"+str3+":"+str.compareTo(str3));
        }
    }

结果：  
b compareTo a: 1  
b compareTo c:-1

**7.字母大小写转换**  
字符串的toLowerCase()方法可将字符串中的所有字符从大写字母改写为小写字母；  
toUpperCase()方法可将字符串所有的小写字母改写为大写字母。  
(1) toLowerCase()方法  
该方法将String转移为小写。如果字符串没有应被转换的字符，则将原字符串返回。否则将返回一个新的字符串，将原字符串中每个该进行小写转换的字符都转移成为等价的小写字符。字符串长度与原字符长度相同。  
语法：

str.toLowerCase();

其中，str是进行转换的字符串。  
(2)toUpperCase()方法  
该方法将String转移为大写。如果字符串中没有应该被转换的字符，则将原字符串返回。否则返回一个新的字符串，将原字符串中每个该进行大写转换的字符都转移成为等价的大写字符。字符串长度与原字符长度相同。  
语法：

str.toUpperCase();

其中，str是进行转换的字符串。  
说明：  
使用toLowerCase()方法和toUpperCase()方法进行大小写转换时，数字或非字符不受影响。  
案例代码：

public class UpAndLower{
        public static void main(String args[]){
                String str =new String("abc DEF"); 
                String newstr = str.toLowerCase(); 
                String newstr2 = str.toUpperCase();
                System.out.println(newstr); 
                System.out.println(newstr2); 
        }
    }

结果：  
abc def  
ABC DEF

**8.字符串分割**  
使用split()方法可以使字符串按指定的分割字符或字符串对内容进行分割，并将分割后的结果存放在字符串数组中。split()方法提供了以下两种字符串的分割形式。  
(1)split(String sign)  
其中，sign为分割字符串的分割符，也可以使用正则表达式。  
说明：  
没有统一的对字符进行分割的符号。如果想定义多个分割符，可使用符号“|”。例如：“，|=”表示分割符分别为：“，”和“=”。  
(2)split(String sign,int limit)  
该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。  
语法：

str.split(String sign,int limit);

sign:表示分割字符串的分割符，也可以使用正则表达式。  
limit:表示限制的分割次数。  
案例代码：

public class Divsion{
        public static void main(String args[]){
            String str="192.168.0.1"; 
            String[] firstArray = str.split("\\."); 
            String[] secondArray = str.split("\\.",2); 
            System.out.println("str的原值为：["+str+"]"); 
            System.out.println("全部的分割结果为："）；
            for(String a:firstArray){
                System.out.print("["+a+"]"); 
            }
            System.out.println(); 
            Syste.out.println("分割两次的结果为："）；
            for(String a:secondArray){
                System.out.print("["+a+"]"); 
                }
            System.out.println(); 
        }
    }

结果：  
str的原值为：\[192.168.0.1\]  
全部的分割结果为：  
\[192\]\[168\]\[0\]\[1\]  
分割两次的结果为：  
\[192\]\[168.0.1\]