• Java基础-字符串(String)常用方法


                    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]
    小写字母个数[%d]
    数字个数[%d]
    其它个数[%d]
    ",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]
    小写字母个数[%d]
    数字个数[%d]
    其它个数[%d]
    ",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]
    小写字母个数[%d]
    数字个数[%d]
    其它个数[%d]
    ",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 */
    本提的参考解法,本题的解法有很多种,答案不一致很正常,初学者实现效果就好!
  • 相关阅读:
    偏倚有感
    SAS--修改默认语言
    SAS--EXCEL读写、批量读EXCEL
    SAS--sql2
    Day2----respondToValue
    python的一些遗漏用法
    一些常见的东西
    爬虫学习06用selenium爬取空间
    爬虫学习04.
    爬虫学习03常用模块
  • 原文地址:https://www.cnblogs.com/yinzhengjie/p/8840461.html
Copyright © 2020-2023  润新知