StringBuffer及类型转换

 

 StringBuffer

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

1，存储。

    StringBuffer append(boolean | char | char[] | CharSequence |  double | float  | int | String | StringBuffer):将指定数据作为参数添加到已有数据结尾处。
    StringBuffer insert(index,数据):可以将数据插入到指定index位置。

2，删除。

    StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。
    StringBuffer deleteCharAt(index):删除指定位置的字符。

3，获取。

    char charAt(int index) 
    int indexOf(String str) 
    int lastIndexOf(String str) 
    int length() 
    String substring(int start, int end) 
 

4，修改。

    StringBuffer replace(start,end,string);   // 替换指定位置的字符串
    void setCharAt(int index, char ch) ;    // 修改指定索引的字符串

5，反转。

    StringBuffer reverse();
 

6，将缓冲区中指定数据存储到指定字符数组中。

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

JDK1.5 版本之后出现了StringBuilder.

StringBuffer是线程同步，效率低，建议多线程使用。
StringBuilder是线程不同步，效率低。

以后开发，建议使用StringBuilder

升级三个因素：
1，提高效率。
2，简化书写。
3，提高安全性。

class Demo{}

public class StringBufferDemo {

	public static void main(String[] args) {
		method_add();
//		method_delete();
//		method_get();
//		method_update();
	}
	
	
	public static void method_add() {
		StringBuffer sb  = new StringBuffer();  // 创建一个容器，容器不可变
		
		StringBuffer sb1 = sb.append(34).append("abc");
		System.out.println("sb==sb1-->"+(sb1==sb));  // sb==sb1-->true  同一个容器
		
		sb.insert(1, "pp");
		System.out.println(sb.toString());   // 3pp4abc
		System.out.println(sb1.toString());   // 3pp4abc
		sb.append(new Demo());
		System.out.println(sb.toString());   // [email protected]  添加一个Object

	}
	
	public static void method_delete() {
		StringBuffer sb = new StringBuffer("abcde");
		sb.delete(0, 2);  // 删除0-2 包含头不包含尾
		System.out.println(sb.toString());  // cde
		sb.deleteCharAt(0);
		System.out.println(sb.toString());  // de  删除指定索引的元素。
	}
	
	public static void method_get() {
		StringBuffer sb = new StringBuffer("abcdefs");
		System.out.println(sb.charAt(2));  // c 获取索引所对应的字符
		System.out.println(sb.indexOf("cd"));   // 2 获取指定字符串的索引
		System.out.println(sb.substring(1));   // bcdefs 获取子串 
		
		// 将缓冲区中指定数据存储到指定字符数组中。
		char[] c = new char[sb.length()];
		sb.getChars(1, 3, c, 1);
		for (int i = 0; i < c.length; i++) {
			System.out.println("c["+i+"]="+c[i]);
		}
		/*
		 c[0]=
		 c[1]=b
		c[2]=c
		c[3]=	 
		 */
	}
	
	public static void method_update() {
		StringBuffer sb = new StringBuffer("abc123defg");
		sb.replace(3, 6, "999");  // abc999defg  t替换指定位置字符串
		System.out.println(sb);
		sb.setCharAt(1, 'c');   // acc999defg  修改指定索引的字符		
		System.out.println(sb);

	}
}

基本数据类型对象包装类。

byte            Byte
short            short
int                Integer
long            Long
boolean     Boolean
float            Float
double        Double
char            Character

基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换。

基本数据类型转成字符串。

    基本数据类型+""

    基本数据类型.toString(基本数据类型值);

    如： Integer.toString(34);//将34整数变成"34";

字符串转成基本数据类型。

    xxx a = Xxx.parseXxx(String);

    int a = Integer.parseInt("123"); 

    double b = Double.parseDouble("12.23");

    boolean b = Boolean.parseBoolean("true");

    Integer i = new Integer("123");
    int num = i.intValue();   // 实例方法

十进制转成其他进制。

    toBinaryString();
    toHexString();
    toOctalString();

其他进制转成十进制。

  parseInt(string,radix);   // radix 进制

public class InterDemo {

	public static void main(String[] args) {
		//整数类型的最大值。
		System.out.println("int max :"+Integer.MAX_VALUE);

		//将一个字符串转成整数。
		int num = Integer.parseInt("123");//必须传入数字格式的字符串。
		//long x = Long.parseLong("123");

		System.out.println("num="+(num+4));

		System.out.println(Integer.toBinaryString(-6));
		System.out.println(Integer.toHexString(60));  // 3c

		int x = Integer.parseInt("3c",16);  // 16进制转int

		System.out.println("x="+x);

	}

}

JDK1.5版本以后出现的新特性。 

/*
JDK1.5版本以后出现的新特性。
*/

class IntegerDemo2
{
	public static void main(String[] args) 
	{
		
//		Integer x = new Integer(4);

		Integer x = 4;//自动装箱。//new Integer(4)

		x = x/* x.intValue() */ + 2;//x+2:x 进行自动拆箱。变成成了int类型。和2进行加法运算。
					//再将和进行装箱赋给x。

		

		Integer m = 128;
		Integer n = 128;

		sop("m==n:"+(m==n));

		Integer a = 127;
		Integer b = 127;

		sop("a==b:"+(a==b));//结果为true。因为a和b指向了同一个Integer对象。
						//因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。
	}

	public static void method()
	{
		Integer x = new Integer("123");

		Integer y = new Integer(123);

		sop("x==y:"+(x==y));
		sop("x.equals(y):"+x.equals(y));
	}

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