java中的String类

1、String类

1.1 、String类两种对象实例化方式

         对于String在之前已经学习过了基本使用，就是表示字符串，那么当时使用的形式采用了直接赋值：

public class StringDemo {

         public static void main(String args[]) {

                   String str = "Hello" ;    // 定义字符串

                   System.out.println(str) ;

         }

}

         对于String而言肯定是一个类，那么程序之中出现的str应该就是这个类的对象，那么就证明以上的赋值操作实际上就表示要为String类的对象进行实例化操作。

         但String毕竟是一个类，那么类之中一定会存在构造方法，String类的构造：public String(String str)；

public class StringDemo {

         public static void main(String args[]) {

                   String str = new String("Hello") ;   // 定义字符串

                   System.out.println(str) ;

         }

}

         发现现在也可以通过构造方法为String类对象实例化。

1.2 、字符串比较

         如果说现在有两个int型变量，如果要想知道是否相等，使用“==”进行验证。

public class StringDemo {

         public static void main(String args[]) {

                   int x = 10 ;

                   int y = 10 ;

                   System.out.println(x == y) ;

         }

}

         但是，同样的操作，现在换成String完成。

public class StringDemo {

         public static void main(String args[]) {

                   String str1 = "Hello" ;

                   String str2 = new String("Hello") ;

                   String str3 = str2 ;        // 引用传递

                   System.out.println(str1 == str2) ;    // false

                   System.out.println(str1 == str3) ;    // false

                   System.out.println(str2 == str3) ;    // true

         }

}

    

         现在使用了“==”的确是完成了相等的判断，但是最终判断的是两个对象（现在的对象是字符串）判断是否相等，属于数值判断 —— 判断的是两个对象的内存地址数值，并没有判断内容，而要想完成字符串内容的判断，则就必须使用到String类的操作方法：public boolean equals(String str)（将方法暂时变了）。

public class StringDemo {

         public static void main(String args[]) {

                   String str1 = "Hello" ;

                   String str2 = new String("Hello") ;

                   String str3 = str2 ;        // 引用传递

                   System.out.println(str1.equals(str2)) ;      // true

                   System.out.println(str1.equals(str3)) ;      // true

                   System.out.println(str2.equals(str3)) ;      // true

         }

}

         现在比较的不再是内存地址的数值，而是两个字符串的内容。

1.3 、字符串常量是String的匿名对象

         如果在程序之中定义了字符串（使用“"”），那么这个就表示一个String对象，因为在各个语言之中没有关于字符串数据类型定义，而Java将其简单处理了，所以感觉上存在了字符串类型。

范例：验证字符串是对象的概念

public class StringDemo {

         public static void main(String args[]) {

                   String str = "Hello" ;

                   // 通过字符串调用方法

                   System.out.println("Hello".equals(str)) ;

         }

}

         匿名对象可以调用类之中的方法与属性，以上的字符串可以调用了equals()方法，那么一定是一个对象。

1.4 、String类的两种实例化方式的区别

         对于String类的对象存在了两种实例化的操作形式，那么这两种有什么区别，在开发之中应该使用那一种更好呢？

①        分析直接赋值的情况：

         String str = "Hello" ;

 

         发现现在只开辟了一块堆内存空间和一块栈内存空间。那么随后将代码进行一些修改。

public class StringDemo {

         public static void main(String args[]) {

                   String str1 = "Hello" ;

                   String str2 = "Hello" ;

                   String str3 = "Hello" ;

                   System.out.println(str1 == str2) ;    // true

                   System.out.println(str1 == str3) ;    // true

                   System.out.println(str2 == str3) ;    // true

         }

}

 

解释：关于直接赋值操作之中，字符串比较都是相同的原因

         在String类进行设计的时候采用了一种称为共享设计模式的概念，在每一个运行的JVM底层存在一个字符串的对象池（Object Pool），如果用户采用了直接赋值的方式，会将字符串的内容放入到池之中，以供其他继续使用直接赋值方式的String对象使用，如果新声明的字符串内容不再池之中，则会开辟一个新的，继续放到池，以供下次使用。

②        分析构造方法赋值的情况：

public class StringDemo {

         public static void main(String args[]) {

                   String str = new String("Hello") ;

                   System.out.println(str) ;

         }

}

 

         使用构造方法的方式开辟的字符串对象，实际上会开辟两块空间，其中有一块空间将称为垃圾。

public class StringDemo {

         public static void main(String args[]) {

                   String str1 = new String("Hello") ;

                   String str2 = "Hello" ;  // 入池

                   String str3 = "Hello" ;  // 使用池对象

                   System.out.println(str1 == str2) ;    // false

                   System.out.println(str1 == str3) ;    // false

                   System.out.println(str2 == str3) ;    // true

         }

}

         通过上面的程序可以发现，使用构造方法实例化的String对象，不会入池，所以，只能自己使用。可是在String类之中为了方便操作提供了一种称为手工入池的方法：public String intern()。

public class StringDemo {

         public static void main(String args[]) {

                   String str1 = new String("Hello").intern() ;

                   String str2 = "Hello" ;  // 入池

                   String str3 = "Hello" ;  // 使用池对象

                   System.out.println(str1 == str2) ;    // true

                   System.out.println(str1 == str3) ;    // true

                   System.out.println(str2 == str3) ;    // true

         }

}

1.5 、字符串的内容一旦声明则不可改变

         字符串类的操作特点决定：字符串不可能去修改里面的内容，所以，如果以后在开发之中有如下程序。

 

public class StringDemo {

         public static void main(String args[]) {

                   String str = "Hello " ;

                   str += "World " ;

                   str = str + "!!!" ;

                   System.out.println(str) ;

         }

}

         通过以上的代码可以发现，字符串内容的更改，实际上改变的是字符串对象的引用过程，并且会伴随有大量的垃圾出现，那么对于以下的代码实际之中应该避免：

public class StringDemo {

         public static void main(String args[]) {

                   String str = "" ;

                   for (int x = 0 ; x < 1000 ; x ++) {

                            str += x ;

                   }

                   System.out.println(str) ;

         }

}

         但是这种代码需要“断开-连接”String对象1000次，会产生大量垃圾，所以不能够去使用。

2、String类的常用方法

2.1 、字符串与字符

         在很多的语言之中，都强调，字符串由字符数组所组成，那么这一概念在Java的String类之中也有体现。

No.

方法名称

类型

描述

1

public String(char[] value)

构造

将全部的字符数组内容变为字符串

2

public String(char[] value, int offset, int count)

构造

将部分字符数组变为字符串，offset表示开始点，count表示要操作的长度

3

public char charAt(int index)

普通

取得指定索引位置上的字符

4

public char[] toCharArray()

普通

将字符串转换为字符数组

范例：验证charAt()方法，这个方法是一个标志性方法

public class StringDemo {

         public static void main(String args[]) {

                   String str = "helloworld" ;

                   char c = str.charAt(7) ;

                   System.out.println(c) ;

         }

}

范例：字符串和字符数组转换，完成一个小写字符串变为大写字符串的操作，小写字母和大写字母差了32

public class StringDemo {

         public static void main(String args[]) {

                   String str = "helloworld" ;

                   char data [] = str.toCharArray() ;     // 字符串变为字符数组

                   for (int x = 0 ; x < data.length ; x ++) {

                            System.out.print(data[x] + "、") ;

                            data [x] -= 32 ;    // 变大写

                   }

                   System.out.println() ;

                   System.out.println("全部字符数组变为字符串：" + new String(data)) ;

                   System.out.println("部分字符数组变为字符串：" + new String(data,0,5)) ;

         }

}

2.2 、字符串与字节

         字符串除了与字符可以互相转换之外，还可以和字节互相转换，操作方法：

No.

方法名称

类型

描述

1

public String(byte[] bytes)

构造

将全部的字节数组变为字符串

2

public String(byte[] bytes, int offset, int length)

构造

将部分的字节数组变为字符串

3

public byte[] getBytes()

普通

将字符串变为字节数组

4

public byte[] getBytes(String charsetName) throws UnsupportedEncodingException

普通

字符串转码操作

范例：完成一个小写字母变为大写字母的操作

public class StringDemo {

         public static void main(String args[]) {

                   String str = "helloworld" ;

                   byte data [] = str.getBytes() ;  // 字符串变为字节数组

                   for (int x = 0 ; x < data.length ; x ++) {

                            System.out.print(data[x] + "、") ;

                            data [x] -= 32 ;    // 变大写

                   }

                   System.out.println() ;

                   System.out.println("全部字节数组变为字符串：" + new String(data)) ;

                   System.out.println("部分字节数组变为字符串：" + new String(data,0,5)) ;

         }

}

         一般情况下，在程序之中如果要想操作字节数组只有两种情况：

                   · 情况一：需要进行编码的转换时；

                   · 情况二：数据要进行传输的时候。

2.3 、字符串比较

         之前学习了equals()用于比较两个字符串的内容是否相同。

No.

方法名称

类型

描述

1

public boolean equals(String anObject)

普通

区分大小写的相等判断

2

public boolean equalsIgnoreCase(String anotherString)

普通

不区分大小写比较是否相等

3

public int compareTo(String anotherString)

普通

比较两个字符串的大小

范例：equals()方法

public class StringDemo {

         public static void main(String args[]) {

                   String str1 = "helloworld" ;

                   String str2 = "HELLOWORLD" ;

                   System.out.println(str1.equals(str2)) ;

                   System.out.println(str1.equalsIgnoreCase(str2)) ;

         }

}

         如果现在要想比较两个字符串的大小关系，那么就必须使用compareTo()方法完成，而这个方法返回int型数据，而这个int型数据有三种结果：大于（返回结果大于0）、小于（返回结果小于0）、等于（返回结果为0）。

范例：比较大小

public class StringDemo {

         public static void main(String args[]) {

                   String str1 = "Helloworld" ;

                   String str2 = "HELLOWORLD" ;

                   System.out.println(str1.compareTo(str2)) ;

                   System.out.println("Hello".compareTo("Hello")) ;

         }

}

         对于compareTo()方法一定要记住其返回的类型，以后还会有其他的深入讲解。

2.4 、字符串查找

         在Oracle之中如果要想查找一个子字符串是否在指定的字符串之中存在的函数使用的是inst()，而这样的功能在String类之中也是有所提供的，而且提供的方法还有很多种。

No.

方法名称

类型

描述

1

public boolean contains(String s)

普通

查找指定的子字符串是否存在，JDK 1.5之后有

2

public int indexOf(String str)

普通

从头查找指定字符串的位置，找不到返回-1

3

public int indexOf(String str, int fromIndex)

普通

由指定位置向后查找字符串的位置，找不到返回-1

4

public int lastIndexOf(String str)

普通

由后向前查找字符串的位置，找不到返回-1

5

public int lastIndexOf(String str, int fromIndex)

普通

从指定位置由后向前查找

6

public boolean startsWith(String prefix)

普通

判断是否以指定的字符串开头

7

public boolean startsWith(String prefix, int toffset)

普通

从指定位置判断是否以指定字符串开头，JDK 1.7

8

public boolean endsWith(String suffix)

普通

判断是否以指定的字符串结尾

范例：判断开头和结尾操作

public class StringDemo {

         public static void main(String args[]) {

                   String str = "**@@hello##" ;

                   System.out.println(str.startsWith("**")) ;

                   System.out.println(str.startsWith("@@",2)) ;

                   System.out.println(str.endsWith("##")) ;

         }

}

范例：使用contains()方法查找字符串是否存在，直接返回boolean，用于各种的执行判断

public class StringDemo {

         public static void main(String args[]) {

                   String str = "helloworld" ;

                   System.out.println(str.contains("hello")) ;

                   System.out.println(str.contains("xx")) ;

         }

}

范例：古老的操作，indexOf()

public class StringDemo {

         public static void main(String args[]) {

                   String str = "helloworld" ;

                   if (str.indexOf("hello") != -1) {

                            System.out.println("字符串存在：" + str.indexOf("hello")) ;

                   }

                   System.out.println(str.indexOf("xxx")) ;  // -1

                   System.out.println(str.indexOf("l",5)) ;

                   System.out.println(str.lastIndexOf("l")) ;

         }

}

         在一些古老的教材上，出现的字符串查找都属于indexOf()方法，但是这个方法没有contains()好用。

2.5 、字符串替换操作

         Oracle中的替换函数是replace()，那么String类之中的替换操作有如下几个方法：

No.

方法名称

类型

描述

1

public String replaceAll(String regex, String replacement)

普通

全部替换

2

public String replaceFirst(String regex, String replacement)

普通

替换首个

范例：验证两个替换操作

public class StringDemo {

         public static void main(String args[]) {

                   String str = "Hello World ." ;

                   System.out.println(str.replaceAll("l","_")) ;       // He__o Wor_d .

                   System.out.println(str.replaceFirst("l","_")) ;     // He_lo World .

         }

}

2.6 、字符串截取

         Oracle的截取是substr()函数，这个函数在使用的时候下标从0或1开始都是可以的，不过程序之中只能从0开始，而且不能设置为负数。

No.

方法名称

类型

描述

1

public String substring(int beginIndex)

普通

从指定位置截取到结尾

2

public String substring(int beginIndex, int endIndex)

普通

截取指定范围的内容

范例：字符串截取

public class StringDemo {

         public static void main(String args[]) {

                   String str = "Hello World ." ;

                   System.out.println(str.substring(6)) ;       

                   System.out.println(str.substring(0,5)) ;    

         }

}

2.7 、字符串拆分

         所谓的拆分操作指的就是按照一个指定的字符串标记，对一个完整的字符串进行分割。如果要完成拆分操作，可以使用的方法如下：

No.

方法名称

类型

描述

1

public String[] split(String regex)

普通

按照指定的字符串全拆分

2

public String[] split(String regex, int limit)

普通

拆分为指定的长度

范例：完成全拆分

public class StringDemo {

         public static void main(String args[]) {

                   String str = "Hello World !!!" ;

                   String result [] = str.split(" ") ;

                   for (int x = 0 ; x < result.length ; x ++) {

                            System.out.println(result[x]) ;

                   }

         }

}

范例：拆分为指定的个数

public class StringDemo {

         public static void main(String args[]) {

                   String str = "Hello World !!!" ;

                   String result [] = str.split(" ",2) ;

                   for (int x = 0 ; x < result.length ; x ++) {

                            System.out.println(result[x]) ;

                   }

         }

}

         如果设置了拆分的个数，那么后面的内容将作为整体不再拆分。

范例：现在要求拆分IP地址

public class StringDemo {

         public static void main(String args[]) {

                   String str = "192.168.1.1" ;

                   String result []= str.split("\\.") ;

                   for (int x = 0 ; x < result.length ; x ++) {

                            System.out.println(result[x]) ;

                   }

         }

}

提示：以后在进行字符串拆分的时候，如果遇见拆不开的问题，就使用“\\”

2.8 、其他方法

         以上是一些可以分类的功能性的方法，但是在String类中还有一些无法分类的方法，下面统一列出。

No.

方法名称

类型

描述

1

public boolean isEmpty()

普通

判断是否为空字符串（""）

2

public int length()

普通

取得字符串长度

3

public String trim()

普通

去掉左右空格

4

public String toLowerCase()

普通

将全部字符串转小写

5

public String toUpperCase()

普通

将全部字符串转大写

6

public String intern()

普通

入池

7

public String concat(String str)

普通

字符串连接

范例：取得字符串长度和是否为空

public class StringDemo {

         public static void main(String args[]) {

                   String str = "hello" ;

                   System.out.println(str.isEmpty()) ;  // false

                   System.out.println("".isEmpty()) ;  // true

                   System.out.println(str.length()) ;

                   System.out.println("    Hello     ".length()) ;       // 空格也计算

         }

}

范例：使用trim()去掉空格

public class StringDemo {

         public static void main(String args[]) {

                   String str = "   hello  " ;

                   System.out.println("字符串内容：〖" + str + "〗") ;

                   System.out.println("字符串内容：〖" + str.trim() + "〗") ;

                   // 对象.方法().方法().方法()...代码链，看每个方法的返回值

                   System.out.println("字符串长度：" + str.trim().length()) ;

         }

}

                   String s = str.trim () ;

                   int len = s.length() ;

                   System.out.println("字符串长度：" + len) ;

范例：其他操作

public class StringDemo {

         public static void main(String args[]) {

                   String str = "Hello World !~!!" ;

                   System.out.println(str.toUpperCase());

                   System.out.println(str.toLowerCase());

                   System.out.println("Hello ".concat("World ."));          // +也可以

         }

}

         在Oracle的学习过程之中，发现里面有一个initcap()的方法，可以让首字母大写，可是这个方法其实很重要，但是String类没有提供。下面简单实现一下，给一个基本的原理。

public class StringDemo {

         public static void main(String args[]) {

                   String str = "hello" ;

                   System.out.println(initcap(str)) ;

         }

         public static String initcap(String s) {

                   return s.substring(0,1).toUpperCase().concat(s.substring(1)) ;

         }

}

         提示：虽然JDK没有提供此类方法，可是以后学习的Apache的commones组件包之中，有此方法。