java泛型的用法和方法

String和StringBuffer他们都可以存储和操作字符串，即包含多个字符的字符串数据。

String类是字符串常量，是不可更改的常量。而StringBuffer是字符串变量，它的对象是可以扩充和修改的。

StringBuffer可以对字符串内容进行修改。

StringBuffer是字符串缓冲区

StringBuffer是一个容器。
特点：
1，而且长度是可变化的。
2，可以字节操作多个数据类型
3，最终会通过toString方法编程字符串

1，存储
StringBuffer append()：将制定数据作为参数添加到已有数据结尾处
StringBuffer insert(index,数据)：可以将数据插入到制定index位置


2，删除
StringBuffer delete(start,end):删除缓冲区的数据，包含start，不包含end。
StringBuffer


3，获取
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String subString(int start,int end)


4，修改
StringBuffer repalce(start,end,string)
void setCharAt(int index,char ch)


5,反转
StringBuffer reverse();

6,
将缓冲区中指定的数据存储到指定字符数组中。
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)

-----------------------------------------------------------------------------------------------------------------------------------------------------

下面就是主要StringBuffer类的方法应用：

class  StringBufferDemo
{
public static void main(String[] args)
{
  method_del();
  method_add();
  method_update();

  StringBuffer sb =  new StringBuffer("abcdef");

  char[] chs =  new char[4];

  sb.getChars(1,4,chs,1);

  for(int x=0; x<chs.length; x++)
  {
   sop("chs["+x+"]="+chs[x]+";");
  }
}

public static void method_update()
{
  StringBuffer sb = new StringBuffer("abcde");
 
  //sb.replace(1,4,"Java");//打印结果是：ajavae，将java替换成了bcd
  sb.setCharAt(2,'k');//打印结果是：abkde，将K替换成了角标是2上的字符
 
  sop(sb.toString());

}

public static void method_del()
{
  StringBuffer sb = new StringBuffer("abcde");

  //sb.delete(1,3);//打印结果:ade,从角标1开始到角标3，但不包括角标3
 
  //清空缓冲区
  //sb.delete(0,sb.length());

  sb.deleteCharAt(2);//打印结果是：将角标是2的字符C删除
 
  sop(sb.toString());
}

public static void method_add()
{
  StringBuffer sb = new StringBuffer();
 
  //方法调用链，sb.append("abc")这个方法返回的还是本类对象
  sb.append("abc").append(true).append(34);

  //StringBuffer sb1 = sb.append(34);
  //sop("sb==sb1:"+(sb==sb1));
 
  sb.insert(1,"qq");//打印结果：aqqbctrue34，将qq插入到a字符后面
  sop(sb.toString());//打印结果：abctrue34

  //sop(sb1.toString());
}

public static void sop(String str)
{
  System.out.println(str);
}
}






实例：

    String是不变类，用String修改字符串会新建一个String对象，如果频繁的修改，将会产生很多的String对象，开销很大.因此Java提供了一个StringBuffer类，这个类在修改字符串方面的效率比String高了很多。

 

在java中有3个类来负责字符的操作。

  1.Character 是进行单个字符操作的，

  2.String 对一串字符进行操作。不可变类。

  3.StringBuffer 也是对一串字符进行操作，但是可变类。
[java] view plain copy

    public class UsingStringBuffer {  
        /**
         * 查找匹配字符串
         */  
        public static void testFindStr() {  
            StringBuffer sb = new StringBuffer();  
            sb.append("This is a StringBuffer");  
            // 返回子字符串在字符串中最先出现的位置，如果不存在，返回负数  
            System.out.println("sb.indexOf(\"is\")=" + sb.indexOf("is"));  
            // 给indexOf方法设置参数，指定匹配的起始位置  
            System.out.println("sb.indexOf(\"is\")=" + sb.indexOf("is", 3));  
            // 返回子字符串在字符串中最后出现的位置，如果不存在，返回负数  
            System.out.println("sb.lastIndexOf(\"is\") = " + sb.lastIndexOf("is"));  
            // 给lastIndexOf方法设置参数，指定匹配的结束位置  
            System.out.println("sb.lastIndexOf(\"is\", 1) = "  
                    + sb.lastIndexOf("is", 1));  
        }  
      
        /**
         * 截取字符串
         */  
        public static void testSubStr() {  
            StringBuffer sb = new StringBuffer();  
            sb.append("This is a StringBuffer");  
            // 默认的终止位置为字符串的末尾  
            System.out.print("sb.substring(4)=" + sb.substring(4));  
            // substring方法截取字符串，可以指定截取的起始位置和终止位置  
            System.out.print("sb.substring(4,9)=" + sb.substring(4, 9));  
        }  
      
        /**
         * 获取字符串中某个位置的字符
         */  
        public static void testCharAtStr() {  
            StringBuffer sb = new StringBuffer("This is a StringBuffer");  
            System.out.println(sb.charAt(sb.length() - 1));  
        }  
      
        /**
         * 添加各种类型的数据到字符串的尾部
         */  
        public static void testAppend() {  
            StringBuffer sb = new StringBuffer("This is a StringBuffer!");  
            sb.append(1.23f);  
            System.out.println(sb.toString());  
        }  
      
        /**
         * 删除字符串中的数据
         */  
        public static void testDelete() {  
            StringBuffer sb = new StringBuffer("This is a StringBuffer!");  
            sb.delete(0, 5);  
            sb.deleteCharAt(sb.length() - 1);  
            System.out.println(sb.toString());  
        }  
      
        /**
         * 向字符串中插入各种类型的数据
         */  
        public static void testInsert() {  
            StringBuffer sb = new StringBuffer("This is a StringBuffer!");  
            // 能够在指定位置插入字符、字符数组、字符串以及各种数字和布尔值  
            sb.insert(2, 'W');  
            sb.insert(3, new char[] { 'A', 'B', 'C' });  
            sb.insert(8, "abc");  
            sb.insert(2, 3);  
            sb.insert(3, 2.3f);  
            sb.insert(6, 3.75d);  
            sb.insert(5, 9843L);  
            sb.insert(2, true);  
            System.out.println("testInsert: " + sb.toString());  
        }  
      
        /**
         * 替换字符串中的某些字符
         */  
        public static void testReplace() {  
            StringBuffer sb = new StringBuffer("This is a StringBuffer!");  
            // 将字符串中某段字符替换成另一个字符串  
            sb.replace(10, sb.length(), "Integer");  
            System.out.println("testReplace: " + sb.toString());  
        }  
      
        /**
         * 将字符串倒序
         */  
        public static void reverseStr() {  
            StringBuffer sb = new StringBuffer("This is a StringBuffer!");  
            System.out.println(sb.reverse()); // reverse方法将字符串倒序  
        }  
    }