JAVA从小白到大神第10章字符串

10.1java中的字符串

java中的字符串是由双引号括起来的多个字符

"Hello World","\u0048\u0045\u0020","世界你好"，"A"，""

单个字符用双引号括起来就是字符串而不是字符了，""代表的不是null，空字符串分配了内存空间，null没有分配内存空间。

JAVASE提供了三个字符串类：String,StringBuffer,StringBuilder。String是不可变字符串，StringBuffer，StringBuilder是可变字符串。

10.2使用api文档

java中有很多类，每个类又有很多方法和变量，通过查看javaAPI文档可以知道这些类，方法，变量如何使用。

JAVA8在线API文档，网址是http://docs.oracle.com/javase/8/docs/api/

10.3 不可变字符串

10.3.1String

Java中的不可变字符串是String，属于java.lang包，他也是java非常重要的类。

创建String对象可以通过构造方法实现：

String（）：使用空字符串创建并初始化一个新的String对象。

String（String original）：使用另外一个字符串创建并初始化一个新的String对象。

String（SringBuffer buffer）：使用可变字符串对象创建并初始化一个新的String对象。

String（StringBuilder builder）：使用可变字符串对象创建并初始化一个新的String对象。

String（byte[] byte）:使用平台默认字符集解码指定的byte数组，通过byte数组创建并初始化一个新的String对象。

String（char[] value）：通过字符数组创建并初始化一个新的String对象。

String（char[] value,int offset,int count）:通过字符数组的子数组创建并初始化一个新的String对象：offset参数是子数组的第一个字符的索引，count参数指定子数组的长度。

例子：

package ChapterTen;

public class CharacterString {
    public static void main(String[] args) {
        //创建字符串对象
        String s1 = new String();
        String s2 = new String("Hello World");
        String s3 = new String("\u0048\u0065\u006c\u006c\u0020\u0057\u006f\u0072\u006c\u0064");
        System.out.println("s2 = " + s2);
        System.out.println("s3 = " + s3);
        
        char chars[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
        //通过字符数组创建字符串对象
        String s4 = new String(chars);
        //通过子字符数组创建字符串对象
        String s5 = new String(chars,1,4);
        System.out.println("s4 = " + s4);
        System.out.println("s5 = " + s5);
        
        byte bytes[] = { 97, 98, 99 };
        //通过byte数组创建字符串对象
        String s6 = new String(bytes);
        System.out.println("s6 = " + s6 );
        System.out.println("s6字符串长度 = "  + s6.length());
        
    }
}
java.lang包中提供了许多java基础类，包括Object，Class，String，Math基本类。使用时不需要引入此包，因为他是由解释器自动引入的。

10.3.2字符串池

String s7 = "Hello";
        String s8 = "Hello";                        //字符串常量
        
        String s9 = new String("Hello");           //使用new关键字创建
        String s10 = new String("Hello");
        
        System.out.println("s7 == s8 : %b%n",s7 = s8);
        System.out.println("s9 == s10 : %b%n",s9 = s10);
        System.out.println("s7 == s9 : %b%n",s7 = s9);
        System.out.println("s9 == s8 : %b%n",s9 = s8);

得出的，结果是

s7 == s8：true

s9 == s10：false

s7 == s9：false

s9 == s8：false

10.3.3字符串拼接

String字符串拼接可以使用+运算符或者String的concat（String str）方法。

package ChapterTen;

public class Stringconcat {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = s1 + " " ;
        String s3 = s2 + "World";
        System.out.println(s3);
        
        String s4 = "Hello";
        //使用+运算符来连接，支持+=运算符
        s4 += " ";
        s4 += "World";
        System.out.println(s4);
        
        String s5 = "Hello";
        //使用concat方法连接
        s5 = s5.concat(" ").concat("World");
        System.out.println(s5);
        
        int age = 18;
        String s6 = "她的年龄是" + age + "岁";
        System.out.println(s6);
        
        java.util.Date now = new java.util.Date();
        //对象拼接自动调用toString（）方法
        String s8 = "今天是：" + now;
        System.out.println(s8);    
    }
}
 

10.3.4字符串查找

在String类中提供了indexOf和lastIndexOf方法用于查找字符或字符串，返回值是查找的字符串或字符串所在位置，-1代表没有查到

int indexOf(int ch)：从前往后搜索字符ch，返回第一次找到字符ch所在处的索引。

int indexOf(int ch, int fromIndex):从指定的索引开始从前往后搜索字符ch，返回第一次找到字符ch所在的索引。

int indexOf(String str):从前往后搜索字符串str，返回第一次找到字符串str所在的索引。

int indexOf(String str,int fromIndex):从指定的索引开始从前往后搜索字符串str，返回第一次找到字符ch所在的索引。

int lastIndexOf(int ch)：从后往前搜索字符ch，返回第一次找到字符ch所在处的索引。

int lastIndexOf(int ch, int fromIndex):从指定的索引开始从后往前搜索字符ch，返回第一次找到字符ch所在的索引。

int lastIndexOf(String str):从后往前搜索字符串str，返回第一次找到字符串str所在的索引。

int lastIndexOf(String str,int fromIndex):从指定的索引开始从后往前搜索字符串str，返回第一次找到字符ch所在的索引。

字符串本质上是字符数组，因此他也有索引，索引从零开始。String的CharAt（int index）方法可以返回索引index所在位置的字符。

package ChapterTen;

public class Stringfind {
    public static void main(String[] args) {
        String sourceStr = "There is a string accessing example.";
        
        //获得字符串长度
        int len = sourceStr.length();
        //获得索引位置16的字符
        char ch = sourceStr.charAt(16);
        
        //查找字符和字符串
        int firstChar1 = sourceStr.indexOf('r');
        int lastChar1 = sourceStr.lastIndexOf('r');
        int firstStr1 = sourceStr.indexOf("ing");
        int lastStr1 = sourceStr.lastIndexOf("ing");
        int firstChar2 = sourceStr.indexOf('e',15);
        int lastChar2 = sourceStr.lastIndexOf('e',15);
        int firstStr2 = sourceStr.indexOf("ing",5);
        int lastStr2 = sourceStr.lastIndexOf("ing",5);
        
        System.out.println("原始字符串长度：" + sourceStr);
        System.out.println("字符串长度：" + len);
        System.out.println("索引16的字符" + ch);
        System.out.println("从前往后搜索r字符，第一次找到它的索引" + firstChar1);
        System.out.println("从后往前搜索r字符，第一次找到它的索引" + lastChar1);
        System.out.println("从前往后搜索ing字符串，第一次找到它的索引" + firstStr1);
        System.out.println("从后往前搜索ing字符串，第一次找到它的索引" + lastStr1);
        System.out.println("从索引为15位置开始，从前往后搜索e字符，第一次找到它的索引" + firstChar2);
        System.out.println("从索引为15位置开始，从后往前搜索e字符，第一次找到它的索引" + lastChar2);
        System.out.println("从索引为5位置开始，从前往后搜索ing字符串，第一次找到它的索引" + firstStr2);
        System.out.println("从索引为5位置开始，从后往前搜索ing字符串，第一次找到它的索引" + lastStr2);
    }
}

输出结果

原始字符串长度：There is a string accessing example.
字符串长度：36
索引16的字符g
从前往后搜索r字符，第一次找到它的索引3
从后往前搜索r字符，第一次找到它的索引13
从前往后搜索ing字符串，第一次找到它的索引14
从后往前搜索ing字符串，第一次找到它的索引24
从索引为15位置开始，从前往后搜索e字符，第一次找到它的索引21
从索引为15位置开始，从后往前搜索e字符，第一次找到它的索引4
从索引为5位置开始，从前往后搜索ing字符串，第一次找到它的索引14
从索引为5位置开始，从后往前搜索ing字符串，第一次找到它的索引-1

10.3.5字符串比较

1.比较相等

boolean equals(Object anObject):比较两个字符串中内容是否相等

boolean equalsIgnoreCase(String anotherString):类似equals方法，只是忽略大小写

2.比较大小

int compareTo(String anotherString):按字典顺序比较两个字符串，如果参数字符串等于此字符串，则返回值0；如果此字符串小于参数字符串，则返回一个小于0的值；如果此字符串大于参数字符串，则返回一个大于0的值。

int compareToIgnoreCase(String str):类似compareTo，只是忽略大小写

3.比较前缀和后缀

boolean ends With(String suffix):测试此字符串是否以指定的后缀结束。

boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始。

例子：

package ChapterTen;

public class Stringcompare {
        public static void main(String[] args) {
            String s1 = new String("Hello");
            String s2 = new String("Hello");
            //比较字符串是否是相同的引用
            System.out.println("s1 == s2:" + (s1 == s2));
            //比较字符串是否相等
            System.out.println("s1.equals(s2):" + s1.equals(s2));
            
            String s3 = "HELlo";
            //忽略大小写比较字符串内容是否都相等
            System.out.println("s1.equalsIgnoreCase(s3)" + (s1.equalsIgnoreCase(s3)));
            
            //比较大小
            String s4 = "java";
            String s5 = "Swift";
            //比较字符串大小 s4》s5
            System.out.println("s4.compareTo(s5):" + (s4.compareTo(s5)));
            //忽略大小比较字符串大小
            System.out.println("s4.compareToIgnoreCase(s5)" + (s4.compareToIgnoreCase(s5)));
            
            //判断文件夹中文件名
            String[] docFolder = {
                    "java.docx","JavaBean.docx","Objective-C.xlsx","Swift.docx"
            };
            int wordDocCount = 0;
            //查找文件夹中word文档个数
            for(String doc : docFolder) {
                //去掉前后空格
                doc = doc.trim();
                //比较后缀是否有.docx字符串
                if (doc.endsWith(".docx")) {
                    wordDocCount++;
                }
            }
            System.out.println("文件夹中word文档个数是：" + wordDocCount);
            
            int javaDocCount = 0;
            //查找文件夹中Java相关文档的个数
            for (String doc : docFolder) { 
                //去掉前后空格
                doc = doc.trim();
                //全部字符转成小写
                doc = doc.toLowerCase();
                //比较前缀是否有java字符串
                if(doc.startsWith("java")) {
                    javaDocCount++;
                }
            }
            System.out.println("文件夹中Java相关文档个数是：" + javaDocCount);
        }
}

10.3.6字符串截取

String substring(int beginIndex):从指定索引beginIndex开始截取一直到字符串结束的字符串。

String substring(int beginIndex, int endIndex):从指定索引beginIndex开始截取到endIndex-1处的字符，注意包括beginIndex的字符而不包括endIndex处的字符。

例子：

package ChapterTen;

public class Substring {
    public static void main(String[] args) {
        String sourceStr = "THere is a string accessing example.";
        //截取example.字符串
        String subStr1 = sourceStr.substring(28);
        //截取string字符串
        String subStr2 = sourceStr.substring(11,17);
        System.out.printf("subStr1 = %s%n", subStr1);
        System.out.printf("subStr2 = %s%n", subStr2);
        
        //使用split方法分隔字符串
        System.out.println("-----使用split-----");
        String[] array = sourceStr.split(" ");
        for(String str : array) {
            System.out.println(str);
        }
    }

}
10.4可变字符串

可变字符串在追加，删除，修改，插入和拼接等操作过程中不会产生新对象。

10.4.1 StringBuffer和StringBuilder

Java提供了两个可变字符串类StringBuffer和StringBuilder，中文翻译为“字符串缓冲区”。

StringBuffer是线程安全的，它的方法支持线程同步，线程同步会操作串行顺序执行，在单线程环境下会影响效率。StringBuilder是StringBuffer的单线程版本，它不是线程安全的，但是它的执行效率很高。

StringBuffer和StringBuilder的API具有完全相同的API，即构造方法和普通方法等内容一样

四个方法

StringBuilder():创建字符串内容是空的StringBuilder对象，初始容量默认为16个字符。

StringBuilder(CharSequence seq):指定CharSequence字符串创建StringBuilder对象。CharSequence接口类型，它的实现类有String，StringBuffer和StringBuilder等，所以参数seq可以是String，StringBuffer和StringBuilder等类型。

StringBuilder(int capacity):创建字符串内容是空的StringBuilder对象，初始容量由参数capacity指定。

StringBulider(String str):指定String字符串创建StringBuilder对象。

例子：

package ChapterTen;

public class StringBuffer {
    public static void main(String[] args) {
        //字符串长度length和字符串缓冲区容量capacity
        StringBuilder sbuilder = new StringBuilder;
        System.out.println("包含的字符串长度：" + sbuilder.length());
        System.out.println("字符串缓冲区容量：" + sbuilder.capacity());
        
        StringBuilder sbuilder2 = new StringBuilder("Hello");
        System.out.println("包含的字符串长度：" + sbuilder2.length());
        System.out.println("字符串缓冲区容量：" + sbuilder2.capacity());
        
        //字符串缓冲区初始容量为16，超过之后会扩容
        StringBuilder sbuilder3 = new StringBuilder();
        for(int i = 0; i < 17; i++){
            sbuilder3.append(8);
        }
        System.out.println("包含的字符串长度：" + sbuilder3.length());
        System.out.println("字符串缓冲区容量：" + sbuilder3.capacity());
    }

}
 

包含的字符串长度：0
字符串缓冲区容量：16
包含的字符串长度：5
字符串缓冲区容量：21
包含的字符串长度：17
字符串缓冲区容量：34

10.4.2字符串追加

字符串追加的方法是append，append有很多重载方法，可以追加任何类型的数据，它的返回值还是StringBuilder。

例子:

package ChapterTen;

public class Stringappend {
    public static void main(String[] args) {
        //添加字符串，字符
        StringBuilder sbuilder1 = new StringBuilder("Hello");
        sbuilder1.append("").append("World");
        sbuilder1.append(".");
        System.out.println(sbuilder1);
        
        StringBuilder sbuilder2 = new StringBuilder();
        Object obj = null;
        //添加布尔类型，转义符和空对象
        sbuilder2.append(false).append('\t').append(obj);
        System.out.println(sbuilder2);
        
        //添加数值
        StringBuilder sbuilder3 = new StringBuilder();
        for(int i = 0; i < 10; i++){
            sbuilder3.append(i);
        }
        System.out.println(sbuilder3);
    }
}
 

HelloWorld.
false    null
0123456789
10.4.3字符串插入，删除和替换

StringBuilder insert(int offset,String str):在字符串缓冲区中索引为offset的字符位置之前插入str，insert有很多重载方法，可以插入任何类型的数据。

StringBuffer delete(int start,int end):在字符串缓冲区中删除字符串，要删除的子字符串从指定索引start开始直到索引为end-1处的字符。start和end两个参数与substring（int beginIndex，int endIndex）方法中的两个参数含义一样。

StringBuffer replace(int begin, int end, String str):在字符串缓冲区中用str替换子字符串，子字符串从指定索引start直到索引为end-1的字符。start和end同delete（int start，int end）方法。

例子：

package ChapterTen;

public class StrInsertDeleteReplace {
    public static void main(String[] args) {
        //原始不可变字符串
        String str1 = "Java C";
        //从不可变的字符串创建可变字符串对象
        StringBuilder mstr = new StringBuilder(str1);
        
        //插入字符串
        mstr.insert(4, "C++");
        System.out.println(mstr);
        
        //具有追加效果的插入字符串
        mstr.insert(mstr.length()," Objective-C");
        System.out.println(mstr);
        
        //追加字符串
        mstr.append(" and Swift");
        System.out.println(mstr);
        
        //删除字符串
        mstr.delete(11, 23);
        System.out.println(mstr);
    }
}
 

JavaC++ C
JavaC++ C Objective-C
JavaC++ C Objective-C and Swift
JavaC++ C Ond Swift