Java筆記第十一課（String類&StringBuffer類）

Java常用類

 

 String類中的其他功能:

   替換功能:

   public String replace(char oldChar,char newChar):將字符串中某一個字符用新的字符替換

  public String replace(String oldStr,String newStr):將字符串中某一個子字符串用新 的字符串去替代
   去除字符串兩端空格:

  public String trim()

  兩個字符串進行比較:

  public int compareTo(String anotherString)  是Comparable接口中的方法(該接口可以實現一個自然排序）

public class StringDemo {
	
	public static void main(String[] args) {
		
		//定義字符串
		String s1 = "helloworld" ;
		
		//替換功能
		//public String replace(char oldChar,char newChar):將字符串中某一個字符用新的字符替換
		//String s2 = s1.replace('l', 'k') ;
		//System.out.println("s:"+s2);
		//public String replace(String oldStr,String newStr):將字符串中某一個子字符串用新 的字符串去替代
		String s3 = s1.replaceAll("owo", "ak47") ;
		System.out.println("s3:"+s3);
		
		System.out.println("------------------");
		
		String s4 = " hello world " ;
		System.out.println("s4:"+"----"+s4+"----");
		//public String trim()
		String s5 = s4.trim() ;
		System.out.println("s5:"+"----"+s5+"----");
		
		//public int compareTo(String anotherString)
		String s6 = "hello" ;
		String s7 = "hello" ;
		String s8 = "abc" ;
		System.out.println("compareTo():"+s6.compareTo(s7));
		System.out.println("compareTo():"+s6.compareTo(s8));
	}
}
//定義字符串
		String s1 = "helloworld" ;
		
		//替換功能
		//public String replace(char oldChar,char newChar):將字符串中某一個字符用新的字符替換
		//String s2 = s1.replace('l', 'k') ;
		//System.out.println("s:"+s2);
		//public String replace(String oldStr,String newStr):將字符串中某一個子字符串用新 的字符串去替代
		String s3 = s1.replaceAll("owo", "ak47") ;
		System.out.println("s3:"+s3);
		
		System.out.println("------------------");
		
		String s4 = " hello world " ;
		System.out.println("s4:"+"----"+s4+"----");
		//public String trim()
		String s5 = s4.trim() ;
		System.out.println("s5:"+"----"+s5+"----");
		
		//public int compareTo(String anotherString)
		String s6 = "hello" ;
		String s7 = "hello" ;
		String s8 = "abc" ;
		System.out.println("compareTo():"+s6.compareTo(s7));
		System.out.println("compareTo():"+s6.compareTo(s8));
	}
}

例;String一些方法的使用

public class StringTest {

		public static void main(String[] args) {
			//創建鍵盤錄入對象
			Scanner sc = new Scanner(System.in) ;
			
			//錄入並接收數據
			System.out.println("請您輸入一個字符串:");
			String line = sc.nextLine() ;
			
			//將接收到的字符串截取
			String s1 = line.substring(0, 1) ;
			
			//將得到s1字符串轉換成小寫
			String s2 = s1.toLowerCase() ;
			
			//在將line字符串的其餘字母字符截取出來
			String s3 = line.substring(1) ;
			//轉換成大寫
			String s4 = s3.toUpperCase() ;
			
			//s2和s4作品接
			String result = s2.concat(s4) ;
			System.out.println("result:"+result);
			System.out.println("------------------------------");
			
			//鏈式編程
			String result2 = line.substring(0, 1).toLowerCase().concat(line.substring(1).toUpperCase()) ;
			System.out.println("result2:"+result);
		}
}
//創建鍵盤錄入對象
			Scanner sc = new Scanner(System.in) ;
			
			//錄入並接收數據
			System.out.println("請您輸入一個字符串:");
			String line = sc.nextLine() ;
			
			//將接收到的字符串截取
			String s1 = line.substring(0, 1) ;
			
			//將得到s1字符串轉換成小寫
			String s2 = s1.toLowerCase() ;
			
			//在將line字符串的其餘字母字符截取出來
			String s3 = line.substring(1) ;
			//轉換成大寫
			String s4 = s3.toUpperCase() ;
			
			//s2和s4作品接
			String result = s2.concat(s4) ;
			System.out.println("result:"+result);
			System.out.println("------------------------------");
			
			//鏈式編程
			String result2 = line.substring(0, 1).toLowerCase().concat(line.substring(1).toUpperCase()) ;
			System.out.println("result2:"+result);
		}
}

 

 

char[] toCharArray():將字符串轉換成 字符數組 (開發中經常使用)

字符串拼接：

例：

import java.util.Scanner;

/**
 * 需求:鍵盤錄入一個字符串,將字符串進行反轉
 * 
 * 舉例:
 * 		"abc"--->"cba"
 * 
 * 分析:
 * 		1)創建鍵盤錄入對象,錄入並接收一個字符串
 * 		2)定義空字符串
 * 		3)可以將字符串轉換成字符數組:toCharArray();
 * 		4)遍歷字符數組,倒着遍歷
 * 		5)遍歷之後獲取到字符串中的每一個字符,然後使用空串進行拼接
 * 		6)輸出即可!
 * @author Apple
 */
public class StringTest3 {
	
	public static void main(String[] args) {
		//創建鍵盤錄入對象
		Scanner sc = new Scanner(System.in) ;
		
		//錄入數據並接收數據
		System.out.println("請您輸入一個字符串:");
		String line = sc.nextLine() ;
		
	/*	//定義一個空字符串
		String result = "" ;
		
		//將字符串轉換成字符數組
		char[] chs = line.toCharArray() ;
		
		//遍歷字符數組,倒着遍歷
		for(int x = chs.length-1; x >=0 ; x --){
			//獲取到每一個字符
			result+= chs[x] ;
		}*/
		
		String result = myReverse(line) ;
		
		//輸出
		System.out.println("result:"+result);
	}
	
	//寫一個功能實現
	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 ;
	}
}
/**
 * 需求:鍵盤錄入一個字符串,將字符串進行反轉
 * 
 * 舉例:
 * 		"abc"--->"cba"
 * 
 * 分析:
 * 		1)創建鍵盤錄入對象,錄入並接收一個字符串
 * 		2)定義空字符串
 * 		3)可以將字符串轉換成字符數組:toCharArray();
 * 		4)遍歷字符數組,倒着遍歷
 * 		5)遍歷之後獲取到字符串中的每一個字符,然後使用空串進行拼接
 * 		6)輸出即可!
 * @author Apple
 */
public class StringTest3 {
	
	public static void main(String[] args) {
		//創建鍵盤錄入對象
		Scanner sc = new Scanner(System.in) ;
		
		//錄入數據並接收數據
		System.out.println("請您輸入一個字符串:");
		String line = sc.nextLine() ;
		
	/*	//定義一個空字符串
		String result = "" ;
		
		//將字符串轉換成字符數組
		char[] chs = line.toCharArray() ;
		
		//遍歷字符數組,倒着遍歷
		for(int x = chs.length-1; x >=0 ; x --){
			//獲取到每一個字符
			result+= chs[x] ;
		}*/
		
		String result = myReverse(line) ;
		
		//輸出
		System.out.println("result:"+result);
	}
	
	//寫一個功能實現
	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 ;
	}
}

 

 

 

 

 

StringBuffer：

 

 1.StringBuffer的構造方法:
   public StringBuffer ()構造一個其中不帶字符的字符串緩衝區，其初始容量爲 16 個字符
   public StringBuffer(int capacity)構造一個不帶字符，但具有指定初始容量的字符串緩衝區
   public StringBuffer(String str)構造一個字符串緩衝區，並將其內容初始化爲指定的字符串內容。該字符串的初始                                                      容量爲 16 加上字符串參數的長度。
  
 2.常用的功能:
   public int length():獲取字符串長度數
   public int capacity():獲取當前字符串緩衝區的容量

public class StringBufferDemo {
	
	public static void main(String[] args) {
		//StringBuffer sb = "hello" ;
		//String s = "hello" ;
		//StringBuffer sb = s ;
		
		//public StringBuffer	()構造一個其中不帶字符的字符串緩衝區，其初始容量爲 16 個字符(構造方法)
		//創建一個字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		System.out.println("sb.length:"+sb.length());
		System.out.println("sb.capacity:"+sb.capacity());//16
		
		System.out.println("----------------------------");
		
		//	public StringBuffer(int capacity)構造一個不帶字符，但具有指定初始容量的字符串緩衝區
		StringBuffer sb2 = new StringBuffer(50) ;
		System.out.println("sb2.length:"+sb2.length());
		System.out.println("sb2.capacity:"+sb2.capacity());//50
		
		System.out.println("----------------------------");
		
		StringBuffer sb3 = new StringBuffer("hello") ;
		System.out.println("sb3.length:"+sb3.length());
		System.out.println("sb3.capacity:"+sb3.capacity());//默認:初始容量16 + 當前字符串長度
		
	}
}
		//StringBuffer sb = "hello" ;
		//String s = "hello" ;
		//StringBuffer sb = s ;
		
		//public StringBuffer	()構造一個其中不帶字符的字符串緩衝區，其初始容量爲 16 個字符(構造方法)
		//創建一個字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		System.out.println("sb.length:"+sb.length());
		System.out.println("sb.capacity:"+sb.capacity());//16
		
		System.out.println("----------------------------");
		
		//	public StringBuffer(int capacity)構造一個不帶字符，但具有指定初始容量的字符串緩衝區
		StringBuffer sb2 = new StringBuffer(50) ;
		System.out.println("sb2.length:"+sb2.length());
		System.out.println("sb2.capacity:"+sb2.capacity());//50
		
		System.out.println("----------------------------");
		
		StringBuffer sb3 = new StringBuffer("hello") ;
		System.out.println("sb3.length:"+sb3.length());
		System.out.println("sb3.capacity:"+sb3.capacity());//默認:初始容量16 + 當前字符串長度
		
	}
}

 StringBuffer中的和添加有關的方法
   public StringBuffer append(int/String/char/boolean/double/float....):當前這個方法追加,給緩衝中追加數據,返回字符串緩衝區本身(經常使用的)

 

  public StringBuffer insert(int offset,String str):在某一個位置處去插入str這個字符串,返回字符串緩衝區本身

 

 

public class StringBufferDemo2 {
	
	public static void main(String[] args) {
		
		//創建一個字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		
		//追加數據
		/*sb.append("hello") ;
		sb.append(true) ;
		sb.append(13.45) ;
		sb.append('A') ;
		sb.append(12.56F);*/
		
		//鏈式編程
		sb.append("hello").append(true).append(13.45).append('A').append(12.56F);
		
		//public StringBuffer insert(int offset,String str):在某一個位置處去插入str這個字符串,返回字符串緩衝區本身
		
		sb.insert(5, "world") ;
		//輸出
		System.out.println("sb:"+sb);
	}
}

		//創建一個字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		
		//追加數據
		/*sb.append("hello") ;
		sb.append(true) ;
		sb.append(13.45) ;
		sb.append('A') ;
		sb.append(12.56F);*/
		
		//鏈式編程
		sb.append("hello").append(true).append(13.45).append('A').append(12.56F);
		
		//public StringBuffer insert(int offset,String str):在某一個位置處去插入str這個字符串,返回字符串緩衝區本身
		
		sb.insert(5, "world") ;
		//輸出
		System.out.println("sb:"+sb);
	}
}

 

 

 

 StringBuffer的刪除功能:
  public StringBuffer deleteCharAt(int index):刪除指定位置處的字符,返回的是字符串緩衝區本身!
  public StringBuffer delete(int start,int end):刪除從指定位置開始到指定位置結束的字符,返回的是字符串緩衝區本身!
 

 

public class StringBufferDemo3 {
	
	public static void main(String[] args) {
		//創建字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		
		//給緩衝區追加數據
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		/*public StringBuffer deleteCharAt(int index)
		需求:要刪除當前緩衝區中'e'這個字符
		sb.deleteCharAt(1) ;
		需求:要刪除當前緩衝區中第一個'l'這個字符
		sb.deleteCharAt(1) ;*/
		
		//public StringBuffer delete(int start,int end)
		//sb.delete(5, 9) ;
		//從0索引開始,當前緩衝的字符串全部刪除掉
		sb.delete(0, sb.length()) ;
		
		//輸出
		System.out.println("sb:"+sb);
	}
}//創建字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		
		//給緩衝區追加數據
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		/*public StringBuffer deleteCharAt(int index)
		需求:要刪除當前緩衝區中'e'這個字符
		sb.deleteCharAt(1) ;
		需求:要刪除當前緩衝區中第一個'l'這個字符
		sb.deleteCharAt(1) ;*/
		
		//public StringBuffer delete(int start,int end)
		//sb.delete(5, 9) ;
		//從0索引開始,當前緩衝的字符串全部刪除掉
		sb.delete(0, sb.length()) ;
		
		//輸出
		System.out.println("sb:"+sb);
	}
}

 

StringBuffer的反轉功能:

   public StringBuffer reverse():將此字符串中的字符序列直接反轉

 

import java.util.Scanner;

public class StringBufferDemo4 {
	
	public static void main(String[] args) {
		
		//創建鍵盤錄入對象
		Scanner sc = new Scanner(System.in) ;
		
		//錄入並接收數據
		System.out.println("請您輸入一個字符串:");
		String line = sc.nextLine() ;
		
		//可以創建字符串緩衝區對象
		StringBuffer sb = new StringBuffer(line) ;
		//public String toString():現在的數據類型StirngBuffer類型,需要將StringBuffer類型轉換String
		//反轉功能
		 String result = sb.reverse().toString() ;
		 System.out.println("result:"+result);
		
		
	}
}
//創建鍵盤錄入對象
		Scanner sc = new Scanner(System.in) ;
		
		//錄入並接收數據
		System.out.println("請您輸入一個字符串:");
		String line = sc.nextLine() ;
		
		//可以創建字符串緩衝區對象
		StringBuffer sb = new StringBuffer(line) ;
		//public String toString():現在的數據類型StirngBuffer類型,需要將StringBuffer類型轉換String
		//反轉功能
		 String result = sb.reverse().toString() ;
		 System.out.println("result:"+result);
		
		
	}
}

 StringBuffer的替換功能:
  public StringBuffer replace(int start, int end,String str)
  從指定位置開始到指定位置結束的字符用str子字符串去替代

 

 

 

 

public class StringBufferDemo5 {
	
	public static void main(String[] args) {
		
		//創建字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		
		//給緩衝添加數據
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		//public StringBuffer replace(int start, int end,String str)
		sb.replace(5, 10, "節日快樂") ;
		
		System.out.println("sb:"+sb);
	}
}

		//創建字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		
		//給緩衝添加數據
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		//public StringBuffer replace(int start, int end,String str)
		sb.replace(5, 10, "節日快樂") ;
		
		System.out.println("sb:"+sb);
	}
}

StringBuffer的截取功能:
   public String substring(int start):從指定位置默認截取到末尾,返回值是一個新的字符串
public String substring(int start,int end):從指定位置開始截取到指定位置結束,包前不包後,返回一個新的字符串

 

 

 

 

public class StringBufferDemo6 {
	
	public static void main(String[] args) {
		//創建字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		
		//添加
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		
		
		
		//public String substring(int start)
		//String s1 = sb.substring(5) ;
		//System.out.println("s1:"+s1);
		
		//public String substring(int start,int end)
		String s2 = sb.substring(5,10) ;
		System.out.println("s2:"+s2);
		System.out.println("sb:"+sb);
	}
}
//創建字符串緩衝區對象
		StringBuffer sb = new StringBuffer() ;
		
		//添加
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		
		
		
		//public String substring(int start)
		//String s1 = sb.substring(5) ;
		//System.out.println("s1:"+s1);
		
		//public String substring(int start,int end)
		String s2 = sb.substring(5,10) ;
		System.out.println("s2:"+s2);
		System.out.println("sb:"+sb);
	}
}

 

 

 

 

 

 面試題1:
   String,   StringBuffer,  StringBuilder的區別?
  
   String:一個不可變的字符序列,StringBuffer:和StringBuilder是可變的字符序列,在單個線程時候的時候(優先採用StringBuilder)
   從線程角度考慮:
  StringBuilder線程不安全,不同步,執行效率高!它比StringBuffer要快!
 
   String和StringBuffer作爲形式參數
 
   String類型作爲形式參數和基本數據類型作爲形式參數的效果一樣!

 

 StringBuffer和數組的區別?

 

   兩個共同特點:都屬於容器類型的變量
   數組:只能存儲同一種數據類型的元素,數組的長度是固定的 
   int[] arr = {10,20,40,50,"hello"}  錯誤的 
   StringBuffer:字符串緩衝區,可以存儲任意類型的元素,可以不斷的去給緩衝區中追加(append),字符串緩衝區中:在內存始終返回的字符串

 

 

 

 

關於String和StringBuffer 的一些練習

 類與類之間的轉換
   A類型--->B類型
   這裏面可能最終使用B類型裏面的功能
   B類型--->A類型
   有時候需要的不是B類型,所以又要將B類型-->A類型
 
  StringBuffer--->String之間的相互轉換

 

public class StringBufferTest {
	
	public static void main(String[] args) {
		//String--->StringBuffer
		//定義一個字符串
		String s = "hello" ;
		
		/*StringBuffer sb = "hello" ;
		StringBuffer sb = s ;*/
		//方式1)使用StringBuffer的構造方式:StringBuffer(String str)
		//創建一個字符串緩衝區並指向這個字符串
		StringBuffer sb = new StringBuffer(s) ;
		System.out.println("sb:"+sb);
		
		//方式2)創建字符串緩衝區對象,使用無參構造StringBuffer(),利用append()
		StringBuffer sb2 = new StringBuffer() ;
		sb2.append(s) ;
		System.out.println("sb2:"+sb2);
		
		System.out.println("--------------------");
		
		//StringBuffer--->String
		//有一個字符串緩衝區對象
		StringBuffer buffer = new StringBuffer("world") ;
		//1)方式1String的另一種構造方法:String(StringBuffer buffer)
		String s2 = new String(buffer) ;
		System.out.println("s2:"+s2);
		//2)方式2:/public String toString():現在的數據類型StirngBuffer類型,需要將StringBuffer類型轉換String
		String s3 = buffer.toString() ;
		System.out.println("s3:"+s3);
	}
}
//String--->StringBuffer
		//定義一個字符串
		String s = "hello" ;
		
		/*StringBuffer sb = "hello" ;
		StringBuffer sb = s ;*/
		//方式1)使用StringBuffer的構造方式:StringBuffer(String str)
		//創建一個字符串緩衝區並指向這個字符串
		StringBuffer sb = new StringBuffer(s) ;
		System.out.println("sb:"+sb);
		
		//方式2)創建字符串緩衝區對象,使用無參構造StringBuffer(),利用append()
		StringBuffer sb2 = new StringBuffer() ;
		sb2.append(s) ;
		System.out.println("sb2:"+sb2);
		
		System.out.println("--------------------");
		
		//StringBuffer--->String
		//有一個字符串緩衝區對象
		StringBuffer buffer = new StringBuffer("world") ;
		//1)方式1String的另一種構造方法:String(StringBuffer buffer)
		String s2 = new String(buffer) ;
		System.out.println("s2:"+s2);
		//2)方式2:/public String toString():現在的數據類型StirngBuffer類型,需要將StringBuffer類型轉換String
		String s3 = buffer.toString() ;
		System.out.println("s3:"+s3);
	}
}

將數組拼接成一個字符串,分別使用String和StringBuffer實現(定義功能方法)
  
   int[] arr = {11,55,33 ,44 ,22} ;
   形成這樣一個字符串:[11, 55, 33, 44, 22] 
  分析:
   1)存在一個數組,靜態初始化
  2)分別使用String和StringBuffer類型去完成
  

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 ;
	}
}
//定義一個數組,靜態初始化!
		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 ;
	}
}

分別使用String和StringBuffer實現字符串的反轉

 

 

 

 

import java.util.Scanner;

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 ;
	}
}
//創建鍵盤錄入對象
		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 ;
	}
}

判斷一個字符串是否是對稱字符串
  
   例如"abc"不是對稱字符串，"aba"、"abba"、"aaa"、"mnanm"是對稱字符串
使用(String和StringBuffer實現這個功能)

分析:
用第一個字符和倒數第一個字符相比較
用二個字符和倒數第二個字符進行比較
...

 

 

 

 

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 ;
	}
}
//創建鍵盤錄入對象
		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 ;
	}
}

Integer

 

 需求:求一個整數100對應的二進制,八進制,十六進制
  需求:要求出Integer類型範圍:
  
 java的jkd5.0以後:還有一些新特性:自動拆裝箱,可變參數,增強for循環,靜態導入,枚舉...
  
  對於每個基本數據類型都會被自動封裝成一個引用類型
  基本類型      引用類型
  intInteger
  char            Character
  byte            Byte
  boolean       Boolean
  double         Double
  float             Float
  long             Long
  short           Short
  
  將基本類型--->引用類型的作用:就是爲了和String類型作爲轉換
  
  

public class IntegerDemo {
	
	public static void main(String[] args) {
		//public static String toBinaryString(int i)
		System.out.println(Integer.toBinaryString(100)) ;
		
		//public static String toOctalString(int i)
		System.out.println(Integer.toOctalString(100));
		
		//public static String toHexString(int i)
		System.out.println(Integer.toHexString(100));
		
		//public static final int MAX_VALUE
		//public static final int MIN_VALUE
		System.out.println(Integer.MAX_VALUE);//2147483647
		System.out.println(Integer.MIN_VALUE);//-2147483647
	}
}
//public static String toBinaryString(int i)
		System.out.println(Integer.toBinaryString(100)) ;
		
		//public static String toOctalString(int i)
		System.out.println(Integer.toOctalString(100));
		
		//public static String toHexString(int i)
		System.out.println(Integer.toHexString(100));
		
		//public static final int MAX_VALUE
		//public static final int MIN_VALUE
		System.out.println(Integer.MAX_VALUE);//2147483647
		System.out.println(Integer.MIN_VALUE);//-2147483647
	}
}

Integer類的構造方式:
  public Integer(int value):將一個int類型的數據封裝成一個引用類型
  public Integer(String s):將一個字符數類型封裝成一個Integer類型
  注意事項:
  該字符串必須是數字字符串!,否則拋出異常:java.lang.NumberFormatException
 

 

 

 

 

public class IntegerDemo2 {
	
	public static void main(String[] args) {
		//public Integer(int value)
		//創建一個Integer對象
		Integer i = new Integer(100);
		//Integer i = 100 ;//jdk5以後的自動裝箱!
		System.out.println("i:"+i);
		
		//public Integer(String s)
		//String s = "abc" ;
		String s = "20" ;
		Integer ii = new Integer(s) ;
		System.out.println("s:"+s);
	}
}
//public Integer(int value)
		//創建一個Integer對象
		Integer i = new Integer(100);
		//Integer i = 100 ;//jdk5以後的自動裝箱!
		System.out.println("i:"+i);
		
		//public Integer(String s)
		//String s = "abc" ;
		String s = "20" ;
		Integer ii = new Integer(s) ;
		System.out.println("s:"+s);
	}
}

 int類型和String類型的相互轉換

public class IntegerTest {
	
	public static void main(String[] args) {
		
		//定義一個int類型的數據
		int number = 100 ;
		
		//方式1)字符串拼接符
		String s1 = "" + number ;
		System.out.println("s1:"+s1);
		
		//方式2:int--->Integer類型
		Integer i = new Integer(number) ;
		//Integer--->String
		//public String toString()
		String s2 = i.toString() ;
		System.out.println("s2:"+s2);
		
		//方式3)public static String toString(int i)
		String s3 = Integer.toString(number) ;
		System.out.println("s3:"+s3);
		//方式4)
		//public static Integer valueOf(int i)
		Integer integer= Integer.valueOf(number) ;
		String s4 = integer.toString() ;
		System.out.println("s4:"+s4);
		
		System.out.println("---------------------------");
		
		//定義一個字符串:
		String s = "10" ;
		//方式1:String--->Integer---->int
		Integer ii = new Integer(s) ;
		//public int intValue()以 int 類型返回該 Integer 的值
		int num = ii.intValue() ;
		System.out.println("num:"+num);
		//public static int parseInt(String s)
		int num2 = Integer.parseInt(s) ;
		System.out.println("num2:"+num2);
		
		
		//Integer的內存緩存區:IntegerCashe
		//low = -128
		//high=127
		Integer i1 = 127 ;		//----->底層在封裝的時候:Integer integer = Inteter.valueOf(int i) ;
		Integer i2 = 127 ;
		
		
		
		System.out.println(i1==i2);//true
		Integer i3 = 128 ;
		Integer i4 = 128 ;
		System.out.println(i3==i4);//false

	}
}
//定義一個int類型的數據
		int number = 100 ;
		
		//方式1)字符串拼接符
		String s1 = "" + number ;
		System.out.println("s1:"+s1);
		
		//方式2:int--->Integer類型
		Integer i = new Integer(number) ;
		//Integer--->String
		//public String toString()
		String s2 = i.toString() ;
		System.out.println("s2:"+s2);
		
		//方式3)public static String toString(int i)
		String s3 = Integer.toString(number) ;
		System.out.println("s3:"+s3);
		//方式4)
		//public static Integer valueOf(int i)
		Integer integer= Integer.valueOf(number) ;
		String s4 = integer.toString() ;
		System.out.println("s4:"+s4);
		
		System.out.println("---------------------------");
		
		//定義一個字符串:
		String s = "10" ;
		//方式1:String--->Integer---->int
		Integer ii = new Integer(s) ;
		//public int intValue()以 int 類型返回該 Integer 的值
		int num = ii.intValue() ;
		System.out.println("num:"+num);
		//public static int parseInt(String s)
		int num2 = Integer.parseInt(s) ;
		System.out.println("num2:"+num2);
		
		
		//Integer的內存緩存區:IntegerCashe
		//low = -128
		//high=127
		Integer i1 = 127 ;		//----->底層在封裝的時候:Integer integer = Inteter.valueOf(int i) ;
		Integer i2 = 127 ;
		
		
		
		System.out.println(i1==i2);//true
		Integer i3 = 128 ;
		Integer i4 = 128 ;
		System.out.println(i3==i4);//false

	}
}

 

 

jdk5.0以後的新特性：自動拆裝箱

 

public class IntegerTest2 {
	
	public static void main(String[] args) {
		//創建一個Integer對象
		Integer i = new Integer(100) ;
		i += 200 ;
		System.out.println("i:"+i);
		
		/**
		 * 通過反編譯工具查看源碼:
		 * 	Integer i = new Integer(100); //將int類型值通過構造的形式自動裝箱爲Integer類型
			i = Integer.valueOf(i.intValue() + 200);//i.intValue()--->int類型的數據:把Integer--->int:自動拆箱
			自動裝箱了
			System.out.println((new StringBuilder("i:")).append(i).toString());
		 */
	}
}
//創建一個Integer對象
		Integer i = new Integer(100) ;
		i += 200 ;
		System.out.println("i:"+i);
		
		/**
		 * 通過反編譯工具查看源碼:
		 * 	Integer i = new Integer(100); //將int類型值通過構造的形式自動裝箱爲Integer類型
			i = Integer.valueOf(i.intValue() + 200);//i.intValue()--->int類型的數據:把Integer--->int:自動拆箱
			自動裝箱了
			System.out.println((new StringBuilder("i:")).append(i).toString());
		 */
	}
}

 

 

Character：

 Character 類在對象中包裝一個基本類型 char 的值。Character 類型的對象包含類型爲 char 的單個字段
  構造方法:
  public Character(char value)構造一個新分配的 Character 對象，用以表示指定的 char值。 

 

public class CharacterDemo {
	
	public static void main(String[] args) {
		//創建一個Character類的對象
		//Character character = new Character((char)97) ;
		Character character = new Character('a') ;
		System.out.println("character:"+character);
	}
}
//創建一個Character類的對象
		//Character character = new Character((char)97) ;
		Character character = new Character('a') ;
		System.out.println("character:"+character);
	}
}

 Character類的判斷功能:
   public static boolean isLowerCase(char ch)確定指定字符是否爲小寫字母。
public static boolenn isUpperCase(char ch)確定指定字符是否爲大寫字母
   public static boolean isDigit(char ch)確定指定字符是否爲數字。

 

 

 

 

 

 Character常用的轉換功能:
   public static char toUpperCase(char ch):將指定字符轉換成大寫
   public static char toLowerCase(char ch):將指定字符轉換成小寫
 
 

public class CharacterDemo2 {
	public static void main(String[] args) {
		

		//public static boolean isLowerCase(char ch)確定指定字符是否爲小寫字母
		System.out.println("isLowerCase:"+Character.isLowerCase('a'));
		System.out.println("isLowerCase:"+Character.isLowerCase('A'));
		System.out.println("isLowerCase:"+Character.isLowerCase('0'));
		System.out.println("---------------------------------------");

		//public static boolenn isUpperCase(char ch)確定指定字符是否爲大寫字母
		System.out.println("isUpperCase:"+Character.isUpperCase('a'));
		System.out.println("isUpperCase:"+Character.isUpperCase('A'));
		System.out.println("isUpperCase:"+Character.isUpperCase('0'));
		System.out.println("---------------------------------------");
		
                //public static boolean isDigit(char ch)確定指定字符是否爲數字。
		System.out.println("isDigit:"+Character.isDigit('a'));
		System.out.println("isDigit:"+Character.isDigit('A'));
		System.out.println("isDigit:"+Character.isDigit('0'));
		
		
	}
}
	//public static boolean isLowerCase(char ch)確定指定字符是否爲小寫字母
		System.out.println("isLowerCase:"+Character.isLowerCase('a'));
		System.out.println("isLowerCase:"+Character.isLowerCase('A'));
		System.out.println("isLowerCase:"+Character.isLowerCase('0'));
		System.out.println("---------------------------------------");

		//public static boolenn isUpperCase(char ch)確定指定字符是否爲大寫字母
		System.out.println("isUpperCase:"+Character.isUpperCase('a'));
		System.out.println("isUpperCase:"+Character.isUpperCase('A'));
		System.out.println("isUpperCase:"+Character.isUpperCase('0'));
		System.out.println("---------------------------------------");
		
                //public static boolean isDigit(char ch)確定指定字符是否爲數字。
		System.out.println("isDigit:"+Character.isDigit('a'));
		System.out.println("isDigit:"+Character.isDigit('A'));
		System.out.println("isDigit:"+Character.isDigit('0'));
		
		
	}
}

 需求:鍵盤錄入一個字符串,統計該字符串中大寫字母字符,小寫字母字符,數字字符有多少個(不考慮其他字符,使用Character提供的判斷功能去完成)
   分析:
   1)定義三個統計變量
  bigCount 
   smallCount
numberCount
  2)創建鍵盤錄入對象,錄入並接收一個字符串
  3)將字符串轉換成字符數組
  4)遍歷字符數組,獲取到每一個字符
  5)使用Character類中的判斷功能判斷是否是大寫,小寫,數字字符
  6)輸出

 

 

 

 

import java.util.Scanner;

public class CharacterTest {
	
	public static void main(String[] args) {
		//定義三個統計變量
		int bigCount = 0 ;
		int smallCount = 0 ;
		int numberCount = 0;
		
		//創建鍵盤錄入對象
		Scanner sc = new Scanner(System.in) ;
		
		//錄入並接收數據
		System.out.println("請您輸入一個字符串:");
		String line = sc.nextLine();
		
		//將字符串轉換成字符數組
		char[]  chs = line.toCharArray() ;
		for(int x = 0 ; x < chs.length ; x ++){
			//獲取每一個字符
			char ch = chs[x] ;
			
			//判斷
			if(Character.isUpperCase(ch)){
				bigCount ++ ;
			}else if(Character.isLowerCase(ch)){
				smallCount ++ ;
			}else if(Character.isDigit(ch)){
				numberCount ++ ;
			}
		}
		
		//輸出
		System.out.println("大寫字母字符共有:"+bigCount+"個");
		System.out.println("小寫字母字符共有:"+smallCount+"個");
		System.out.println("數字字符共有:"+numberCount+"個");
	}
}
//定義三個統計變量
		int bigCount = 0 ;
		int smallCount = 0 ;
		int numberCount = 0;
		
		//創建鍵盤錄入對象
		Scanner sc = new Scanner(System.in) ;
		
		//錄入並接收數據
		System.out.println("請您輸入一個字符串:");
		String line = sc.nextLine();
		
		//將字符串轉換成字符數組
		char[]  chs = line.toCharArray() ;
		for(int x = 0 ; x < chs.length ; x ++){
			//獲取每一個字符
			char ch = chs[x] ;
			
			//判斷
			if(Character.isUpperCase(ch)){
				bigCount ++ ;
			}else if(Character.isLowerCase(ch)){
				smallCount ++ ;
			}else if(Character.isDigit(ch)){
				numberCount ++ ;
			}
		}
		
		//輸出
		System.out.println("大寫字母字符共有:"+bigCount+"個");
		System.out.println("小寫字母字符共有:"+smallCount+"個");
		System.out.println("數字字符共有:"+numberCount+"個");
	}
}

 

 

冒泡排序的思想:

  兩兩比較,大的往後放,第一次比完,最大值出現在最大索引處,依次進行這樣的比較....

 

 

public class ArrayTest {
	
	public static void main(String[] args) {
		
		//定義一個數組,靜態初始化
		int[] arr = {24,69,80,57,13} ;
		
		System.out.println("排序前:");
		//遍歷數組
		printArray(arr) ;
		
		/*//第一次比較
		//arr.length-1:爲了防止角標越劇
		//arr.length-1-0:爲了減少比較的次數
		for(int x = 0 ; x < arr.length-1-0;x++){
			//判斷:兩兩比較,大的往後方法
			if(arr[x]>arr[x+1]){
				//中間變量進行互換
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] = temp;
			}
		}
		System.out.println("第一次比較後:");
		printArray(arr) ;
		
		//第二次比較:
		for(int x = 0 ; x < arr.length-1-1; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第二次比較後:");
		printArray(arr) ;
		
		//第三次比較:
		//arr.length-1:爲了防止角標越界
		////arr.length-1-2:爲了減少比較的次數
		for(int x = 0 ; x < arr.length-1-2; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第三次比較後:");
		printArray(arr) ;
		
		//第三次比較:
		//arr.length-1:爲了防止角標越界
		////arr.length-1-3:爲了減少比較的次數
		for(int x = 0 ; x < arr.length-1-3; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第四次比較後:");
		printArray(arr) ;*/
		/**
		 * 上述代碼重複度高,所以改進
		 */
	/*	for(int x = 0 ; x <4 ; x ++){
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判斷
				if(arr[y]>arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
		
		System.out.println("排序後:");
		printArray(arr) ;*/
		
		/**
		 * 上述代碼不夠好,如果數組非常多,那麼如何進行操作,應該定義一個功能,當前比較的次數是一個數組長度-1次
		 */
		bubbleSort(arr) ;
		System.out.println("排序後:");
		printArray(arr) ;
	}
	
	//冒泡排序的代碼
	//最終版代碼
	public static void bubbleSort(int[] arr){
		for(int x = 0 ; x < arr.length-1; x ++){
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判斷
				if(arr[y]>arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
	}
	
	//遍歷數組的功能:[元素1,元素2,....]
	public static void printArray(int[] arr){
		System.out.print("[");
		//遍歷數組
		for(int x = 0 ; x < arr.length ; x ++){
			//判斷是否是最大索引
			if(x==arr.length-1){
				System.out.println(arr[x]+"]");
			}else{
				System.out.print(arr[x]+", ");
			}
		}
	}
}
//定義一個數組,靜態初始化
		int[] arr = {24,69,80,57,13} ;
		
		System.out.println("排序前:");
		//遍歷數組
		printArray(arr) ;
		
		/*//第一次比較
		//arr.length-1:爲了防止角標越劇
		//arr.length-1-0:爲了減少比較的次數
		for(int x = 0 ; x < arr.length-1-0;x++){
			//判斷:兩兩比較,大的往後方法
			if(arr[x]>arr[x+1]){
				//中間變量進行互換
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] = temp;
			}
		}
		System.out.println("第一次比較後:");
		printArray(arr) ;
		
		//第二次比較:
		for(int x = 0 ; x < arr.length-1-1; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第二次比較後:");
		printArray(arr) ;
		
		//第三次比較:
		//arr.length-1:爲了防止角標越界
		////arr.length-1-2:爲了減少比較的次數
		for(int x = 0 ; x < arr.length-1-2; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第三次比較後:");
		printArray(arr) ;
		
		//第三次比較:
		//arr.length-1:爲了防止角標越界
		////arr.length-1-3:爲了減少比較的次數
		for(int x = 0 ; x < arr.length-1-3; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第四次比較後:");
		printArray(arr) ;*/
		/**
		 * 上述代碼重複度高,所以改進
		 */
	/*	for(int x = 0 ; x <4 ; x ++){
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判斷
				if(arr[y]>arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
		
		System.out.println("排序後:");
		printArray(arr) ;*/
		
		/**
		 * 上述代碼不夠好,如果數組非常多,那麼如何進行操作,應該定義一個功能,當前比較的次數是一個數組長度-1次
		 */
		bubbleSort(arr) ;
		System.out.println("排序後:");
		printArray(arr) ;
	}
	
	//冒泡排序的代碼
	//最終版代碼
	public static void bubbleSort(int[] arr){
		for(int x = 0 ; x < arr.length-1; x ++){
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判斷
				if(arr[y]>arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
	}
	
	//遍歷數組的功能:[元素1,元素2,....]
	public static void printArray(int[] arr){
		System.out.print("[");
		//遍歷數組
		for(int x = 0 ; x < arr.length ; x ++){
			//判斷是否是最大索引
			if(x==arr.length-1){
				System.out.println(arr[x]+"]");
			}else{
				System.out.print(arr[x]+", ");
			}
		}
	}
}