Java基础-字符串（String）常用方法

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

一.java的API概念

　　Java的API（API：Application(应用) Programming(程序) Interface(接口)）就是JDK中提供给我们的类，这些类将底层的代码封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。

　　在JDK安装目录下有个src.zip文件，这个文件解压缩后里面的内容是所有java类的源文件，可以在其中查看相应类的源码。我们每次查看类中的方法时，都打开源代码进行查看，这种方式过于麻烦。其实，我们可以通过查帮助文档的方式，来了解Java提供的API如何使用。如下图操作(我们以查看String类为例)：

　　如何查看类中的方法，我们需要选择相应的方法按钮即可：

　　如果想要查看文件当的详细信息，可以按照如下的操作进行：

　　查看方法的详细信息：

　　想要知道该方法的效果是咋样的吗？很简单的啊，在IDE体会一下不就OK了吗？

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.test01;
 8 
 9 public class StringDemo {
10     public static void main(String[] args) {
11         String Name = "yinzhengjie";
12         System.out.println(Name.charAt(5));        //查看下标索引为6的字符。
13     }
14 }
15 
16 
17 /*
18  * 以上代码执行结果如下：
19  * e
20  */

二.Object类

　　在以前的学习过程中，我们都在学习对象基本特征，对象的使用以及对象的关系。接下来我们开始使用对象做事情，那么在使用对象做事情之前，我们要学习一些API中提供的常用对象。首先来学习API中的Object这个类。

1>.Object类概述

　　object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候，最终找的父类就是Object。在Object类众多方法中，我们先学习equals方法和toString方法，其它的我会陆续给大家分享。

2>.equals方法比较内存地址

　　指示其他某个对象是否与此对象“相等”。

　　既然Object是所有类的祖宗，相当于女娲娘娘~那么女娲娘娘的一些特性自然会被其子类继承，也就是说我们之前定义的每一个类中都自动继承了Object的所有方法属性。比如我们定义一个Person类，并生成2个我们自定义的类，让新生成的两个类进行比较。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.test01;
 8 
 9 class Person{
10     private String Name;
11     private int Age;
12     
13     public Person(String name, int age) {
14         Name = name;
15         Age = age;
16     }
17     
18     public Person() {}
19     
20     public String getName() {
21         return Name;
22     }
23     public void setName(String name) {
24         Name = name;
25     }
26     public int getAge() {
27         return Age;
28     }
29     public void setAge(int age) {
30         Age = age;
31     }
32     
33     /*
34      * 将父类的equals方法歇过来，重写父类的方法，但是不改变方法的源代码，方法equals比较两个对象的内存地址。
35      */
36     public boolean equals(Object obj) {
37         return this == obj;
38     }
39 }
40 
41 
42 public class PersonDemo {
43 
44     public static void main(String[] args) {
45         //Person类继承Object类，继承下来了父类的方法equals。
46         Person p1 = new Person("尹正杰",18);
47         Person p2 = new Person("yinzhengjie",18);
48         
49         //Person对象p1，调用父类的方法equals，进行对象的比较。
50         boolean b = p1.equals(p2);
51         System.out.println(b);
52     }
53 }
54 
55 
56 
57 
58 /*
59  * 以上代码执行结果如下：
60  * false
61  * */

　　为什么我们看到的是一个布尔值呢？其实这都是equals方法在搞鬼。在equals的方法中只有一个返回值“this == obj;”，看起来很简单不是吗？this关键字指的是调用者自己，很明显我们上面的代码调用者就是p1这个对象。那obj又是谁呢？当然是传递的参数对象啦，也就是我们代码中的P2，引用数据类型的比较当然是比较的是对象内存的地址，很显然p1和p2都是在堆内存中new出来的2个不同的内存地址，因此返回的值为false。

3>.重写equals方法

　　两个对象比较地址是没有任何意义的，因为内存的地址就没有可比性，就好比现实生活中我家地址在北京朝阳区，你家地址在北京海淀区，这有什么可比较性呢？地址自然是不一一的！而内存地址主要的作用是存储数据的。因此比较数据的内存地址是无意义的，而我们比较两个对象的成员变量还是有实际意义的。

　　我们可以把上面的代码进行改写，我们可以比较两个人的年龄是否相同，如果想用就返回true，如果不想同就返回false。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.test01;
 8 
 9 class Person{
10     private String Name;
11     private int Age;
12     public Person(String name, int age) {
13         Name = name;
14         Age = age;
15     }    
16     public Person() {}
17     
18     public String getName() {
19         return Name;
20     }
21     public void setName(String name) {
22         Name = name;
23     }
24     public int getAge() {
25         return Age;
26     }
27     public void setAge(int age) {
28         Age = age;
29     }
30     /*
31      * 复写父类的equals方法，实现自己的比较方式,注意传入的obj其类型指向的是Object，用到的就是多态特性！
32      */
33     public boolean equals(Object obj) {
34         //1>.判断当前调用者equals方法的对象和传递进来的对象是否是同一个。
35         if(this == obj) {
36             return true;
37         }
38         //2>.判断传递进来的对象是否是Person类型
39         if(!(obj instanceof Person)) {
40             return false;
41         }
42         //3>.将obj向下转型，访问其属性
43         Person p = (Person)obj;
44         return this.Age == p.Age;
45         
46     }
47 }
48 
49 
50 public class PersonDemo {
51 
52     public static void main(String[] args) {
53         //Person类继承Object类，继承下来了父类的方法equals。
54         Person p1 = new Person("尹正杰",18);
55         Person p2 = new Person("yinzhengjie",18);
56         
57         //Person对象p1，调用重写后的equals方法。比较的是两个人的连年龄。
58         boolean b = p1.equals(p2);
59         System.out.println(b);
60     }
61 }
62 
63 
64 
65 
66 /*
67  * 以上代码执行结果如下：
68  * true
69  * */

4>.重写toString方法

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.test01;
 8 
 9 class Person{
10     private String Name;
11     private int Age;
12     public Person(String name, int age) {
13         Name = name;
14         Age = age;
15     }    
16     public Person() {}
17     
18     public String getName() {
19         return Name;
20     }
21     public void setName(String name) {
22         Name = name;
23     }
24     public int getAge() {
25         return Age;
26     }
27     public void setAge(int age) {
28         Age = age;
29     }
30     //toString()方法是输出语句默认调用方法。
31     public String toString() {
32         return Name + Age;
33     }
34 }
35 
36 
37 public class PersonDemo {
38 
39     public static void main(String[] args) {
40         
41         Person p1 = new Person("尹正杰",18);
42         
43         //调用Person类的方法toString()，很显然，在输出语句中，写的一个对象，默认调用的toString方法。
44         System.out.println(p1);
45         System.out.println(p1.toString());
46         
47     }
48 }
49 
50 
51 
52 
53 /*
54  * 以上代码执行结果如下：
55  * true
56  * */

三.String类

1>.String类的概述

　　参考Java的API文档，发现String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。字符串是常量；它们的值在创建之后不能更改（换句话说，字符串是一个常量，一旦创建String 对象就不能改变）。字符串缓冲区支持可变的字符串。我们可以理解只要用双引号(" ")引起来的都是字符串。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         String Name = "yinzhengjie";
12         System.out.println(Name);
13         Name = "尹正杰";
14         System.out.println(Name);
15     }
16 }
17 
18 
19 /*
20  * 以上代码执行结果如下：
21  * yinzhengjie
22  * 尹正杰
23  * 
24  */

　　我们所说的对象不变指的是字符串本身，要知道字符串本身就是一个对象，运行的时候，字符串对象在堆内存中。以上程序中引用变量“Name”指向内存地址发生变化啦，但是定义好的字符串对象（"yinzhengjie","尹正杰"）是不变的哟,我们可以来画一张图来帮助理解。如下：

2>.String特征之一不可变性

　　字符串的本质就是一个字符数组，不信你可以查看源码，下图是我在java9.0版本的源码查看到的相关代码。

3>.String类创建方式和比较

　　字符串有大量的重载的构造方法，通过String类的构造方法可以完成字符串对象的创建，那么，通过使用双引号的方式创建对象与new的方式创建对象，有上面不同呢？

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         String Name1 = new String("尹正杰");
12         System.out.println(Name1);
13         String Name2 = "尹正杰";
14         System.out.println(Name2);
15         
16         //引用数据类型，比较对象的地址
17         System.out.println(Name1 == Name2);        //false    
18         //String类继承了Object，重写了父类的方法equals，建立了字符串自己的比较方式，字符串中的每个字符是否相同。
19         System.out.println(Name1.equals(Name2));//ture
20     }
21 }
22 
23 
24 /*
25  *以上代码执行结果如下：
26  *尹正杰
27  *尹正杰
28  *false
29  *true
30  */

　　以上代码判断“Name1”和"Name2"的内存地址是否相同，答案是否定的，因为，用new关键字创建字符串时，会自动在堆内存开辟一块单独的内存空间，我们可以简单的画图如下：

　　而后面又比较了"Name1"与"Name2"的值是否相同，我们用肉眼就已经看出来了，答案是肯定的，没错，Java源代码设计也是这样的（他们比较的是对象中存储的value是否都相同，如果相同则返回ture.)，具体代码如下：

4>.String类构造方法

a>.传递字节数组（"String(byte[] bytes);"）

　　通过使用平台（操作系统）的默认字符集（操作系统的默认编码表，如Windows默认字符编码是GBK，Linux默认编码是UTF-8等，不过不管你是那种默认编码都是兼容了ACSSI编码表的哟！）解码指定的byte数组，构造一个新的String。换句话说，该方法是将字节数中的每个字节，查询了编码表，得到的结果。字节是负数，汉字的字节编码就是负数，默认编码表，一个汉字采用2个字节表示。具体代码如下：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         byte[] bytes = {97,98,99,100};
16         //调用String类的构造方法，传递字节数组。
17         String s1 = new String(bytes);
18         System.out.println(s1);
19         
20         //如果你的操作系统是中文版本的Windows的话，字节数组中的成员尽量成对(GBK默认是以2个字节进行编码)出现，或是偶数长度即可
21         byte[] bytes2 = {-60,-61,-62,-63,-64,-65};
22         String s2 = new String(bytes2);
23         System.out.println(s2);
24     }
25 }
26 
27 
28 /*
29  * 以上代码执行结果如下：
30  * abcd
31  * 拿铝揽
32  */

String(byte[] bytes); 用法展示

b>.传递指定的字节数组（“String(byte[] bytes,int offset,int length);”）

　　通过使用平台默认字符集解码指定的byte子数组，构造一个新的String。新String的长度是字符集的函数，因此可能不等于该子数组的长度。换句话说，就是你可以对传入的数组进行自定义控制解码，其中传入的变量“bytes”是要解码的字符的byte，offset是要解码的第一个byte的索引，length是要解码的byte数。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         byte[] bytes = {97,98,99,100,101,102,103,104};
16         //调用String类的构造方法，传递需要解码的数组(bytes)，起始索引(offset)，从起始索引的长度(length)
17         String s1 = new String(bytes,1,5);
18         System.out.println(s1);
19     }
20 }
21 
22 
23 /*
24  * 以上代码执行结果如下：
25  * bcdef
26  */

String(byte[] bytes,int offset,int length); 用法展示

c>.传递字符数组（“String(char[] value)”）

　　将字符数组转成字符串，字符数组的参数不查询编码表。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         char[] ch = {'a','b','c','d','e','f','g'};
16         //调用String构造方法，传递字符数组
17         String s1 = new String(ch);
18         System.out.println(s1);
19     }
20 }
21 
22 
23 /*
24  * 以上代码执行结果如下：
25  * abcdefg
26  */

String(char[] value); 用法展示

d>.将字符数组的一部分转成字符串（"(char[] value,int offset,int count)"）

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         char[] ch = {'a','b','c','d','e','f','g'};
16         //调用String构造方法，传递字符数组
17         String s1 = new String(ch,1,4);
18         System.out.println(s1);
19     }
20 }
21 
22 
23 /*
24  * 以上代码执行结果如下：
25  * bcde
26  */

"(char[] value,int offset,int count)" 用法展示

5>.String类的常用方法

　　String类中有很多的常用的方法，我们在学习一个类的时候，不要盲目的把所有的方法尝试去使用一遍，这时我们应该根据这个对象的特点分析这个对象应该具备哪些功能，这样大家应用起来更方便。字符串是一个对象，那么它的方法必然是围绕操作系统这个对象的数据而定义的。接下来我们就一起来看看字符串的常用方法。

a>.length()属性

　　用于获取字符串长度，案例展示如下：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String s1 = "woyouyizhixiaomaolv,conglaiyebuqi!";
16         int lenth = s1.length();
17         System.out.println(lenth);
18     }
19 }
20 
21 
22 /*
23  * 以上代码执行结果如下：
24  * 34
25  */

String.length(); 用法展示

b>.substring(int beginIndex)属性

　　用于获取字符串一部分，案例展示如下：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String src = "woyouyizhixiaomaolv,conglaiyebuqi!";
16         //获取字符串一部分并赋值给s1，包含起始索引以及字符串后面的所有字符都截取。
17         String s1 = src.substring(10);
18         //获取字符串的一部分并赋值给s2，需要传入起始位置和结束位置。
19         String s2 = src.substring(2,5);
20         System.out.println(src);
21         System.out.println(s1);
22         System.out.println(s2);
23     }
24 }
25 
26 
27 /*
28  * 以上代码执行结果如下：
29  * woyouyizhixiaomaolv,conglaiyebuqi!
30  * xiaomaolv,conglaiyebuqi!
31  * you
32  */

substring(int beginIndex); 用法展示

c>.startsWith(String prefix)属性

　　用于判断一个字符串是不是另一个字符串的前缀，或者你可以理解判断一个字符串是否以变量“prefix”开头。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String Name = "yinzhengjie";
16         boolean flag = Name.startsWith("yin");
17         System.out.println(flag);
18     }
19 }
20 
21 
22 /*
23  * 以上代码执行结果如下：
24  * true
25  */

startsWith(String prefix) 用法展示

d>.endsWith(String suffix)属性

　　用于判断一个字符串是不是另一个字符串的后缀，结尾

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String Name = "yinzhengjie";
16         boolean flag = Name.endsWith("jie");
17         System.out.println(flag);
18     }
19 }
20 
21 
22 /*
23  * 以上代码执行结果如下：
24  * true
25  */

endsWith(String prefix); 用法展示

e>.contains(String s)属性

　　用于判断一个字符串中，是否包含另一字符串。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String Name = "yinzhengjie";
16         String Name2 = "zhengjie";
17         boolean flag = Name.contains(Name2);
18         System.out.println(flag);
19         
20     }
21 }
22 
23 
24 /*
25  * 以上代码执行结果如下：
26  * true
27  */

contains(String s); 用法展示

f>.indexOf(char ch)属性

　　用于查找一个字符在字符串中第一次出现的索引。如果被查找的字符不存在，就会返回一个-1，因为负数不能当索引。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String Name = "yinzhengjie";
16         int index = Name.indexOf("j");
17         System.out.println(index);
18         
19     }
20 }
21 
22 
23 /*
24  * 以上代码执行结果如下：
25  * 8
26  */

indexOf(char ch); 用法展示

g>.getByte()属性

　　用于将字符串转换成字节数组，此功能和String构造方法相反，byte数组相关的功能，查询编码表。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String Name = "yinzhengjie";
16         byte[] bytes = Name.getBytes();
17         for (int i = 0; i < bytes.length; i++) {
18             System.out.println(bytes[i]);
19         }
20         
21     }
22 }
23 
24 
25 /*
26 以上代码执行结果如下： 
27 121
28 105
29 110
30 122
31 104
32 101
33 110
34 103
35 106
36 105
37 101
38  */

getByte() 属性用法展示

h>.toCharArray() 属性

　　用于将字符串转成字符数组，功能和构造方法相反。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String Name = "yinzhengjie";
16         char[] ch = Name.toCharArray();
17         for (int i = 0; i < ch.length; i++) {
18             System.out.println(ch[i]);
19         }
20     }
21         
22 }
23 
24 /*
25 以上代码执行结果如下：
26 y
27 i
28 n
29 z
30 h
31 e
32 n
33 g
34 j
35 i
36 e
37 */

toCharArray(); 用法展示

i>.equals(Object obj) 属性

　　用于判断字符串中的字符是否完全相同，如果完全相同就返回ture.

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String Name = "yinzhengjie";
16         String Name2 = new String("yinzhengjie");
17         boolean flag = Name.equals(Name2);
18         System.out.println(flag);
19         }
20 }
21 
22 /*
23 以上代码执行结果如下：
24 true
25 */

equals(Object obj) 案例展示、

j>.equalsIgnoreCase(String s)属性

　　用于判断字符串中的字符是否相同，忽略大小写！

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         function();
12     }
13     
14     public static void function() {
15         String Name = "yinzhengjie";
16         String Name2 = "YINzhengJIE";
17         boolean flag = Name.equals(Name2);
18         boolean flag2 = Name.equalsIgnoreCase(Name2);
19         System.out.println(flag);
20         System.out.println(flag2);
21         }
22 }
23 
24 /*
25 以上代码执行结果如下：
26 false
27 true
28 */

equalsIgnoreCase(String s) 案例展示

6>.String类方法使用练习

　　String类的常用方法基本上就是上面总结的，那么你是否都熟练掌握了呢？我们可以做几道题来巩固一下你的知识点。

a>.获取指定字符串中，大写字母，小写字母，数字的个数

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         getCount("YinZhengJie@ 2018dashuju!!!!");
12     }
13     
14     public static void getCount(String s) {
15         int upper = 0;         //定义大写字母的计数器
16         int lower = 0;         //定义小写字母的计数器
17         int digit = 0;        //定义数字的计数器
18         int other = 0;        //定义其它字符的计数器
19         
20         for (int index = 0; index < s.length(); index++) {
21             char ch = s.charAt(index);    //获取到当前的字符。
22             if(ch >= 'A' && ch <= 90) {    //注意ch是字符，它默认会查询编码表中对应的数字，定义大写字母的数组区间。‘A’对应的是65
23                 upper++;                
24             }else if(ch >= 'a' && ch<=122) {    //小写的'a'对应97
25                 lower++;
26             }else if(ch >= '0' && ch <= 57) {   //数字的'0'对应的是48
27                 digit++;
28             }else {
29                 other++;
30             }
31         }
32         System.out.printf("大写字母个数[%d]\n小写字母个数[%d]\n数字个数[%d]\n其它个数[%d]\n",upper,lower,digit,other);
33         
34         
35         
36     }
37 }
38 
39 /*
40 以上代码执行结果如下：
41 大写字母个数[3]
42 小写字母个数[15]
43 数字个数[4]
44 其它个数[6]
45 */

本提的参考解法一，本题的解法有很多种，答案不一致很正常，初学者实现效果就好！

 1 package cn.org.yinzhengjie.demo;
 2 
 3 public class CharacterDemo {
 4     public static void main(String[] args) {
 5         String s = "YinZhengJie@ 2018dashuju!!!!";
 6         getCounts(s);
 7         
 8     }
 9     
10     public static void getCounts(String s){
11         int upper=0;
12         int lower=0;
13         int digit=0;
14         int other=0;
15         char[] ch = s.toCharArray();
16         for (int i = 0; i < ch.length; i++) {
17             if(Character.isDigit(ch[i])){        //判断是否是数字
18                 digit++;
19             }else if(Character.isLowerCase(ch[i])){  //判断是否是小写
20                 lower++;
21             }else if(Character.isUpperCase(ch[i])){   //判断是否是大写
22                 upper++;
23             }else{
24                 other++;
25             }
26         }
27         System.out.printf("大写字母个数[%d]\n小写字母个数[%d]\n数字个数[%d]\n其它个数[%d]\n",upper,lower,digit,other);
28     }
29 }
30 
31 
32 
33 
34 /*
35 以上代码执行结果如下：
36 大写字母个数[3]
37 小写字母个数[15]
38 数字个数[4]
39 其它个数[6]
40 */

本提的参考解法二，本题的解法有很多种，答案不一致很正常，初学者实现效果就好！

 1 package cn.org.yinzhengjie.demo;
 2 
 3 public class CharacterDemo {
 4     public static void main(String[] args) {
 5         String s = "YinZhengJie@ 2018dashuju!!!!";
 6         getCounts(s);
 7         
 8     }
 9     
10     public static void getCounts(String s){
11         int upper=0;
12         int lower=0;
13         int digit=0;
14         int other=0;
15         for (int i = 0; i < s.length(); i++) {
16             char ch = s.charAt(i);
17 
18             if(Character.isDigit(ch)){        //判断是否是数字
19                 digit++;
20             }else if(Character.isLowerCase(ch)){  //判断是否是小写
21                 lower++;
22             }else if(Character.isUpperCase(ch)){   //判断是否是大写
23                 upper++;
24             }else{
25                 other++;
26             }
27         }
28         System.out.printf("大写字母个数[%d]\n小写字母个数[%d]\n数字个数[%d]\n其它个数[%d]\n",upper,lower,digit,other);
29     }
30 }
31 
32 
33 
34 
35 /*
36 以上代码执行结果如下：
37 大写字母个数[3]
38 小写字母个数[15]
39 数字个数[4]
40 其它个数[6]
41 */

本提的参考解法三，本题的解法有很多种，答案不一致很正常，初学者实现效果就好！

b>..将字符串中，第一个字母转成大写，其它字母转换成小写，并打印改变后的字符串打印出来

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         getCount("yinZhengJie@ 2018DASHUJU!!!!");
12     }
13     
14     public static void getCount(String s) {
15         //获取大写字母
16         String Initials = s.substring(0,1);
17         //获取小写字母
18         String ResidualLetters = s.substring(1);
19         Initials = Initials.toUpperCase();
20         ResidualLetters = ResidualLetters.toLowerCase();
21         System.out.println(Initials+ResidualLetters);        
22     }
23 }
24 
25 /*
26 以上代码执行结果如下：
27 Yinzhengjie@ 2018dashuju!!!!
28 */

本提的参考解法，本题的解法有很多种，答案不一致很正常，初学者实现效果就好！

c>.查询大写字符串中，出现指定小字符串的次数,如:"hellojava,java world java,howjava are you!java"中查询"java"的次数

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 package cn.org.yinzhengjie.demo;
 8 
 9 public class StringDemo1 {
10     public static void main(String[] args) {
11         String src = "hellojava,java world java,howjava are you!java";
12         int counts = getCount(src,"java");
13         System.out.printf("字符串出现的次数是：%d",counts);
14         
15     }
16     
17     public static int getCount(String src,String value) {
18         //定义计数器，用于返回value出现的次数
19         int counts = 0;
20         //定义索引，保存每次indexOf查找的后的int值
21         int index = 0;
22         
23         while((index = src.indexOf(value)) != -1) {
24             counts++;
25             src = src.substring(index+value.length());
26         }
27         return counts;
28         
29     }
30 }
31 
32 /*
33 以上代码执行结果如下：
34 字符串出现的次数是：5
35 */

本提的参考解法，本题的解法有很多种，答案不一致很正常，初学者实现效果就好！

posted @ 2018-04-15 01:17 尹正杰阅读(1089) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

尹正杰

Java基础-字符串（String）常用方法

公告