java程序员从笨鸟到菜鸟之(十五)StringBuffer类练习题

实例1：

package org.westos.stringbuffer_02;
/**
 * 简答题：
 * 		String,StringBuffer,StringBuilder的区别?
 * 		从可变性：
 * 		String：一个不可变的字符序列,
 *              StringBuffer和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
 * 		从线程角度考虑：
 * 		StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!
 * 
 * String和StringBuffer作为形式参数
 * 
 * String类型作为形式参数和基本数据类型作为形式参数的效果一样!
 * 		
 * @author 
 */
public class StringBufferDemo7 {
	
	public static void main(String[] args) {
		
		//定义两个字符串
		String s1 = "hello" ;
		String s2 = "world" ;
		System.out.println(s1+"---"+s2);
		change(s1,s2);//自己定义方法
		System.out.println(s1+"---"+s2);
		System.out.println("---------------------");
		 //定义两个字符串缓冲区对象
		StringBuffer sb1 = new StringBuffer("hello") ;
		StringBuffer sb2 = new StringBuffer("world") ;
		System.out.println(sb1+"---"+sb2);//
	        change(sb1,sb2);//调用方法
		System.out.println(sb1+"---"+sb2);//hello---worldworld
		//缓冲区是不变()
	}
	
	public static void change(StringBuffer sb1 ,StringBuffer sb2){
		sb1 = sb2 ;  //缓冲区不变"world"
		/**
		 * 形参其实是与实参指向同一个对象的不同引用(堆和方法(形参))区);
		 * 在方法区也有一个sb1和sb2，将对象(引用)分别辅给sb1,sb2；
		 * 此时将sb2指向sb1，此时理解为(方法区)这两个引用指向同一个对象("world");
		 * 此时再sb2.append(sb1);就是在sb2的缓冲区内继续添加内容，sb1不变
		 * 自己可以画个内存形式图：
		 * */
		sb2.append(sb1) ;//worldworld
	}
	
	public static void change(String s1,String s2){
		s1 = s2 ;//对String类型只要是非final修饰的变量在进行操作都会在堆内存创建新的对象
		s2 = s1 + s2 ;
	}
}

实例2：类型转换

package org.westos.stringbuffer_02;
/**
 * 
 * 类与类之间的转换
 * 	A类型--->B类型
 * 		这里面可能最终使用B类型里面的功能
 * 	B类型--->A类型
 * 		有时候需要的不是B类型,所以又要将B类型-->A类型
 * 
 * StringBuffer--->String之间的相互转换
 * 
 * 简答题：
 * 		StringBuffer和数组的区别?
 * 		两个共同特点：都属于容器类型的变量
 * 		数组：只能存储同一种数据类型的元素,数组的长度是固定的	
 * 		      eg：int[] arr = {10,20,40,50,"hello"}-----错误的	
 * 		StringBuffer：字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串
 * 
 * @author vivio
 */
public class StringBufferTest {
	
	public static void main(String[] args) {
		//String--->StringBuffer
		/*方式1:
		 * 使用StringBuffer的构造方式:StringBuffer(String str)
		 * 功能：创建一个字符串缓冲区并指向这个字符串
		 * 参数：String str;
		 * 返回值类型：StringBuffer;
		 * */
		//定义一个字符串
		String s = "hello" ;
		StringBuffer sb = new StringBuffer(s) ;
		System.out.println("sb:"+sb);
		
		/*方式2:
		 * 1)创建字符串缓冲区对象;
		 * 2)使用无参构造StringBuffer();
		 * 3)利用append();
		 * */
		StringBuffer sb2 = new StringBuffer() ;
		sb2.append(s) ;
		System.out.println("sb2:"+sb2);
		System.out.println("--------------------");
		
		//StringBuffer--->String
		/*方式1:
		 *直接：String的另一种构造方法:String(StringBuffer buffer)
		 *1)有一个字符串缓冲区对象
		 *2)
		 * */
		StringBuffer buffer = new StringBuffer("world") ;
		String s2 = new String(buffer) ;
		System.out.println("s2:"+s2);
		
		/*方式2:
		 * public String toString()
		 * 说明:现在的数据类型是StirngBuffer类型,
		 * 利用此方法可以将StringBuffer类型转换String
		 * 
		 * */
		String s3 = buffer.toString() ;
		System.out.println("s3:"+s3);
	}
}

实例3：

package org.westos.stringbuffer_02;
/**
 * 将数组拼接成一个字符串,分别使用String和StringBuffer实现(定义功能方法)
 * 
 * 		int[] arr = {11,55,33 ,44 ,22} ;
 * 		形成这样一个字符串:[11, 55, 33, 44, 22] 
 *         分析：
 * 		1)存在一个数组,静态初始化
 * 		2)分别使用String和StringBuffer类型去完成
 * 	
 * @author App
 */
public class StringBufferTest2 {
	
	public static void main(String[] args) {
		//定义一个数组,静态初始化!
		int[] arr = {11,55,33,44,22} ;
		
		//方式1)使用String类型实现
		String result = arrayToString(arr) ;
		System.out.println("result:"+result);
		
		System.out.println("------------------------");
		//方式2:使用StringBuffer的append功能
		String result2 = arrayToString2(arr) ;
		System.out.println("result2: " + result2);
	}
	
	public static String arrayToString2(int[] arr){
		//1)创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		//sb对象追加左中括号
		sb.append("[") ;
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否是最大索引
			if(x==arr.length-1){
				//append追加
				sb.append(arr[x]);
			}else{
				sb.append(arr[x]).append(", ") ;
			}
		}
		
		sb.append("]") ;
		
		return sb.toString() ; //将StringBuffer--->String
	}
	
	/**
	 * 明确返回值类型:String
	 * 明确参数类型:int[] arr
	 */
	public static String arrayToString(int[] arr){
		
		//定义一个空字符串
		String result = "" ;
		
		//拼接左中括号
		result +="[" ;
		
		//遍历int数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否最大索引
			if(x==arr.length-1){
				//拼接元素以及"]"
				result += arr[x] ;
				result += "]" ;
			}else{
				result += arr[x] ;
				result += ", " ;
			}
		}
		return result ;
	}
}

实例4：使用String和StringBuffer实现字符串的反转

package org.westos.stringbuffer_02;

import java.util.Scanner;

/**
 * 分别使用String和StringBuffer实现字符串的反转
 * @author App
 */
public class StringBufferTest3 {
	
	public static void main(String[] args) {
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收
		System.out.println("请您输入一个字符串:");
		String str = sc.nextLine() ;
		
		//方式1:使用String类型进行拼接
		String result = myReverse(str) ;
		System.out.println("result:"+result);
		//方式2:使用StringBuffer的reverse()功能
		
		String result2 = myReverse2(str) ;
		System.out.println("result2:"+result2);
	}
	
	//StringBuffer的rever()方法实现
	public static String myReverse2(String s){
		//创建字符串缓冲区对象h
		/*StringBuffer sb = new StringBuffer(s) ;
		//开始调用反转功能
		sb.reverse() ;
		//返回
		return sb.toString() ;*/
		
		//一步完成:
		return new StringBuffer(s).reverse().toString() ;
	}
	
	
	//String类型的方式进行反转
	public static String myReverse(String s){
		//定义空串
		String result = "" ;
		
		//可以字符组其转成字符数组
		char[] chs = s.toCharArray() ;
		
		//倒着遍历
		for(int x = chs.length-1 ; x >=0 ; x --){
			//空串进行拼接
			result += chs[x] ;
		}
		
		return result ;
	}
}

实例5：判断一个字符串是否是对称字符串

package org.westos.stringbuffer_02;

import java.util.Scanner;

/**
 * 1判断一个字符串是否是对称字符串
  
   例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
	使用(String和StringBuffer实现这个功能)
	
	分析：
		用第一个字符和倒数第一个字符相比较
		用二个字符和倒数第二个字符进行比较
			...
 * @author App
 */
public class StringBufferTest4 {
	
	public static void main(String[] args) {
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
		//方式1:String类型的转换功能
		boolean flag = isSame(line) ;
		System.out.println("flag:"+flag);
		
		//方式2:间接的使用StringBuffer的reverse()功能
		boolean flag2 = isSame2(line) ;
		System.out.println("flag2:"+flag2);
	}
	
	public static boolean isSame2(String s){
		//直接一步
		//new StringBuffer(s).reverse().toString()--->StirngBuffer--->String
		return new StringBuffer(s).reverse().toString().equals(s) ;
	}
	
	/**
	 * 两个明确:
	 * 		返回值类型:boolean
	 * 		参数类型:String s
	 */
	/*public static boolean isSame(String s){
		
		//将字符串转换成字符数组
		char[] chs = s.toCharArray() ;//重点
		
		for(int start = 0,end = chs.length -1 ; start<=end;start++,end--){
			//判断
			if(chs[start] != chs[end]){
				return false ;
			}
			
		}
		return true ;
	}*/
	
	public static boolean isSame(String s){
		//定义一个标记:假设返回值是true
		boolean flag = true ;
		
		//需要字符串转换成字符数组
		char[] chs = s.toCharArray();
		//遍历字符数组,获取前面索引对应的字符和后面索引的字符
		for(int start = 0 ,end = chs.length -1 ; start<=end ; start++,end--){
			//判断
			if(chs[start]!= chs[end]){
				//修改标记
				flag = false ;
				break ;
			}
		}
		return flag ;
	}
}

实例6：

package org.westos.stringbuffer_02;
import java.util.ArrayList;
//面试题：(补充到代码块)
class B{
	
/*	private static ArrayList<String> array ;
	
	public B(){
		array = new ArrayList<String>() ;
	}*/
	
	//成员变量的位置
	public static B t1 = new B() ;
	public static B t2 = new B() ;
	
	{
		System.out.println("构造代码块");
	}
	//静态代码块的位置
	static{
		System.out.println("静态代码块!");
	}
}
public class Demo {
	public static void main(String[] args) {	
		B b = new B() ;		
	}
}
/*分析：
 * 静态代码块 ,构造代码块,构造方法的优先级问题:
 * 静态代码块>构造代码块>构造方法...
 * 说明：静态代码块与静态对象是处于同一优先级的
 * 测试：把二者位置互换，看看结果
 * 对部分流程：
 *   执行new B()，先去加载B类，会按顺序先加载静态对象(默认静态代码块已经加载(实际未加载))，创建对象，调用构造方法之前，执行构造代码块
 *   接着加载第二个静态对象同上；
 *   再加载静态代码块；
 *   再执行构造代码块，执行构造方法
 *   对象创建完毕
 */