String与StringBuffer

  
1、String类
String是比较特殊的数据类型,它不属于基本数据类型,但是可以直接赋值,不使用new关键字进行实例化,但是也可以使用关键字new进行实例化。下面的代码都是合法的:
   String s1 = "this is a string!";
   String s2 = new String("this is another string!");
另外String在使用的使用也不需要使用import语句导入,还可以使用“+”这样的运算符。如果想把字符串连接起来,可以使用“+”完成。例如:
s1+s2
String的一些常用方法我们通过一个例子来完成,下面是例子的代码:
package com.li.common;
 
public class StringTest {
 
       /**
        * @param args
        */
       public static void main(String[] args) {
              StringTest st = new StringTest();
              st.testString();
       }
      
       /*
        * 介绍String的常用方法
        */
       public void testString(){
              String str = "This is a test string!";
              System.out.println("/n用于被测试的字符串为:"+str);
             
              System.out.println("/n方法length()用于获取字符串的长度,被测试字符串的长度为:");
              int length = str.length();
              System.out.println(String.valueOf(length));
             
              System.out.println("/n方法equals(Object o)用于判断该字符串是否与目标字符串的内容相同,与字符串/"test/"进行比较的结果为:");
              boolean b = str.equals("test");
              System.out.println(b?"相等":"不相等");
              System.out.println("如果比较的时候不区分大小写,可以使用equalsIgnoreCase(Object o)方法,下面是/"test/"与/"Test/"比较的结果:");
              b = "test".equalsIgnoreCase("Test");
              System.out.println(b?"相等":"不相等");
             
              System.out.println("/n获取字符串中某个位置的字符,可以使用charAt(int index)方法:");
              char c = str.charAt(5);
              System.out.println("/n测试字符串第5个位置的字符为:"+String.valueOf(c)+".注意索引从0开始");
             
              System.out.println("/n获取子串的方法有两个:subString(int fromindex)和substring(int fromindex,int endindex)");
              System.out.println("第一个方法获取从fromindex开始之后的子串,第二个方法获取从fromindex开始到endindex结束的子串,索引从0开始,包含fromindex,不包含endindex。");
              String strSub = str.substring(3);
              System.out.println("str.substring(3)的结果为:"+strSub);
              strSub = str.substring(3,6);
              System.out.println("str.substring(3,6)的结果为:"+strSub);
             
              System.out.println("/n去除字符串前面或者后面的空格,可以使用trim()方法:");
              System.out.println("字符串/"100 01 /"原来的长度为:"+"100 01 ".length()+"使用trim()方法之后的长度为:"+"100 01 ".trim().length());
             
              printContent("/n/n判断一个字符在字符串中的位置,可以使用indexOf(int ch)和indexOf(int ch,int from)方法" +
                            ",/n如果不存在返回0,第一个方法从字符串开头查找,第二个方法从form为置开始查找,包含该位置");
              int index = str.indexOf('s');
              printMethod("str.indexOf('s')");
              printResult(String.valueOf(index));
              index = str.indexOf('s',6);
              printMethod("/nstr.indexOf('s',6)");
              printResult(String.valueOf(index));
             
              printContent("/n/n判断一个字符在字符串中的位置,可以使用indexOf(String str)和indexOf(String str,int from)方法" +
              ",/n如果不存在返回0,第一个方法从字符串开头查找,第二个方法从form为置开始查找,包含该位置");
              index = str.indexOf("is");
              printMethod("str.indexOf(/"is/")");
              printResult(String.valueOf(index));
             
              index = str.indexOf("is",3);
              printMethod("/nstr.indexOf(/"is/",3)");
              printResult(String.valueOf(index));
             
              index = str.indexOf("is",7);
              printMethod("/nstr.indexOf(/"is/",7)");
              printResult(String.valueOf(index));
             
              printContent("/n与indexOf方法相似,还有lastIndexOf方法,用法基本相同,不同的是开始查找的位置不同,一个从前,一个从后");
             
              printContent("/n判断字符串是否以某个子串为后缀,使用endsWith(String str)");
              b = str.endsWith("test");
              printMethod("str.endsWith(/"test/")");
              printResult(String.valueOf(b));
             
              b = str.endsWith("string!");
              printMethod("/nstr.endsWith(/"string!/")");
              printResult(String.valueOf(b));
             
              printContent("/n/n与endsWith方法功能相似,startWith(String prefix)和" +
                            "/nstartWith(String prefix,int toffset)用于判断是否以某个子串为前缀");
             
              printContent("/n/n替换字符串中的字符,使用replace(char oldChar,char newChar)方法");
              String str2 = str.replace('s','S');
              printMethod("str.replace('s','S')");
              printResult(str2);
             
              printContent("/n/n替换字符串中的第一次出现的某个字串,使用replaceFirst(String oldStr,String newStr)方法");
              str2 = str.replaceFirst("is","IS");
              printMethod("str.replaceFirst(/"is/",/"IS/")");
              printResult(str2);
             
              printContent("/n/n替换字符串中的所有的出现的某个字串,使用replaceAll(String oldStr,String newStr)方法");
              str2 = str.replaceAll("is","IS");
              printMethod("str.replaceAll(/"is/",/"IS/")");
              printResult(str2);
             
              printContent("/n/n可以根据某个特定的格式把字符串分成多个子串,使用split方法," +
                            "/n使用的测试字符串为zhangsan-lisi-wangwu");
              str2 = "zhangsan-lisi-wangwu";
              String strSplit[] = str2.split("-");
              printMethod("str.split(/"-/")");
              for(int i=0;i<strSplit.length;i++)
                     printResult(strSplit[i]+" ");
             
       }
       /*
        * 显示注释的内容
        */
       public void printContent(String str){
              System.out.println(str);
       }
       /*
        * 显示代码
        */
       public void printMethod(String str){
              System.out.print(str);
              for(int i=0;i<30-str.length();i++)
                     System.out.print(" ");
       }
       /*
        * 显示结果
        */
       public void printResult(String str){
              System.out.print(str);
       }
}
需要注意的是String本身是一个常量,一旦一个字符串创建了,它的内容是不能改变的,那么如何解释下面的代码:
   s1+=s2;
这里并不是把字符串s2的内容添加到字符串s1的后面,而是新创建了一个字符串,内容是s1和s2的连接,然后把s1指向了新创建的这个字符串。如果一个字符串的内容经常需要变动,不应该使用String,因为在变化的过程中实际上是不断创建对象的过程。这时候应该使用StringBuffer。
2、StringBuffer
StringBuffer也是字符串,与String不同的是StringBuffer对象创建完之后可以修改内容。有几个构造函数:
public StringBuffer(int);
public StringBuffer(String);
public StringBuffer();
第一种构造函数是创建指定大小的字符串,第二个构造函数是以给定的字符串创建StringBuffer对象,第三个构造函数是默认的构造函数,生成一个空的字符串。
StringBuffer对象创建完之后,大小会随着内容的变化而变化。
StringBuffer的常用方法及其用法如下:
 
   StringBuffer sb = new StringBuffer();
   sb.append("字符串的第一部分");
   /*append方法可以在字符串后面添加各种类型的数据,包括基本数据类型变量和其
    他任意类型的对象*/
 
   for (int i = 0; i < sb.length(); i++)
     System.out.println(sb.charAt(i));
   //length()方法用来获取字符串中字符的个数
   //charAt(int)方法用来获取指定位置的字符
 
   System.out.println(sb.length());
   System.out.println(sb.capacity());
   /*capacity()方法用来获取字符串的容量,当前的输出结果是"8 16",
    通常是不相等的*/
 
   System.out.println(sb.toString());
   //toString方法把StringBuffer的内容转换成String对象
  
   sb.delete(1, 3);
   System.out.println(sb.toString());
   /*
    delete方法用于删除字符串中的部分字符,第一个参数是删除的第一个字符,第二
    个参数是删除结束的地方,需要注意3点:字符串的第一个字符的索引"0",第一个
    参数指定的字符会删除,但是第二个参数指定的字符不会删除,此处的运行结果是
    "字符串的第一部分 字的第一部分"。
    */
  
   sb.deleteCharAt(1);
   System.out.println(sb.toString());
   /*
    deleteCharAt删除指定位置的字符,索引也是从零开始,此处的运行结果是"字第
    一部分",把“的”删掉了
    */
  
   String s3 = sb.substring(2);
   String s4 = sb.substring(2,4);
   System.out.println(s3);
   System.out.println(s4);
   /*
   substring用于获取字符串的字串,第一个方法有一个参数,用于指定开始位置,获取的
   字串是从该位置开始到字符串的结束,第二个方法有两个参数,第一个指定开始位置,第
   二个指定结束位置,与delete方法中的参数用法基本相同,此处输出的结果为:"一部
   分 一部"
3、String与基本数据类型之间的转换
不管采用什么方式,用户输入的数据都是以字符串的形式存在,但是在处理的过程中可能需要把输入信息作为数字或者字符来使用,另外不管信息以什么方式存储,最终都必须以字符串的形式展示给用户,所以需要各种数据类型与字符串类型之间的转换。
首先,基本数据类型与String类型对象之间的转换:
从字符串转换成其它类型:
   //字符串与其基本数据类型之间的转换,以int为代表
   //下面的代码把字符串转换成数字
   String input = "111";
   int i = Integer.parseInt(input); //比较常用
   int i2 = new Integer(input).intValue();
   int i3 = Integer.valueOf(input);
   int i4 = new Integer(input);
  
   //下面的代码把数字转换成字符串
   String out = new Integer(i).toString();
   String out2 = String.valueOf(i);
其它对象向字符串转换可以使用每个对象的toString()方法,所有对象都有toString()方法,如果该方法不满足要求,可以重新实现该方法。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值