β

《Java从小白到大牛》之第9章 字符串

Harries Blog™ 9 阅读

《Java从小白到大牛》纸质版已经上架了!!!

《Java从小白到大牛》之第9章 字符串

由字符组成的一串字符序列,称为“字符串”,在前面的章节中也多次用到了字符串,本章将重点介绍。

Java中的字符串

Java中的字符串是由双引号括起来的多个字符,下面示例都是表示字符串常量:

"Hello World"                                                           ①
"/u0048/u0065/u006c/u006c/u006f/u0020/u0057/u006f/u0072/u006c/u0064"        ②
"世界你好"                                                              ③
"A"                                                                 ④
""                                                                  ⑤

Java中的字符采用Unicode编码,所以Java字符串可以包含中文等亚洲字符,见 代码 第③行的"世界你好"字符串。代码第②行的字符串是用Unicode编码表示的字符串,事实上它表示的也是"Hello World"字符串,可通过System.out.print方法将Unicode编码表示的字符串输出到控制台,则会看到Hello World字符串。

另外,单个字符如果用双引号括起来,那它表示的是字符串,而不是字符了,见代码第④行的"A"是表示字符串A,而不是字符A。

注意 字符串还有一个极端情况,就代码第⑤行的""表示空字符串,双引号中没有任何内容,空字符串不是null,空字符串是分配内存 空间 ,而null是没有分配内存空间。

Java SE提供了三个字符串类:String、StringBuffer和StringBuilder。String是不可变字符串,StringBuffer和StringBuilder是可变字符串。

使用 API 文档

Java中很多类,每一个类又有很多方法和变量,通过查看Java API文档能够知道这些类、方法和变量如何使用。Java官方为Java SE提供了基于 HTML 的API文档。作为Java 程序员 应该熟悉如何使用API文档。

本节介绍一下如何使用Java SE的API文档。Java官方提供了Java 8在线API文档,网址是 http ://docs.oracle.com/ java se/8/docs/api/ ,页面如图9-1所示。

《Java从小白到大牛》之第9章 字符串

提示 很多读者 希望 能够有离线的中文Java API文档,但Java官方只提供了Java 6的中文API文档,该文件 下载 地址是 http://download.oracle.com/technetwork/java/javase/6/docs/zh/api. zip ,下载完成后解压api.z ip 文件,找到其中的index.html文件,双击就会在浏览器中打开API文档了。

下面介绍一下如何使用API文档,熟悉一下API文档页面中的各个部分含义,如图9-2所示,类和接口中,斜文字体显示是接口,正常字体才是类。

《Java从小白到大牛》之第9章 字符串

在类窗口还有很多内容,向下拖曳滚动条会看到如图9-3所示页面,其中“字段摘要”描述了类中的 实例 变量和静态变量;“ 构造方法 摘要”描述了类中所有构造方法;“方法摘要”描述了类中所有方法。这些“摘要”只是一个概要说明,单击链接可以进入到该主题更加详细的描述,如图9-4所示单击了compareTo方法看到的详细信息。

《Java从小白到大牛》之第9章 字符串

《Java从小白到大牛》之第9章 字符串

查询API的一般流程是:找包→找类或接口→查看类或接口→找方法或变量。读者可以尝试查找一下String、StringBuffer和StringBuilder这些字符串类的API文档,熟悉一下这些类的用法。

不可变字符串

很多计算机语言都提供了两种字符串,即不可变字符串和可变字符串,它们区别在于当字符串进行拼接等修改操作时,不可变字符串会创建新的字符串对象,而可变字符串不会创建新对象。

String

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

提示 java.lang包中提供了很多Java基础类,包括Object、Class、String和Math等基本类。在使用java.lang包中的类时不需要引入(import)该包,因为它是由解释器自动引入的。当然引入java.lang包程序也不会有 编译 错误。

创建String对象可以通过构造方法实现,常用的构造方法:

  • String():使用空字符串创建并初始化一个新的String对象。
  • String(String original):使用另外一个字符串创建并初始化一个新的 String 对象。
  • String(StringBuffer buffer):使用可变字符串对象(StringBuffer)创建并初始化一个新的 String 对象。
  • String(StringBuilder build er):使用可变字符串对象(StringBuilder)创建并初始化一个新的 String 对象。
  • String(byte[] bytes):使用平台的默认字符集解码指定的byte数组,通过byte数组创建并初始化一个新的 String 对象。
  • String(char[] value ):通过字符数组创建并初始化一个新的 String 对象。
  • String(char[] value, int offset, int count):通过字符数组的子数组创建并初始化一个新的 String 对象;offset 参数 是子数组第一个字符的 索引 ,count参数指定子数组的长度。

创建字符串对象示例代码如下:

// 创建字符串对象

String s1 = new String();

String s2 = new String("Hello World");

String s3 = new String("/u0048/u0065/u006c/u006c/u006f/u0020/u0057/u006f/u0072/u006c/u0064");

System.out.println("s2 = " + s2);

System.out.println("s3 = " + s3);

char chars[] = {  a ,  b ,  c ,  d ,  e  };

// 通过字符数组创建字符串对象

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());

输出结果:

s2 = Hello World

s3 = Hello World

s4 = abcde

s5 = bcde

s6 = abc

s6字符串长度 = 3

上述代码中s2和s3都是表示Hello World字符串,获得字符串长度方法是length(),其他代码比较简单,这里不再赘述。

字符串池

在前面的学习过程中细心的读者可能会发现,前面的示例代码中获得字符串对象时都是直接使用字符串常量,但Java中对象是使用new关键字创建,字符串对象也可以使用new关键字创建,代码如下:

String s9 = "Hello"; //字符串常量

String s7 = new String("Hello"); //使用new关键字创建

使用new关键字与字符串常量都能获得字符串对象,但它们之间有一些区别。先看下面代码运行结果:

String s7 = new String("Hello"); ①

String s8 = new String("Hello"); ②

String s9 = "Hello"; ③

String s10 = "Hello"; ④

System.out.printf("s7 == s8 : %b%n", s7 == s8);

System.out.printf("s9 == s10: %b%n", s9 == s10);

System.out.printf("s7 == s9 : %b%n", s7 == s9);

System.out.printf("s8 == s9 : %b%n", s8 == s9);

输出结果:

s7 == s8 : false

s9 == s10: true

s7 == s9 : false

s8 == s9 : false

==运算符比较的是两个引用是否指向相同的对象,从上面的运行结果可见,s7和s8指的是不同对象,s9和s10指向的是相同对象。

这是为什么?Java中的不可变字符串String常量,采用字符串池(String Pool) 管理 技术,字符串池是一种字符串驻留技术。采用字符串常量赋值时(见代码第③行),如图9-5所示,会字符串池中查找"Hello"字符串常量,如果已经存在把引用赋值给s9,否则创建"Hello"字符串对象,并放到池中。根据此原理,可以推定s10与s9是相同的引用,指向同一个对象。但此原理并不适用于new所创建的字符串对象,代码运行到第①行后,会创建"Hello"字符串对象,而它并没有放到字符串池中。代码第②行又创建了一个新的"Hello"字符串对象,s7和s8是不同的引用,指向不同的对象。

《Java从小白到大牛》之第9章 字符串

字符串拼接

String字符串虽然是不可变字符串,但也可以进行拼接只是会产生一个新的对象。String字符串拼接可以使用+运算符或String的con cat (String str)方法。+运算符优势是可以连接任何类型 数据 拼接成为字符串,而concat方法只能拼接String类型字符串。

字符串拼接示例如下:

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);

char score =  A ;

String s7= "她的英语成绩是" + score; ⑦

System.out.println(s7);

java.util.Date now = new java.util.Date(); ⑧

//对象拼接自动调用toString()方法

String s8= "今天是:" + now; ⑨

System.out.println(s8);

输出结果:

Hello World

Hello World

Hello World

她的年龄是18岁。

她的英语成绩是A

今天是:Thu May 25 16:25:40 CST 2017

上述代码第①~②行使用+运算符进行字符串的拼接,其中产生了三个对象。代码第③~④行业是使用+=赋值运算符, 本质 上也是+运算符进行拼接。

代码第⑤行采用concat方法进行拼接,该方法的完整定义如下:

public String concat(String str)

它的参数和返回值都是String,因此代码第⑤行可以连续调用该方法进行多个字符串的拼接。

代码第⑥和第⑦行是使用+运算符,将字符串与其他类型数据进行的拼接。代码第⑨行是与对象可以进行拼接,Java中所有对象都有一个toString()方法,该方法可以将对象转换为字符串,拼接过程会调用该对象的toString()方法,将该对象转换为字符串后再进行拼接。代码第⑧行的java.util.Date类是Java SE提供的日期类。

字符串查找

在给定的字符串中查找字符或字符串是比较常见的操作。在String类中提供了indexOf和lastIndexOf方法用于查找字符或字符串,返回值是查找的字符或字符串所在的位置,-1表示没有找到。这两个方法有多个重载版本:

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

[ 图片 上传中…(10-6.jpg-790da8-1530662260524-0)]

提示 字符串本质上是字符数组,因此它也有索引,索引从零开始。String的charAt(int index)方法可以返回索引index所在位置的字符。

字符串查找示例代码如下:

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

sourceStr字符串索引如图9-6所示。上述字符串查找方法比较类似,这里重点解释一下sourceStr.indexOf("ing", 5)和sourceStr.lastIndexOf("ing", 5)表达式。从图9-6可见ing字符串出现过两次,索引分别是14和24。sourceStr.indexOf("ing", 5)表达式从索引为5的字符(" ")开始从前往后搜索,结果是找到第一个ing(索引为14),返回值为14。sourceStr.lastIndexOf("ing", 5)表达式从索引为5的字符(" ")开始从后往前搜索,没有找到,返回值为-1。

《Java从小白到大牛》之第9章 字符串

字符串比较

字符串比较是常见的操作,包括比较相等、比较大小、比较前缀和后缀串等。

  1. 比较相等

String提供的比较字符串相等的方法:

  • boolean equals (Object anObject):比较两个字符串中内容是否相等。
  • boolean equalsIgnoreCase(String anotherString):类似equals方法,只是忽略大小写。

    1. 比较大小

有时不仅需要知道是否相等,还要知道大小,String提供的比较大小的方法:

  • int compareTo(String anotherString):按字典顺序比较两个字符串。如果参数字符串等于此字符串,则返回值 0;如果此字符串小于字符串参数,则返回一个小于 0 的值;如果此字符串大于字符串参数,则返回一个大于 0 的值。
  • int compareToIgnoreCase(String str):类似compareTo,只是忽略大小写。

    1. 比较前缀和后缀
  • boolean endsWith(String suffix): 测试 此字符串是否以指定的后缀结束。

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

字符串比较示例代码如下:

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))); ①

// 忽略大小写比较字符串大小 s4 < s5

System.out.println("s4.compareToIgnoreCase(s5) : " + (s4.compareToIgnoreCase(s5))); ②

// 判断文件夹中文件名

String[] docFolder = { "java.docx", " JavaBean.docx", "Objecitve-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);

输出结果:

s1 == s2 : false

s1.equals(s2) : true

s1.equalsIgnoreCase(s3) : true

s4.compareTo(s5) : 23

s4.compareToIgnoreCase(s5) : -9

文件夹中Word文档个数是: 3

文件夹中Java相关文档个数是:2

上述代码第①行的compareTo方法按字典顺序比较两个字符串,s4.compareTo(s5)表达式返回结果大于0,说明s4大于s5,字符在字典中顺序事实上就它的Unicode编码,先比较两个字符串的第一个字符j和S,j的Unicode编码是106,S的Unicode编码是83,所以可以得出结论s4 > s5。代码第②行是忽略大小写时,要么全部当成小写字母进行比较,要么当前成全部大写字母进行比较,无论哪种比较结果都是一样的s4 < s5。

代码第③行trim()方法可以去除字符串前后空白。代码第④行toLowerCase()方法可以将此字符串全部转化为小写字符串,类似的方法还有toLowerCase()方法,可将字符串全部转化为小写字符串。

字符串截取

Java中字符串String截取方法主要的方法如下:

  • String substring(int beginIndex):从指定索引beginIndex开始截取一直到字符串结束的子字符串。
  • String substring(int beginIndex, int endIndex):从指定索引beginIndex开始截取直到索引endIndex – 1处的字符,注意包括索引为beginIndex处的字符,但不包括索引为endIndex处的字符。

字符串截取方法示例代码如下:

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);

}

输出结果:

subStr1 = example.

subStr2 = string

-----使用split方法-----

There

is

a

string

accessing

example.

上述sourceStr字符串索引参考图9-6所示。代码第①行是截取example.子字符串,从图9-6可见e字符索引是28, 从索引28字符截取直到sourceStr结尾。代码第②行是截取string子字符串,从图9-6可见,s字符索引是11,g字符索引是16,endIndex参数应该17。

另外,String还提供了字符串分割方法,见代码第③行split(" ")方法,参数是分割字符串,返回值String[]。

可变字符串

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

StringBuffer和StringBuilder

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

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

StringBuffer和StringBuilder具有完全相同的API,即构造方法和方法等内容一样。StringBuilder的中构造方法有4个:

  • StringBuilder():创建字符串内容是空的StringBuilder对象,初始容量默认为16个字符。
  • StringBuilder(CharSequence seq):指定CharSequence字符串创建StringBuilder对象。CharSequence接口类型,它的实现类有:String、StringBuffer和StringBuilder等,所以参数seq可以是String、StringBuffer和StringBuilder等类型。
  • StringBuilder(int capacity):创建字符串内容是空的StringBuilder对象,初始容量由参数capacity指定的。
  • StringBuilder(String str):指定String字符串创建StringBuilder对象。

上述构造方法同样适合于StringBuffer类,这里不再赘述。

提示 字符串长度和字符串缓冲区容量区别。字符串长度是指在字符串缓冲区中目前所包含字符串长度,通过length()获得;字符串缓冲区容量是缓冲区中所能容纳的最大字符数,通过capacity()获得。当所容纳的字符超过这长度时,字符串缓冲区自动扩充容量,但这是以牺牲新能为代价的扩容。

字符串长度和字符串缓冲区容量示例代码如下:

// 字符串长度length和字符串缓冲区容量capacity

StringBuilder sbuilder1 = new StringBuilder();

System.out.println("包含的字符串长度:" + sbuilder1.length());

System.out.println("字符串缓冲区容量:" + sbuilder1.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

### 字符串追加 {#-0}

StringBuilder在提供了很多修改字符串缓冲区的方法,追加、插入、删除和替换等,这一节先介绍字符串追加方法。字符串追加方法是append,append有很多重载方法,可以追加任何类型数据,它的返回值还是StringBuilder。StringBuffer的追加法与StringBuffer完全一样,这里不再赘述。

字符串追加示例代码如下:

//添加字符串、字符

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);

运行结果:

Hello World.

false null
456789

上述代码第①行是创建一个包含Hello字符串StringBuilder对象。代码第②行是两次连续调用append方法,由于所有的append方法都返回StringBuilder对象,所有可以连续调用该方法,这种写法比较简洁。如果连续调用append方法不行喜欢,可以append方法占一行,见代码第③行。

代码第④行连续追加了布尔值、转义符和空对象,需要注意的是布尔值false转换为false字符串,空对象null也转换为"null"字符串。

字符串插入、删除和替换

StringBuilder中实现插入、删除和替换等操作的常用方法说明如下:

  • 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 start, int end, String str)字符串缓冲区中用str替换子字符串,子字符串从指定索引start开始直到索引end – 1处的字符。start和end同delete(int start, int end)方法。

以上介绍的方法虽然是StringBuilder方法,但StringBuffer也完全一样,这里不再赘述。

示例代码如下:

// 原始不可变字符串

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);

运行输出结果:

Java C++ C

Java C++ C Objective-C

Java C++ C Objective-C and Swift

Java C++ C and Swift

上述代码第①行mstr.insert(4, " C++")是在索引4,插入字符串,原始字符串索引如同9-7所示,索引4位置是一个空格,在它之前插入字符串。代码第②行mstr.insert(mstr.length(), " Objective-C")是按照字符串的长的插入,也就是在尾部追加字符串。在执行代码第③行删除字符串之前的字符串如图9-8所示,mstr.delete(11, 23)语句是要删除"Objective-C "子字符串,第一个参数是子字符串开始索引11;第二个参数是23,结束字符的索引是22(end – 1),所以参数end是23。

《Java从小白到大牛》之第9章 字符串

《Java从小白到大牛》之第9章 字符串

本章小结

本周介绍了Java中的字符串,Java字符串类分为:可变字符串类(String)和不可变字符串类(StringBuilder和StringBuffer)。然后分别介绍了这些字符串类的用法。

配套视频

https ://edu.csdn.net/combo/detail/594

配套源代码

http://www.zhijieketang.com/group/5

与本书 免费 版对应的还有一个收费版本:

原文

https://blog.csdn.net/tonny_guan/article/details/80999242

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。 PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处: Harries Blog™ » 《Java从小白到大牛》之第9章 字符串

作者:Harries Blog™
追心中的海,逐世界的梦
原文地址:《Java从小白到大牛》之第9章 字符串, 感谢原作者分享。

发表评论