Java笔记第十一课（String类&StringBuffer类）

约定不等于承诺〃 2022-06-06 07:27 112阅读 0赞

## **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]+", ");
    			}
    		}
    	}
    }