9.1 String类

悠悠 2021-09-30 07:22 280阅读 0赞

*  构造字符串对象
 *  String类的常用方法

//public int length（）
    //public boolean equals（String s）
    //public boolean startsWith(String s)
    //public boolean endsWith(String s)
    //public boolean regionMatches(int firstStart,String other,int ortherStart,int length)
    //public boolean regionMatches(boolean b,int firstStart,String other,int ortherStart,int length)
    //public int compareTo（String s）
    //public int compareToIgnoreCase（String s）
    //public boolean contains(String s)
    //public int indexOf(String s)
    //public int indexOf(String s，int startpoint)
    //public int lastIndexOf(String s)
    //public String subString(int startPoint)
    //public String trim（）

**Java使用java.lang包（默认导入）中的String类来创建一个字符串变量，字符串变量是对象**

**注意：Java把String类声明为Final类，因此用户不能扩展String类，****即String类不能有子类**

**一：构造字符串对象**

*  **常量对象**

字符串常量对象是用双引号括起的字符序列

**如：“你好”，“12.86”，“boy”等**

*  **字符串对象**

可以使用String类声明字符串对象

**如：String s;  **** (注意：这时候s是null,如果是局部变量，因为没有初始化，所有没有默认值)**

由于字符串是对象，那么必须创建字符串对象，可以使用String类的构造方法

**如：s=new String（“who are you”）;**

也可以使用一个创建好的字符串创建另外一个字符串

**如：String a=new String(s);**

*  **String类还有两种较常用的构造方法**

**（1）String (char a\[ \])：用一个字符数组a创建一个字符串对象**

**如char a\[\]=\{** **‘****b****’****,****’****o****’****,****’****y****’****\};**

**String s=new String(a);**

**相当于**

**String s=new String(“boy”);**

**（2）String(char a\[\],int startIndex,int count):提取字符数组a中的一部分字符创建一个字符串对象，参数startIndex和count分别指定在a中提取****字符的起始位置****和从该位置开始****截取的字符个数。(注意：数组的索引是从0开始的)**

**如：char a\[\]=\{** **‘****b****’****,****’****o****’****,****’****y****’****,****’****f****’****\};**

**String s=new String(a,1,2);**

**相当于**

**String s=new String(“oy”);**

*  **引用字符串常量对象**

**字符串常量是对象，因此，可以把字符串常量的引用赋给一个字符串常量**

**如：String s1,s2;**

**S1=“how are you”;**

**S2=“how are you”;**

**“how are you”字符串常量是对象，因此s1和s2具有相同的索引，因而具有相同的实体。（也就是说他们的地址是一样的）**

**但是：**

**String s1=new String(“how are you”);**

**String s2=new String(“how are you”);**

**s1和s2的引用不同**

public class AA {
        public static void main(String []agrs){
            String s1,s2;
    //        System.out.println(s1);      //非法
            s1="aa";
            s2="aa";
            System.out.println(s1==s2);
    
            String s3=new String("how are you");
            String s4=new String("how are you");
            System.out.println(s3==s4);
        }
    }

true  
false

**二：String类的常用方法**

*  **public int length（）**

使用String类中的length（）方法可以获取一个字符串的长度

如：String a=“我们是学生”；
    Int n1,n2;
    n1=a.length();     //对象.方法
    n2=“你好abcd”.length();
    那么n1的值为5，n2的值为6

*  **public boolean equals（String s）**

字符串对象调用equals（String s）方法比较当前字符串对象的实体是否与参数s指定的字符串的实体相同

如：String a=new String(“wo”);
    String b=new String(“we”);
    String c=new String(“wo”);
    那么，a.equals（b）的值为false  ,  a.equals（c）的值为true
    注意：
    1>关系式a==c的值是false，因为字符串是对象，a和c中存放的是引用，
    虽然值一样，但a和c的引用不一样（和前面（4）不一样，这里是new了新的）
    
    2>字符串对象调用public boolean equalsIgnoreCase（String s）比较
    当前字符串对象与参数s指定的字符串是否相同，比较时候忽略大小写

*  **public boolean startsWith(String s)**
 *  **public boolean endsWith(String s)**

**字符串对象调用startsWith(String s)方法，判断当前字符串对象的前缀是否是参数s指定的字符串**

如：String a=“2603021”，b=“21079220”;
    那么，a.startsWith(“260”)的值是true,b.startsWith(“260”)的值是false

**使用endsWith(String s)方法，判断一个字符串的后缀是否是字符串s**

如：a.endsWith(“021”)的值是true，b.endsWith(“021”)的值是false

*  **public boolean regionMatches(int firstStart,String other,int ortherStart,int length)方法**

**字符串调用regionMatches(int firstStart,String other,int ortherStart,int length)方法，从当前字符串参数firstStart指定的位置开始处，取长度为length的一个字串，并将这个字串和参数other指定的一个字串进行比较，其中，other指定的字串是从参数ortherStart指定的位置开始，取长度为length的一个子串。（看例子比较好懂）**

**如果两个子串相同，该方法返回true，否则返回false**

package p3;
    
    public class P3 {
        public static void main(String args[]){
            int number=0;
            int k;
            String s="student";
            System.out.println(s.length());   //长度从1开始
    //为什么k是7,因为比较了7轮,只有一轮en符合,所以number是1
            for(k=0;k<s.length();k++){
                if (s.regionMatches(k,"en",0,2)){    //索引从0开始
                    number++;            //一个en
                }              //k是从字符串s即student第几位开始，索引从k开始，长度为2
            }                  //"en"是要对比的字符串，从索引0开始（ooffset那个），长度也是2
            System.out.println(number);
            System.out.println(k);
        }
    
    }
    结果是7 1 7

**使用该方法的重载方法：**

*  **public boolean regionMatches(boolean b,int firstStart,String other,int ortherStart,int length)**

**可以通过b决定是否忽略大小写，但b为true时候，忽略大小写**

*  **public int compareTo（String s）方法**

**字符串对象可以使用String类中的compareTo（String s）方法，按字典序与参数s指定的字符串比较大小。**

**如果当前字符串与s相同，该方法返回值0；如果大于s，返回正值，如果小于返回负值**

如：String str=”abcde”;
    str.compareTo(“boy”)小于0
    str.compareTo(“aba”)大于0
    str.compareTo(“abcde”)等于0
    
    我是这样想：比如abcde和boy比较，第一个字母：a<b，所以小于0
    abcde和aba比较，第一个和第二个字母一样，第三个c>a，所以大于0
    还有就是A和a比，小于0，因为Aa

**也可以使用该方法，该方法忽略大小写**

*  **public int compareToIgnoreCase（String s）**

例子：将一个字符串数组按字典序重新排列

package p1;
    
    public class SortString {
        public static void sort(String a[]){
            for(int i=0;i<a.length-1;i++){              //0到<4，比较4轮
                for (int j=i+1;j<a.length;j++){            //1到<5,,比较4次
                    if (a[j].compareTo(a[i])<0){         //a[1]和a[0],若<0说明a[1]大，要放后面
                        String temp=a[i];
                        a[i]=a[j];        //交换，下面就是a[2]和a[1]比较，a[3]和a[1],a[4]和a[1]
                        a[j]=temp;         //反正就是使最小那个在第一位，一轮后确定了最小那个数
                    }             //第二轮就可以排除第一个，从第二个开始新的一轮确定倒数第二最小的数
                }
            }
        }
    }

package p1;
    
    import java.util.Arrays;
    
    public class p1 {
        public static void main(String args[]) {
            String a[]={"boy","apple","Applet","girl","Hat"};
            String []b=Arrays.copyOf(a,a.length);
            System.out.println("数组a"+Arrays.toString(a));
            System.out.println("数组b"+Arrays.toString(b));
            System.out.println("使用用户编写的SortString类，按字典序排列数组a");
            SortString.sort(a);
            for (String s:a){
                System.out.print(" "+s);         //用for循环将数组a一个个输出来
            }
            System.out.println();     //换行
            System.out.println("使用类库中的Arrays类，按字典序排列数组b");
            Arrays.sort(b);
            for (String s:b){
                System.out.print(" "+s);         //用for循环将数组a一个个输出来
            }
        }
    }

结果：
    数组a[boy, apple, Applet, girl, Hat]
    数组b[boy, apple, Applet, girl, Hat]
    使用用户编写的SortString类，按字典序排列数组a
     Applet Hat apple boy girl
    使用类库中的Arrays类，按字典序排列数组b
     Applet Hat apple boy girl

*  **public boolean contains(String s)**

**字符串对象调用contains方法，判断当前字符串对象是否含有参数指定的字符串s**

如：
    
    tom=”student”,那么tom.contains(“stu”)的值是true,
    
    而tom.contains(“ok”)的值是false

*  **public int indexOf(String s)**
 *  **indexOf(String s，int startpoint)**
 *  **lastIndexOf(String s)**

**字符串对象调用方法indexOf(String s)从当前字符串的头开始检索字符串s，并返回首次出现s的位置，如果没有检索到，返回-1**

**也可以调用indexOf(String s，int startpoint)方法，从startpoint位置开始检索（首次出现的s，-1，懒的写了）**

**字符串调用lastIndexOf(String s)方法（最后出现的s,-1）**

public class p1 {
        public static void main(String args[]) {
            String tom="I am a good cat";
            System.out.println(tom.indexOf("a"));
            System.out.println(tom.indexOf("good"));
            System.out.println(tom.indexOf("a",3));
            System.out.println(tom.indexOf("a",7));
            System.out.println(tom.indexOf("w",2));
            System.out.println(tom.lastIndexOf("a"));
        }    //全以索引形式记就行了，空格也算的
    }
    结果：2   7   5   13   -1   13

*  **public String subString(int startPoint)**

**字符串对象调用方法获得一个当前字符串的子串，该子串是从当前字符串的startPoint处截取到最后所得到的字符串**

**也可以调用方法subString(int start，int end)**

**该子串是从当前字符串的start处截取到end处（不包括end对应的字符）**

例子：
    String tom=”I love tom”;
    String s=tom.subString(2,5);
    那么，s是“lov”.(也是按索引形式去记就行了，注意end对应那个字符不包括)

注意：如果
    String path
    path="c:\\book\\javabook\\xml.doc";
    
    \\是转义字符，输出\的意思
    即如果这样
    String sub=path.substring(2);
    System.out.println(sub);
    输出得到是\book\javabook\xml.doc

*  **public String trim（）**

**一个字符串s通过调用方法 trim（）得到一个字符串对象，该字符串对象是s去掉前后空格的字符串**