java之13天 字符串StringBuffer (二)

StringBuffer 和 StringBuilder

/**
 * StringBuffer是字符串缓冲区一个容器
 * 特点:
 * 1.长度是可变的 
 * 2.可以直接操作多种数据类型
 * 3.最终会通过toString方法编程字符串
 * 
 * 
 * 1.存储
 * 		StringBuffer append(): 将数据作为参数添加到已有的数据结尾处.
 *      StringBuffer insert(index,数据);可以将数据插入到指定的index位置.
 * 2.删除
 *     StringBuffer delete(int start,int end): 包含 start 不包含 end
 *     StringBuffer deleteCharAt(int index):删除指定位置字符
 * 3.修改
 *     StringBuffer replace(int start,int end,String str);
 *     void setCharAt(int index,char c);
 * 4.查询
 *    char  charAt(index):获取指定角标上的字符
 *    int indexOf(String str)
 *    int lastIndexOf(String str)
 *    int length()
 *    String subString(int start)
 *    
 * 5.反转
 *   StringBuffer reverse();
 *   
 * 6.复制
 *  void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)  
 *
 *
 *
 *JDK1.5 版本之后出现了StringBuilder.
 *
 *	StringBuffer 是线程同步.
 *	StringBuilder 是线程不同步. 单线程的时候 一般都用这个  以后开发建议使用 StringBuilder
 *
 *JDK 升级 的三个因素
 *  1.提高效率
 *  2.简化书写
 *  3.提高安全性
 *
 */
public class StringBufferDemo {
	public static void sop(String str){
		System.out.println(str);
	}
	public static void method_copy(){
		StringBuffer sb=new StringBuffer("abcdef");
		char[] chs=new char[4];
		sb.getChars(0, 4, chs, 0);
		for (char c : chs) {
			sop("getChars"+c);
		}
		
	}
	
	public static void method_update(){
		StringBuffer sb=new StringBuffer("abcdef");
		sb.replace(1, 4, "JAVA");
		sop(sb.toString());
		sb.setCharAt(2,'K');  //替换指定位置上的字符
		sop(sb.toString());
	}
	
	public static void method_delete(){
		StringBuffer sb=new StringBuffer("abcdef");
		sb.delete(1,3);
		sop(sb.toString());
		
		//清空缓冲区 
		//sb.delete(0, sb.length());
		
		//删除 sb中的 c
		sb.deleteCharAt(2);// 或者 sb.delete(2,3);
		sop(sb.toString());
		
	}
	
	public static void method_create(){
		StringBuffer sb=new StringBuffer();
		StringBuffer sb1=sb.append(34);
		sop("sb==sb1:"+(sb==sb1));
		
		sb.append("sdfsdf").append(true).append(123);
		sop(sb.toString());
	}
	
	public static void main(String[] args) {
		method_create();
		method_delete();
		method_update();
		method_copy();
	}

}

装箱 和 拆箱

/**
 * 基本数据类型的对象包装类
 * byte       	Byte
 * short      	short
 * int			Integer
 * boolean 		Boolean
 * float		Float
 * double		Double
 * char			Character
 * 
 * 基本数据类型对象包装类的最常见作用
 *   1.就是用于基本数据类型和字符串类型之间的转换
 *   
 *   基本数据类型装字符串
 *    基本数据类+"";  这样就变成了一个字符串
 *    基本数据类型.toString(基本数据类型值);
 *    如: Integer.toString(34); //将34 整数类型变成 "34"
 *    
 *   字符串转成基本数据类型. 
 *     基本数据类型包装类.parseXXX(str);
 *     xxx  a=Xxxx.parseXxx(String stt);
 *     
 *     double d=Double.parstDouble("12.13");
 *     
 * 十进制转换其他进制
 * 		toBinaryString();
 *      toHexstrng();
 *      toOctalString();
 * 
 * 其他进制转换成十进制
 *    parseInt(string,radix);
 * 
 */


public class IntegerDemo {

	public static void sop(String str){
		System.out.println(str);
	}
	
	public static void main(String[] args) {
		//整数类型的最大值
		sop("int max:"+Integer.MAX_VALUE); //用于判断 表达式运算后的值 是不是在这个整数范围
		
		
		//将在一个字符串转成整数
		int num=Integer.parseInt("123"); //必须要传入数字格式的字符串
		sop("num="+(num+4));
		
		long x=Long.parseLong("123");
		
		
		boolean b=Boolean.parseBoolean("true");
		sop("boolean="+b);
		
		sop(Integer.toBinaryString(6));
		sop(Integer.toHexString(60));
		
		
		int ss =Integer.parseInt("110",10);
		sop(""+ss);
		ss =Integer.parseInt("110",2);
		ss =Integer.parseInt("3c",16);
		sop(""+ss);
		
		Integer i=new Integer("123");
		int sss=i.intValue(); //这样也可以转成 基本数据
		
		method();
		
		method1();
	}

	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 method1(){
		Integer x=new Integer(4);
		Integer x1=4;  //和上面的相等    4 就是一个对象 代替了 new Integer(4); 这个是自动装箱过程只在JDK 5.0后才行. 
		
		x=x1+2;  //4 表示一个对象, 那 对象 +2 肯定是不成功的. 原因  4:进行了 自动拆箱. x1.intValue(); 然后在进行装箱赋值给 x
		//x1=x1+2;
		
		
		//享元模式
		Integer m=128;
		Integer n=128;
		sop("m==n:"+(m==n));  //false
		Integer m1=127;
		Integer n1=127;
		sop("m1==n1:"+(m1==n1)); //true ,因为 m1 和 n1 指向了同一个Integer对象.
		//因为当数值在byte范围内的时候.-128~127中,对于新特性,如果该数值已经存在,则不会在开辟新的空间.
		sop("m1.compareTo(n1)"+m1.compareTo(n1)); //0 相等
	}
}