String

一、基本

String类表示的“字符串”。位于java.lang.Object-java.lang.String。

java程序中的所有字符串，如 "abc"，"中国人"，都是实现这个类的实例。

String没有子类，不可能被复写。

字符串是常量，它们的值不能被创建后改变。由于字符串对象是不可改变的，所以它们可以被共享

二、创建字符串的方式：

1、直接创建，如String s1="abc";

这种定义方式最常见。s1是一个类类型变量，它指向对象，"abc"是一个对象。

2用new创建，如String s2=new String("abc");

以上两种创建方式的区别，s1在内存中只创建了一个对象，s2则是两个对象（分别是new和"abc"）

创建空字符串的方式：String s1="";或  String s2=new String();

三、字符串之间的比较

 ==比较的是字符串对象的内存地址值

equals()比较的是字符串的内容。String类复写了Object类中的equals方法，定义了自己的独特肉类，该方法用判断字符串内容是否相同。

package StringDemo1;

public class StringDemo {

    public static void main(String[] args) {
        
        String s = new String("abc");
        String s1 = "abc";    
        System.out.println(s1.equals(s));//比较的是字符串的内容
        System.out.println(s==s1);//比较的是字符串对象的内存地址值

    }

}

输出：

true

false

当字符串abc创建后，就存在了，另一个变量s3再指向同一字符串后，就不再新创建了，而是指向了原来的abc，所以内存地址值一样。

public class StringDemo {

    public static void main(String[] args) {

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

        String s3 = "abc";

        System.out.println(s1 == s2);// 两个对象，地址值不一样
        System.out.println(s1 == s3);// s1和s3指向同一个对象

    }

}

输出：

false
true

四、String类常用方法——获取数据

1、int length()　　获取字符串长度

2、int indexOf(int ch)　　根据字符获取在字符串中的第一次出现的位置

3、int indexOf(int ch, int fromIndex)　　从指定位置起搜索，获取字符在字符串的中第一次出现的位置

4、int indexOf(String str)　　根据子字符串，获取在字符串中的第一次出现的位置

5、int indexOf(String str, int fromIndex) 　　从指定位置起搜索，根据子字符串获取在字符串中的第一次出现的位置

class StringDemoGet
{
    public static void main(String[] args)
    {
        method_get();
    }
    
    public static void method_get()
    {
        String str="Hello World";

        //获取字符串长度  int length()
        sop(str.length());            //输出：11


        //根据位置获取字符  char    charAt(int index) 
        sop(str.charAt(1));            //输出：e


        //根据字符获取在字符串中第一次出现的位置     int indexOf(int ch)
        sop(str.indexOf('o'));        //输出：4
        sop(str.indexOf(100));        //输出：10。接受ASCII码表中字符对应的值
        sop(str.indexOf('f'));        //输出：-1。找不到时输出-1。


        //从指定位置起搜索，获取字符在字符串的中第一次出现的位置 int indexOf(int ch, int fromIndex)
        sop(str.indexOf('o',5));    //输出：7


        //根据子字符串，获取在字符串中的第一次出现的位置     int indexOf(String str)
        sop(str.indexOf("lo"));        //输出：3

        
        //从指定位置起搜索，根据子字符串获取在字符串中的第一次出现的位置     int indexOf(String str, int fromIndex) 
        sop(str.indexOf("lo",2));    //输出：3
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

五、String类的常用方法—判断数据

1、boolean isEmpty()　　判断字符串是否为空。就是判断长度是否为0，相当于判断length()==0。长度为0返回true，否则为false

2、boolean contains(CharSequence s) 　　判断字符串是否包含字符或字符串。

　　　　注：indexOf(str)，用于索引字符串和一次出现的位置，如果-1，侧表示字符串中不存在str，所以也可以用于判断字符中是否包含。

　　　　if(str.indexof("aa"))!=-1)，即可判断位置，也可判断是否包含。

3、boolean startsWith(String prefix) 　　判断是否以含指定内容开头

4、boolean endsWith(String suffix) 　　判断是否以含指定内容结尾

5、boolean equals(Object anObject) 　　判断字符串内容是否相同。复写了Object类中的equals方法

6、boolea equalsIgnoreCase(String anotherString)　　判断字符串内容是否相同，且忽略大写小。

    public static void method_if()
    {
        String str1="ArrayDemo.java";
        String str2="";
        String str3="ARRAYDEMO.JAVA";

        
        //判断字符串是否为空    boolean isEmpty()
        sop(str1.isEmpty());        //输出：false
        sop(str2.isEmpty());        //输出：true    


        //判断字符串是否包含    boolean contains(CharSequence s)
        sop(str1.contains("Demo."));        //输出：true


        //判断是否以含指定内容开头  boolean startsWith(String prefix) 
        sop(str1.startsWith("Array"));            //输出：true


        //判断是否以含指定内容结尾    boolean endsWith(String suffix) 　　
        sop(str1.endsWith(".java"));        //输出：true


        //判断字符串内容是否相同。    boolean equals(Object anObject) 　　
        sop(str1.equals(str3));        //输出：false


        //判断字符串内容是否相同，且忽略大写小。    equalsIgnoreCase(String anotherString)　　
        sop(str1.equalsIgnoreCase(str3));        //输出：true
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

　

六、String类操作——转换

1、字符数组——>字符串
　　构造函数：String(char[])
　　　　　 　  String(char[],offset,count)，字符数组中的一部分转成字符串

　　静态方法：static String copyValueOf(char[]);
　　　　　　　static String copyValueOf(char[],offset,count)，字符数组中的一部分转换成字符串

　　　　　　   static String valueOf(char[]);
　　　　　　　static String valueOf(char[],offset,count)，字符数组中的一部分转换成字符串

2、字符串——>字符数组　　char[] toCharArray();

3、字节数组——>字符串
　　构造函数：String(byte[])
　　　　　 　  String(byte[],offset,count)，字节数组中的一部分转成字符串

4、字符串——>字节数组(可以指定编码表)　　byte[] getBytes()

5、基本数据类型——>字符串
静态方法：static String valeOf(int); 　　 3+''//String.valueOf(3)
　　　　   static String valeOf(double);

5、基本数据类型——>字符串　　String valudOf(int)

class StringDemoTrans
{
    public static void main(String[] args)
    {
        method_trans();
    }
    
    public static void method_trans()
    {
        char[] arr={'a','b','c','d','e','f','g','h','i'};
//构造函数，字符数组转成字符串    String(char[])
        sop(new String(arr));                    //输出：abcdefghi

        //构造函数，字符数组中的一部分转成字符串 String(char[],offset,count)，
        sop(new String(arr,1,5));                //输出：bcdef


        //静态方法，字符数组转成字符串    static String copyValeOf(char[]);
        sop(String.copyValueOf(arr));            //输出：abcdefghi

        //静态方法，字符数组中的一部分转成字符串    static String copyValeOf(char[],offset,count)
        sop(String.copyValueOf(arr,1,3));        //输出：bcd


        //静态方法，字符数组转成字符串    static String valeOf(char[]);
        sop(String.valueOf(arr));            //输出：abcdefghi

        //静态方法，字符数组中的一部分转成字符串    static String valeOf(char[],offset,count)
        sop(String.valueOf(arr,2,3));        //输出：cde

    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

class StringDemoTrans
{
    public static void main(String[] args)
    {
        method_trans();
    }
    
    public static void method_trans()
    {

        String s="zxcvbnm"; 


        //字符串——>字符数组    char[] toCharArray();
        char[] chs=s.toCharArray();

        for (int x=1;x<chs.length ;x++ )
        {
            sop(chs[x]);
        }
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

输出：

x
c
v
b
n
m

class StringDemoTrans
{
    public static void main(String[] args)
    {
        method_trans();
    }
    
    public static void method_trans()
    {
        //字节数组——>字符串;
        byte[] bs={97,98,99,100,101,102};
        sop(new String(bs));       //abcdef
        sop(new String(bs,1,3));   //bcd
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}        

class StringDemoTrans
{
    public static void main(String[] args)
    {
        method_trans();
    }
    
    public static void method_trans()
    {
        //字符串——>字节数组   byte[] getBytes()
        String s="qwerty";
        byte[] bs=s.getBytes();
        for (int x=1;x<bs.length ;x++ )
        {
            sop(bs[x]);
        }

    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

七、String类的常用方法—替换

1、替换单个字符　　String replace(char oldChar, char newChar)   

2、替换字符串　　   String replace(CharSequence target, CharSequence replacement)  　　

class StringDemoReplace
{
    public static void main(String[] args)
    {

        String s="Hello java";
        //替换单个字符
        sop(s.replace('H','h'));        //输出：hellow java
        sop(s.replace('q','h'));        //输出：Hellow java。哪果原字符不存在，返回的还是原字符串。
        
        //替换字符串
        sop(s.replace("Hello java","world"));        //输出：Hellow world
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

八、String类的常用方法—切割

String[] split(String regex)  

class StringDemoSplit
{
    public static void main(String[] args)
    {

        String s="zhanshan,lisi,wangwu";
        
        String[] arr=s.split(",");

        for (int x=0;x<arr.length ; x++)
        {
            sop(arr[x]);
        }
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

输出：

zhanshan
lisi
wangwu

九、String类的常用方法—获取子串

sbustring(begin) 从指定位置开始开结尾。整串，s.substring(0)。如果角标不存在，则不现字符角标越界异常

sbustring(begin,end) 包含头，不包含尾。整串，s.substring(0,s.length())

class StringDemoSubstring
{
    public static void main(String[] args)
    {
        method_Substring();
    }
    
    public static void method_Substring()
    {
        String str1="ArrayDemo.java";

        //子串，sbustring(begin)。
        sop(str1.substring(4));            //输出：yDemo.java

        //子串，sbustring(begin,end)
        sop(str1.substring(3,5));        //输出：ay
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

九、String类的常用方法—大小写转换、去掉两端空格、

转换成大小写
　　String toLowerCase();
　　String toUpperCase();

class StringDemoCase
{
    public static void main(String[] args)
    {

        String s="Hello World";
        
//转成小写
        sop(s.toLowerCase());    //输出：hello world
        
        //转成大写
        sop(s.toUpperCase());    //输出：HELLO WORLD
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

去掉两端多空格

String trim()

class StringDemoTrim
{
    public static void main(String[] args)
    {

        String s="   Hello World   ";
        
        //转成小写
        sop(s.trim());    //Hello World
        
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

class StringDemoCompare
{
    public static void main(String[] args)
    {

        String s1="aba";
        String s2="aba";
        
        sop(s1.compareTo(s2));    //1。相当于s1和s2的ASCII相减。返回结果大于0，s1>s2；等于0，s1=s2；小于0，s1<s2.
        
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

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

int compareTo(string) 返回结果为整数。可能是正数，负数或0。

class StringDemoCompare
{
    public static void main(String[] args)
    {

        String s1="abc";
        String s2="aba";
        
        sop(s1.compareTo(s2));    //1。c-a=2。相当于s1和s2的最前一个不相同的字符的编码值相减。返回结果大于0，s1>s2；等于0，s1=s2；小于0，s1<s2.
        
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}