語言基礎-面向對象基礎（數組排序、StringBUffer、包裝類）

冒泡排序、選擇排序

冒泡排序 ：輕的上浮，沉的降低

    原理：兩個相鄰位置比較，若是前面的比後面的元素大，就交換位置

選擇排序：用一個索引位置上的元素，依次與其餘位置上的元素比較，小的在前，大的在後

package com.heima.array;

public class Demo1_Array {

	/**
	 * * A:案例演示
	* 數組高級冒泡排序代碼
	 */
	public static void main(String[] args) {
		int[] arr = {24, 69, 80, 57, 13};
		bubbleSort(arr);
		//selectSort(arr);
		print(arr);
	}
	
	/*
	 * 冒泡排序
	 * 1,返回值類型,void
	 * 2,參數列表,int[] arr
	 * 
	 * 	第一次:arr[0]與arr[1],arr[1]與arr[2],arr[2]與arr[3],arr[3]與arr[4]比較4次
		第二次:arr[0]與arr[1],arr[1]與arr[2],arr[2]與arr[3]比較3次
		第三次:arr[0]與arr[1],arr[1]與arr[2]比較2次
		第四次:arr[0]與arr[1]比較1次
	 */
	
	public static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {				//外循環只須要比較arr.length-1次就能夠了
			for (int j = 0; j < arr.length - 1 - i; j++) {		//-1爲了防止索引越界,-i爲了提升效率
				if(arr[j] > arr[j+1]) {
					/*int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j+1] = temp;*/
					swap(arr,j,j+1);
				}
			}
		}
	}
	
	/*
	 * 打印數組
	 * 1,返回值類型void
	 * 2,參數列表int[]arr
	 */
	
	public static void print(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
	
	/*
	 * 選擇排序
	 * 1,返回值類型void
	 * 2,參數列表int[] arr
	 * 
	 * 	第一次:arr[0]分別與arr[1-4]比較,比較4次
		第二次:arr[1]分別與arr[2-4]比較,比較3次
		第三次:arr[2]分別與arr[3-4]比較,比較2次
		第四次:arr[3]與arr[4]比較,比較1次
	 */
	
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {				//只須要比較arr.length-1次
			for (int j = i + 1; j < arr.length; j++) {
				if(arr[i] > arr[j]) {
					/*int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;*/
					swap(arr,i,j);
				}
			}
		}
	}
	
	/*
	 * 換位操做
	 * 1,返回值類型,void
	 * 2,參數列表int[] arr.int i,int j
	 * 
	 * 若是某個方法,只針對本類使用,不想讓其餘類使用就能夠定義成私有的
	 */
	
	private static void swap(int[] arr,int i,int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

二分查找法

package com.heima.array;

public class Demo2_Array {

	/**
	 * * A:案例演示
			* 數組高級二分查找代碼
		* B:注意事項
			* 若是數組無序，就不能使用二分查找。
				* 由於若是你排序了，可是你排序的時候已經改變了我最原始的元素索引。

	 */
	public static void main(String[] args) {
		int[] arr = {11,22,33,44,55,66,77};
		System.out.println(getIndex(arr, 22));
		System.out.println(getIndex(arr, 66));
		System.out.println(getIndex(arr, 88));
	}
	
	/*
	 * 二分查找
	 * 1,返回值類型,int
	 * 2,參數列表int[] arr,int value
	 */
	
	public static int getIndex(int[] arr, int value) {
		int min = 0;
		int max = arr.length - 1;
		int mid = (min + max) / 2;
		
		while(arr[mid] != value) {					//當中間值不等於要找的值,就開始循環查找
			if(arr[mid] < value) {					//當中間值小於了要找的值
				min = mid + 1;						//最小的索引改變
			}else if (arr[mid] > value){			//當中間值大於了要找的值
				max = mid - 1;						//最大的索引改變
			}
			
			mid = (min + max) / 2;					//不管最大仍是最小改變,中間索引都會隨之改變
			
			if(min > max) {							//若是最小索引大於了最大索引,就沒有查找的可能性了
				return -1;							//返回-1
			}
		}
		return mid;
	}
}

package com.heima.array;

import java.util.Arrays;

public class Demo3_Arrays {

	/**
	 	* public static String toString(int[] a)
		* public static void sort(int[] a)
		* public static int binarySearch(int[] a,int key)
		* 
		*  public static String toString(int[] a) {
		        if (a == null)								//若是傳入的數組是null
		            return "null";							//返回null
		        int iMax = a.length - 1;					//iMax最大索引
		        if (iMax == -1)								//若是數組中沒有元素
		            return "[]";							//返回[]
		
		        StringBuilder b = new StringBuilder();		//線程不安全,效率高
		        b.append('[');								//將[添加到字符串緩衝區中
		        for (int i = 0; ; i++) {					//遍歷數組,判斷語句沒有寫默認是true
		            b.append(a[i]);							//把第一個元素添加進字符串緩衝區
		            if (i == iMax)							//若是索引等於了最大索引值
		                return b.append(']').toString();	//將]添加到字符串緩衝區,在轉換成字符串並返回
		            b.append(", ");							//若是不等於最大索引就將, 添加到緩衝區
		        }
    		}
    		
    	 private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
		        int low = fromIndex;				//最小索引0
		        int high = toIndex - 1;				//最大索引數組長度-1
		
		        while (low <= high) {				//最小索引小於等於最大索引能夠循環判斷
		            int mid = (low + high) >>> 1;	//求出中間索引值,(最小+最大)/2
		            int midVal = a[mid];			//經過中間索引獲取中間值
		
		            if (midVal < key)				//中間索引對應的值小於查找的值
		                low = mid + 1;				//最小索引變化
		            else if (midVal > key)			//中間索引對應的值大於查找的值
		                high = mid - 1;				//最大索引變化
		            else
		                return mid; // key found	//找到了
		        }
		        return -(low + 1);  // key not found.//-插入點 - 1
		    }
	 */
	public static void main(String[] args) {
		int[] arr = {33,22,11,44,66,55};
		System.out.println(Arrays.toString(arr));			//數組轉字符串
		
		Arrays.sort(arr);									//排序
		System.out.println(Arrays.toString(arr));
		
		int[] arr2 = {11,22,33,44,55,66};
		System.out.println(Arrays.binarySearch(arr2, 22));
		System.out.println(Arrays.binarySearch(arr2, 66));
		System.out.println(Arrays.binarySearch(arr2, 9));	//-插入點-1
	}

}

A:StringBuffer的構造方法：
            * public StringBuffer():無參構造方法
            * public StringBuffer(int capacity):指定容量的字符串緩衝區對象
            * public StringBuffer(String str):指定字符串內容的字符串緩衝區對象
        * B:StringBuffer的方法：
            * public int capacity()：返回當前容量。    理論值(不掌握)
            * public int length():返回長度（字符數）。 實際值
        * C:案例演示
            * 構造方法和長度方法的使用        

package com.heima.stringbuffer;

public class Demo1_StringBuffer {

	/**
	 * * A:StringBuffer的構造方法：
			* public StringBuffer():無參構造方法
			* public StringBuffer(int capacity):指定容量的字符串緩衝區對象
			* public StringBuffer(String str):指定字符串內容的字符串緩衝區對象
		* B:StringBuffer的方法：
			* public int capacity()：返回當前容量。	理論值(不掌握)
			* public int length():返回長度（字符數）。 實際值
		* C:案例演示
			* 構造方法和長度方法的使用
	 */
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		System.out.println(sb.length());			//容器中的字符個數,實際值
		System.out.println(sb.capacity());			//容器的初始容量,理論值
		
		StringBuffer sb2 = new StringBuffer(10);
		System.out.println(sb2.length());
		System.out.println(sb2.capacity());
		
		StringBuffer sb3 = new StringBuffer("heima");
		System.out.println(sb3.length());			//實際字符的個數
		System.out.println(sb3.capacity());			//字符串的length + 初始容量
		
	}

}

A:StringBuffer的添加功能
        * public StringBuffer append(String str):
            * 能夠把任意類型數據添加到字符串緩衝區裏面,並返回字符串緩衝區自己
        * public StringBuffer insert(int offset,String str):
            * 在指定位置把任意類型的數據插入到字符串緩衝區裏面,並返回字符串緩衝區自己
        StringBuffer是字符串緩衝區,當new的時候是在堆內存建立了一個對象,底層是一個長度爲16的字符數組
        當調用添加的方法時,不會再從新建立對象,在不斷向原緩衝區添加字符

    爲何說String是不可變的，StringBuffer是可變的？

        以下代碼，String初始化賦值之後再進行賦值操做，原來的對象變成了垃圾，而StringBuffer則四個引用指向的是同一個對象(sb,sb1,sb2,sb3四個引用均指向同一個對象)

package com.heima.stringbuffer;

public class Demo2_StringBuffer {

	/**
	 * * A:StringBuffer的添加功能
		* public StringBuffer append(String str):
			* 能夠把任意類型數據添加到字符串緩衝區裏面,並返回字符串緩衝區自己
		* public StringBuffer insert(int offset,String str):
			* 在指定位置把任意類型的數據插入到字符串緩衝區裏面,並返回字符串緩衝區自己
		StringBuffer是字符串緩衝區,當new的時候是在堆內存建立了一個對象,底層是一個長度爲16的字符數組
		當調用添加的方法時,不會再從新建立對象,在不斷向原緩衝區添加字符
	 */
	public static void main(String[] args) {
		//demo1();
		StringBuffer sb = new StringBuffer("1234");
		sb.insert(3, "heima");						//在指定位置添加元素,若是沒有指定位置的索引就會報索引越界異常
		
		System.out.println(sb);
	}

	private static void demo1() {
		StringBuffer sb = new StringBuffer();
		StringBuffer sb2 = sb.append(true);
		StringBuffer sb3 = sb.append("heima");
		StringBuffer sb4 = sb.append(100);
		
		
		System.out.println(sb.toString());			//StringBuffer類中重寫了toString方法,顯示的是對象中的屬性值
		System.out.println(sb2.toString());
		System.out.println(sb3.toString());
		System.out.println(sb4.toString());
	}

}

A:StringBuffer的刪除功能
        * public StringBuffer deleteCharAt(int index):
            * 刪除指定位置的字符，並返回自己
        * public StringBuffer delete(int start,int end):
            * 刪除從指定位置開始指定位置結束的內容，並返回自己
 

package com.heima.stringbuffer;

public class Demo3_StringBuffer {

	/**
	 * * A:StringBuffer的刪除功能
		* public StringBuffer deleteCharAt(int index):
			* 刪除指定位置的字符，並返回自己
		* public StringBuffer delete(int start,int end):
			* 刪除從指定位置開始指定位置結束的內容，並返回自己
	 */
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		//sb.deleteCharAt(5);					//當緩衝區中這個索引上沒有元素的時候就會報StringIndexOutOfBoundsException
		sb.append("heima");
		//sb.deleteCharAt(4);					//根據索引刪除掉索引位置上對應的字符
		//sb.delete(0, 2);						//刪除的時候是包含頭,不包含尾
		//System.out.println(sb);
		//sb.delete(0, sb.length());				//清空緩衝區
		//System.out.println(sb);
		
		sb = new StringBuffer();				//不要用這種方式清空緩衝區,原來的會變成垃圾,浪費內存
		System.out.println(sb);
	}

}

A:StringBuffer的替換功能
            * public StringBuffer replace(int start,int end,String str):
                * 從start開始到end用str替換
        * B:StringBuffer的反轉功能
            * public StringBuffer reverse():
                * 字符串反轉

package com.heima.stringbuffer;

public class Demo4_StringBufferMethod {

	/**
	 * * A:StringBuffer的替換功能
			* public StringBuffer replace(int start,int end,String str):
				* 從start開始到end用str替換
		* B:StringBuffer的反轉功能
			* public StringBuffer reverse():
				* 字符串反轉
	 */
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("我愛總複習");
		//sb.replace(0, 3, "bai");					//替換
		//System.out.println(sb);
		
		sb.reverse();
		System.out.println(sb);
	}

}

A:StringBuffer的截取功能
        * public String substring(int start):
            * 從指定位置截取到末尾
        * public String substring(int start,int end):
            * 截取從指定位置開始到結束位置，包括開始位置，不包括結束位置
    * B:注意事項
        * 注意:返回值類型再也不是StringBuffer自己
 

package com.heima.stringbuffer;

public class Demo5_StringBufferMethod {

	/**
	 * * A:StringBuffer的截取功能
		* public String substring(int start):
			* 從指定位置截取到末尾
		* public String substring(int start,int end):
			* 截取從指定位置開始到結束位置，包括開始位置，不包括結束位置
	* B:注意事項
		* 注意:返回值類型再也不是StringBuffer自己
	 */
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("woaiheima");
		//String str = sb.substring(4);
		//System.out.println(str);
		
		//System.out.println(sb);
		
		String str3 = sb.substring(4, 7);
		System.out.println(str3);
	}

}

A:String -- StringBuffer
        * a:經過構造方法
        * b:經過append()方法
    * B:StringBuffer -- String
        * a:經過構造方法
        * b:經過toString()方法
        * c:經過subString(0,length);
 

package com.heima.stringbuffer;

public class Demo6_StringBuffer {

	/**
	 * * A:String -- StringBuffer
		* a:經過構造方法
		* b:經過append()方法
	* B:StringBuffer -- String
		* a:經過構造方法
		* b:經過toString()方法：經常使用
		* c:經過subString(0,length);

	 */
	public static void main(String[] args) {
		//demo1();
		StringBuffer sb = new StringBuffer("heima");
		
		String s1 = new String(sb);						//經過構造將StringBuffer轉換爲String
		System.out.println(s1);
		
		String s2 = sb.toString();						//經過toString方法將StringBuffer轉換爲String
		System.out.println(s2);
		
		String s3 = sb.substring(0, sb.length());		//經過截取子字符串將StringBuffer轉換爲String
		System.out.println(s3);
	}

	private static void demo1() {
		StringBuffer sb1 = new StringBuffer("heima");			//經過構造方法將字符串轉換爲StringBuffer對象
		System.out.println(sb1);
		
		StringBuffer sb2 = new StringBuffer();
		sb2.append("heima");									//經過append方法將字符串轉換爲StringBuffer對象
		System.out.println(sb2);
	}

}

A:形式參數問題
            * String做爲參數傳遞
            * StringBuffer做爲參數傳遞 
        * B:案例演示
            * String和StringBuffer分別做爲參數傳遞問題
            * 
    基本數據類型的值傳遞,不改變其值
    引用數據類型的值傳遞,改變其值    
    String類雖然是引用數據類型,可是他看成參數傳遞時和基本數據類型是同樣的

package com.heima.stringbuffer;

public class Demo7_StringBuffer {

	/**
	 * * A:形式參數問題
			* String做爲參數傳遞
			* StringBuffer做爲參數傳遞 
		* B:案例演示
			* String和StringBuffer分別做爲參數傳遞問題
			* 
	基本數據類型的值傳遞,不改變其值
	引用數據類型的值傳遞,改變其值
	
	String類雖然是引用數據類型,可是他看成參數傳遞時和基本數據類型是同樣的。初始化不會改變
	 */
	public static void main(String[] args) {
		String s = "heima";
		System.out.println(s);                           //heima
		change(s);
		System.out.println(s);                           //heima。change方法彈棧，heimaitcast消失，存在的仍是heima
		
		
		System.out.println("---------------------");
		StringBuffer sb = new StringBuffer();
		sb.append("heima");
		System.out.println(sb);
		change(sb);
		System.out.println(sb);
	}

	public static void change(StringBuffer sb) {
		sb.append("itcast");
	}

	public static void change(String s) {
		s += "itcast";
	}

}

需求：把數組中的數據按照指定個格式拼接成一個字符串
    * 
            舉例：
                int[] arr = {1,2,3};    
            輸出結果：
                "[1, 2, 3]"
                
            用StringBuffer的功能實現
 

package com.heima.test;

public class Test1 {

	/**
	 * * 需求：把數組中的數據按照指定個格式拼接成一個字符串
	* 
			舉例：
				int[] arr = {1,2,3};	
			輸出結果：
				"[1, 2, 3]"
				
			用StringBuffer的功能實現
	 */
	public static void main(String[] args) {
		int[] arr = {1,2,3};
		System.out.println(arrayToString(arr));
	}

	/*
	 * 將數組轉換爲字符串
	 * 1,返回值類型String
	 * 2,參數列表int[]
	 * 
	 * arrayToString 將數組轉換爲字符串
	 * array2String		2與to的發音同樣就用2替換了to,後來演變成了一種書寫習慣
	 * dom4j  domForJ
	 */
	
	public static String arrayToString(int[] arr) {
		StringBuffer sb = new StringBuffer();				//建立字符串緩衝區對象
		sb.append("[");										//將[添加到緩衝區
		
		
		//{1,2,3}
		for (int i = 0; i < arr.length; i++) {				//遍歷數組
			//sb.append(arr[i] + ", ");						//這樣作沒有]。不推薦這種方式鏈接字符串，應爲變量與常量相加時候，底層會建立新的String
			if(i == arr.length - 1) {
				sb.append(arr[i]).append("]");				//[1, 2, 3]
			}else {
				sb.append(arr[i]).append(", ");				//[1, 2,
			}
		}
		return sb.toString();
	}
}

 A:案例演示
    * 
            需求：把字符串反轉
                舉例：鍵盤錄入"abc"        
                輸出結果："cba"
                
            用StringBuffer的功能實現

package com.heima.test;

import java.util.Scanner;

public class Test2 {

	/**
	 * * A:案例演示
	* 
			需求：把字符串反轉
				舉例：鍵盤錄入"abc"		
				輸出結果："cba"
				
			用StringBuffer的功能實現	
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);				//建立鍵盤錄入對象
		String line = sc.nextLine();						//將鍵盤錄入的字符串存儲在line中
		
		/*StringBuffer sb = new StringBuffer(line);			//將字符串轉換爲StringBuffer對象
		sb.reverse();										//將緩衝區的內容反轉
		
		System.out.println(sb.toString());*/
		
		System.out.println(revString(line));
	}

	/*
	 * 將字符串反轉
	 * 1,返回值類型String
	 * 2,參數列表String line
	 */
	
	public static String revString(String line) {
		StringBuffer sb = new StringBuffer(line);			//將字符串轉換爲StringBuffer對象
		sb.reverse();										//將緩衝區的內容反轉
		
		return sb.toString();
	}
}

StringBuffer和StringBuilder和String的區別

StringBuffer是JDK1.0版本的，是線程安全的，效率低

StringBuilder是JDK1.5版本的，是線程不安全的，效率高

String是一個不可變字符序列

StringBuffer，StringBuilder是可變的字符序列

 A:爲何會有基本類型包裝類
            * 將基本數據類型封裝成對象的好處在於能夠在對象中定義更多的功能方法操做該數據。
        * B:經常使用操做
            * 經常使用的操做之一：用於基本數據類型與字符串之間的轉換。
        * C:基本類型和包裝類的對應
 

package com.heima.wrapclass;

public class Demo1_Integer {

	/**
	 * * A:爲何會有基本類型包裝類
			* 將基本數據類型封裝成對象的好處在於能夠在對象中定義更多的功能方法操做該數據。
		* B:經常使用操做
			* 經常使用的操做之一：用於基本數據類型與字符串之間的轉換。
		* C:基本類型和包裝類的對應
		* 
				byte 			Byte
				short			Short
				int				Integer
				long			Long
				float			Float
				double			Double
				char			Character
				boolean			Boolean
	 */
	public static void main(String[] args) {
		System.out.println(Integer.toBinaryString(60));
		System.out.println(Integer.toOctalString(60));
		System.out.println(Integer.toHexString(60));
	}

}

A:Integer類概述
            * 經過JDK提供的API，查看Integer類的說明
        
            * Integer 類在對象中包裝了一個基本類型 int 的值,
            * 該類提供了多個方法，能在 int 類型和 String 類型之間互相轉換，
            * 還提供了處理 int 類型時很是有用的其餘一些常量和方法
        * B:構造方法
            * public Integer(int value)
            * public Integer(String s)
        * C:案例演示
            * 使用構造方法建立對象
 

package com.heima.wrapclass;

public class Demo2_Integer {

	/**
	 * * A:Integer類概述
			* 經過JDK提供的API，查看Integer類的說明
		
			* Integer 類在對象中包裝了一個基本類型 int 的值,
			* 該類提供了多個方法，能在 int 類型和 String 類型之間互相轉換，
			* 還提供了處理 int 類型時很是有用的其餘一些常量和方法
		* B:構造方法
			* public Integer(int value)
			* public Integer(String s)
		* C:案例演示
			* 使用構造方法建立對象
	 */
	public static void main(String[] args) {
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
		
		Integer i1 = new Integer(100);
		System.out.println(i1);
		
		//Integer i2 = new Integer("abc");			//java.lang.NumberFormatException數字格式異常
		//System.out.println(i2);						//由於abc不是數字字符串,因此轉換會報錯
		
		Integer i3 = new Integer("100");
		System.out.println(i3);
	}

}

 A:int -- String
            * a:和""進行拼接
            * b:public static String valueOf(int i)
            * c:int -- Integer -- String(Integer類的toString方法())
            * d:public static String toString(int i)(Integer類的靜態方法)
        * B:String -- int
            * a:String -- Integer -- int
                * public static int parseInt(String s)
        基本數據類型包裝類有八種,其中七種都有parseXxx的方法,能夠將這七種的字符串表現形式轉換成基本數據類型
 

package com.heima.wrapclass;

public class Demo3_Integer {

	/**
	 * * A:int -- String
			* a:和""進行拼接
			* b:public static String valueOf(int i)
			* c:int -- Integer -- String(Integer類的toString方法())
			* d:public static String toString(int i)(Integer類的靜態方法)
		* B:String -- int
			* a:String -- Integer -- int
				* public static int parseInt(String s)
		基本數據類型包裝類有八種,其中七種都有parseXxx的方法,能夠將這七種的字符串表現形式轉換成基本數據類型
	 */
	public static void main(String[] args) {
		
		//demo1();
		String s1 = "true";
		boolean b = Boolean.parseBoolean(s1);
		System.out.println(b);
		
		//String s2 = "abc";
		//char c = Character.p		//char的包裝類Character中沒有pareseXxx的方法
									//字符串到字符的轉換經過toCharArray()就能夠把字符串轉換爲字符數組
	}

	private static void demo1() {
		//int ----> String int轉換成String
		int i = 100;
		String s1 = i + "";						//推薦用
		String s2 = String.valueOf(i);			//推薦用
		
		Integer i2 = new Integer(i);
		String s3 = i2.toString();
		
		String s4 = Integer.toString(i);
		System.out.println(s1);
		
		//String----> int String 轉換int
		String s = "200";
		Integer i3 = new Integer(s);
		int i4 = i3.intValue();					//將Integer轉換成了int數
		
		int i5 = Integer.parseInt(s);			//將String轉換爲int,推薦用這種
	}

}

A:JDK5的新特性
            * 自動裝箱：把基本類型轉換爲包裝類類型
            * 自動拆箱：把包裝類類型轉換爲基本類型
        * B:案例演示
            * JDK5的新特性自動裝箱和拆箱
            
            * Integer ii = 100;
            * ii += 200;
        * C:注意事項
            * 在使用時，Integer  x = null;代碼就會出現NullPointerException。
            * 建議先判斷是否爲null，而後再使用。
 

package com.heima.wrapclass;

public class Demo4_JDK5 {

	/**
	 * * A:JDK5的新特性
			* 自動裝箱：把基本類型轉換爲包裝類類型
			* 自動拆箱：把包裝類類型轉換爲基本類型
		* B:案例演示
			* JDK5的新特性自動裝箱和拆箱
			
			* Integer ii = 100;
			* ii += 200;
		* C:注意事項
			* 在使用時，Integer  x = null;代碼就會出現NullPointerException。
			* 建議先判斷是否爲null，而後再使用。
	 */
	public static void main(String[] args) {
//		int x = 100;
//		Integer i1 = new Integer(x);			//將基本數據類型包裝成對象,裝箱
//		
//		int y = i1.intValue();					//將對象轉換爲基本數據類型,拆箱
		
		Integer i2 = 100;						//自動裝箱,把基本數據類型轉換成對象
		int z = i2 + 200;						//自動拆箱,把對象轉換爲基本數據類型
		System.out.println(z);
		
		Integer i3 = null;
		int a = i3 + 100;						//底層用i3調用intValue,可是i3是null,null調用方法就會出現
		System.out.println(a);					//空指針異常java.lang.NullPointerException
	}

}

package com.heima.wrapclass;


public class Demo5_Integer {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Integer i1 = new Integer(97);
		Integer i2 = new Integer(97);
		System.out.println(i1 == i2);				//false
		System.out.println(i1.equals(i2));			//true
		System.out.println("-----------");
	
		Integer i3 = new Integer(197);
		Integer i4 = new Integer(197);
		System.out.println(i3 == i4);				//false
		System.out.println(i3.equals(i4));			//true
		System.out.println("-----------");
	
		Integer i5 = 127;
		Integer i6 = 127;
		System.out.println(i5 == i6);				//true
		System.out.println(i5.equals(i6));			//true
		System.out.println("-----------");
	
		Integer i7 = 128;
		Integer i8 = 128;
		System.out.println(i7 == i8);
		System.out.println(i7.equals(i8));			//true
		
		/*
		 * -128到127是byte的取值範圍,若是在這個取值範圍內,自動裝箱就不會新建立對象,而是從常量池中獲取
		 * 若是超過了byte取值範圍就會再新建立對象
		 * 
		 * public static Integer valueOf(int i) {
		        assert IntegerCache.high >= 127;
		        if (i >= IntegerCache.low && i <= IntegerCache.high)			//i>= -128 && i <= 127
		            return IntegerCache.cache[i + (-IntegerCache.low)];
		        return new Integer(i);
		    }
		 */
	}

}