java语言(8): String String String 类慢慢来

一、快速使用java.lang.String类

1、得到字符串对象的有关信息

(1)通过调用length()方法得到String的长度.例:

String str="This is a String";
int len =str.length();

(2)StringBuffer类的capacity()方法与String类的 length()的方法类似,但是它测试是分配给StringBuffer的内存空间的大小,而不是当前被使用了的内存空间。

(3)如果想确定字符串中指定字符或子字符串在给定字符串的位置,可以用 indexOf()和lastIndexOf()方法。例:

String str="This is a String";
int index1 = str.indexOf("i");   //index1=2
int index2 = str.indexOf('i',index+1);   //index2=5
int index3 = str.lastIndexOf("i");   //index3=13
int index4 = str.indexOf("String");  //index4=10

2.String 对象的比较和操作 


(1)String 对象的比较 
String类的equals()方法用来确定两个字符串是否相等。例:

String str="This is a String";
boolean result=str.equals("This is another String ");//result=false

(2)String对象的访问 
A、方法charAt()用以得到指定位置的字符。

String str="This is a String";
char chr=str.charAt(3); //chr="s"

——————————————————————————————————————————

java中charAt()方法的使用

charAt(int index)方法是一个能够用来检索特定索引下的字符的String实例的方法.

charAt()方法返回指定索引位置的char值。索引范围为0~length()-1.

如: str.charAt(0)检索str中的第一个字符,str.charAt(str.length()-1)检索最后一个字符.

——————————————————————————————————————————————

 

B、方法getChars()用以得到字符串的一部分字符串.

public void getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin)

要复制的第一个字符在索引 srcBegin 处;要复制的最后一个字符在索引 srcEnd-1 处(因此要复制的字符总数是 srcEnd-srcBegin)。要复制到 dst 子数组的字符从索引 dstBegin 处开始,并结束于索引.例:

tring str="abcdefghijklmn";
char[] chr =new char[10];
str.getChars(5,12,chr,0);  //chr= fghijkl

————————————————————————————————————————————

Java getChars() 方法

getChars() 方法将字符从字符串复制到目标字符数组。

———————————————————————————————————————————————

C、subString()是提取字符串的另一种方法,它可以指定从何处开始提取字符串以及何处结束。 有两种传参方式 ,
一种是:

返回一个新的字符串,它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始,直到此字符串末尾。

public String substring(int beginIndex)


String str="abcdefghijklmn";
String str1=str.substring(3);//str1=“defghijklmn”

另一种是:

返回一个新字符串,它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始,
直到索引 endIndex - 1 处的字符。因此,该子字符串的长度为 endIndex-beginIndex。

public String substring(int beginIndex, int endIndex)


String str="abcdefghijklmn";
String str2=str.substring(3,5);//str2=“de”

(3)操作字符串 
A、replace()方法可以将字符串中的一个字符替换为另一个字符。 
Replace(char oldChar, char newChar) 
返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 而生成的。 

例1
String str=”This is a String”;
String str1=str.replace(‘T‘,‘t‘); //str1=”this is a String”;



例2
String s = “This is my original string ,it is very good!”;
String r = “at”;
s = s.replace(“is”,r);//s= That at my original string ,it at very good!

B、concat()方法可以把两个字符串合并为一个字符串。

String str=”This is a String”;
String str1=str.concat(“Test”); //str1=”This is a String Test”

C、toUpperCase()和toLowerCase()方法分别实现字符串大小写的转换。

String str=”THIS IS A STRING”;
String str1=str.toLowerCase(); //str1=”this is a string”;

D、trim()方法可以将字符串中开头和结尾处的空格去掉.

String str=”This is a String   “;
String str1=str.trim();   // str1=”This is a String”

E、String 类提供静态方法valueOf(),它可以将任何类型的数据对象转换为一个字符串。如

System.out.println(String,ValueOf(math,PI));

 

3.修改可变字符串 


StringBuffer类为可变字符串的修改提供了3种方法,在字符串中间插入和改变某个位置所在的字符。 
(1)在字符串后面追加:用append()方法将各种对象加入到字符串中。 
(2)在字符串中间插入:用insert()方法。

例:
StringBuffer str=new StringBuffer(“This is a String”);
str.insert(9,”test”);
System.out.println(str.toString());

代码输出:
This is a test String

(3)改变某个位置所在的字符,用setCharAt()方法。

 

二、深入String类

String类是一个字符串类型的类,使用“XXXX”定义的内容都是字符串,虽然这个类在使用上有一些特殊,但是String本身是一个类。

一、String的实例化两种方式

1、直接赋值实例化:

String StringName= "xxx";

以上是String对象的直接赋值,以上的代码并没有使用关键字new进行。String类也是类,所以也有构造方法。

2、使用构造方法实例化:

public String(String str);

可以通过构造方法为String类对象实例化,但在构造里面依然要接收一个本类对象。

二、字符串的比较

如果要想知道两个int型变量是否相等,使用“==”进行验证,在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) ;
                   System.out.println(str1 == str3) ;
                   System.out.println(str2 == str3) ;
         }
}


输出:
false
false
true

发现使用“==”好象最终的判断结果是不一样的,为什么呢?下面通过内存关系图来分析:

1

通过以上分析可以发现,“==”比较的不是字符串对象包含的内容,而是两个对象所在的的内存对象的数值。所以“==”属于数值比较,比较的是内存地址。

如果想比较字符串的内容,可以使用String类的equals()方法。

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)) ;      
                   System.out.println(str1.equals(str3)) ;
                   System.out.println(str2.equals(str3)) ;      
         }
}

输出:
true
true
true

于是,现在比较的不是字符串的内存地址的数值,而是字符串的内容。

小结: 
(1) ==:比较的是两个字符串内存地址的数值是否相等,属于数值比较; 
(2)equals():比较的是两个字符串的内容,属于内容比较。

三、字符串常量是匿名对象

在各个语言中并没有提供字符串的数据类型定义,很多语言都是使用字符数组来描述字符串的概念,在Java中也没有字符串的概念,只是Java自己做了简单处理。但是在Java中字符串依然不属于基本数据类型,字符串是作为String类的匿名对象的形式存在的

字符串是匿名对象的验证:

public class StringDemo {
         public static void main(String args[]) {
                   String str = "Hello" ;
                   // 通过字符串调用方法
                   System.out.println("Hello".equals(str)) ;
         }
}

输出: true

匿名对象可以调用类中的方法与属性,而以上的字符串调用了equals()方法,所以它一定是一个对象。

四、String类对象两种实例化方式的区别

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

1、直接赋值的实例化方式:

String str = "Hello" ;

此时,只分配了一块堆内存空间和一块栈内存空间:

 11

 

再看一下代码:

public class StringDemo {
         public static void main(String args[]) {
                   String str1 = "Hello" ;
                   String str2 = "Hello" ;
                   String str3 = "Hello" ;
                   System.out.println(str1 == str2) ;
                   System.out.println(str1 == str3) ;
                   System.out.println(str2 == str3) ;
         }
}

输出:
true
true
true

我们发现以上所有直接赋值的String类对象的内存地址完全相同,内存分配图如下:

12

 

在设计String类的时候采用了一种称为共享设计模式的概念。在运行的JVM底层存在一个字符串的对象池(Object Pool),如果用户采用了直接赋值的方式时,会将字符串的内容放入池保存,如果以后其他String对象继续使用直接赋值方式实例化,并且设置了同样的内容时,那么将不会分配新的堆内存空间,而是使用已有对象的引用进行分配继续使用。如果新声明的字符串内容不在对象池中,则会分配一个新的,然后继续放到池中以供下次使用。

 

2、采用构造方法实例化的方式:

使用构造方法实例化一定要用到new关键字,而一旦使用了new就表示要分配新的内存空间。

String str = new String("Hello") ;

内存分配图如下:

21

从上可以发现,分配了两块堆内存空间,其中一块是垃圾。这样处理内存的浪费外,使用构造方法定义的String类对象,其内容不会保存在对象中(因为重新分配了新的一块堆内存)。

现在希望使用构造方法定义的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) ;
                   System.out.println(str1 == str3) ;
                   System.out.println(str2 == str3) ;
         }
}

输出:
true
true
true

小结:String类对象两种实例化的区别? 
(1)直接赋值实例化方式(String str = “xxx”):只会分配一块堆内存空间,并且对象内容自动入池,以供重复使用; 
(2)构造方法实例化方式(String str = new String(“xxx”)):会分配两块堆内存空间,其中有一块是垃圾,并且不会自动入池,用户可以使用intern()方法手动入池。

 

五、字符串的内容一旦定义则不可改变

先看一段代码:

public class StringDemo {
         public static void main(String args[]) {
                   String str = "Hello " ;
                   str += "World " ;
                   str = str + "!!!" ;
                   System.out.println(str) ;
         }
}

输出:
Hello World !!!

我们通过内存分配图分析一下:

31

通过以上的分析可以发现:字符串内容的更改,实际上改变的是字符串对象的引用过程,并且会伴随有大量的垃圾出现,在实际开发中应该避免。

 

六、字符串的常用方法 — 字符与字符串

很多编程语言利用了字符数组的概念来描述字符串的概念,在String类的方法上也有所体现。

1

一个例子:字符串和字符数组转换,完成一个小写字符串变为大写字符串的操作

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

输出:
h、e、l、l、o、w、o、r、l、d、
全部字符数组变为字符串:HELLOWORLD
部分字符数组变为字符串:HELLO

七、字符串的常用方法 — 字节与字符串

字节使用byte描述,字节一般用在数据的传输和进行编码转换的时候使用。String中也提供相应的方法,来进行数据传输和编码转换。

22

一个例子:完成一个小写字母变为大写字母的操作

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

输出:
104、101、108、108、111、119、111、114、108、100、
全部字节数组变为字符串:HELLOWORLD
部分字节数组变为字符串:HELLO

八、字符串的常用方法 — 字符串比较

3

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

输出:
false
true

九、字符串的常用方法 — 字符串查找

4

一个例子:判断开头和结尾操作

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("##")) ;
         }
}

输出:
true
true
true

另外一个例子:使用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")) ;
         }
}

输出:
true
false

十、字符串的常用方法 — 字符串替换

5

一个例子:

public class StringDemo {
         public static void main(String args[]) {
                   String str = "Hello World ." ;
                   System.out.println(str.replaceAll("l","_")) ;
                   System.out.println(str.replaceFirst("l","_")) ;
         }
}

输出:
He__o Wor_d .
He_lo World .

十一、字符串的常用方法 — 字符串截取

6

例子:

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

输出:
World .
Hello

十二、字符串的常用方法 — 字符串拆分

7

例子:

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

输出:
Hello
World
!!!

十三、字符串的常用方法 — 其他方法

8

例子1:取得字符串长度和是否为空

public class StringDemo {
         public static void main(String args[]) {
                   String str = "hello" ;
                   System.out.println(str.isEmpty()) ;
                   System.out.println("".isEmpty()) ;
                   System.out.println(str.length()) ;
                   System.out.println("    Hello     ".length()) ;       // 空格也计算
         }
}

输出:
false
true
5
14

例子2:

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 ."));          // +也可以
         }
}

输出:
HELLO WORLD !~!!
hello world !~!!
Hello World .

 

参考:

简析java.lang.String类

Java String类详解(一)

Java String类详解(二)

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值