java基礎13

1:數組的高級操作

字符串排序(屬於算法)：

排序算法：插入排序、歸併排序、快速排序、冒泡排序、希爾排序、選擇排序

(1)數組：存儲同一種數據類型的多個元素的容器。
(2)特點：每個元素都有從0開始的編號，方便我們獲取。專業名稱：索引。
(3)數組操作：

		A:遍歷
			public static void printArray(int[] arr) {
				for(int x=0; x<arr.length; x++) {
					System.out.println(arr[x]);
				}
			}


		B:獲取最值
			public static int getMax(int[] arr) {
				int max = arr[0];
				for(int x=1; x<arr.length; x++) {
					if(arr[x]>max) {
						max = arr[x];
					}
				}
				return max;
			}
		C:排序
			a:冒泡排序
				原理：相鄰元素兩兩比較，大的往後放。第一次完畢，最大值在最大索引處。
				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;
							}
						}
					}
				}


			b:選擇排序
				原理：從0索引元素開始，依次和後面的所有元素比較，小的往0索引處放。
				      第一次完畢後，最小值在最小索引處。
				public static void selectSort(int[] arr) {
					for(int x=0; x<arr.length-1; x++) {
						for(int y=x+1; y<arr.length; y++) {
							if(arr[y]<arr[x]) {
								int temp = arr[y];
								arr[y] = arr[x];
								arr[x] = temp;
							}
						}
					}
				}
		D:查找
			a:普通查找
				原理：遍歷數組，從頭找到尾
				public static int getIndex(int[] arr,int value) {
					int index = -1;
					for(int x=0; x<arr.length; x++) {
						if(arr[x]==value) {
							index = x;
							break;
						}
					}
					return index;
				}
			b:二分查找(折半查找)
				前提：數組必須是有序的。
				原理：每次都從中間開始找，如果比中間數據小，就在左邊找，
				      如果比中間數據大，就在右邊找，如果相等，就返回中間的索引值。
				public static int getIndex(int[] arr,int value) {
					int start = 0;
					int end = arr.length-1;
					int mid = (start+end)/2;
					while(arr[mid]!=value){
						if(value>arr[mid]) {
							start = mid + 1;
						}else if(value<arr[mid]) {
							end = mid - 1;
						}
						if(start > end) {
							return -1;
						}
						mid = (start+end)/2;
					}
					return mid;
				}

2:Arrays工具類的使用
(1)Arrays是針對數據進行操作的工具類。
(2)要掌握的功能：
A:把數組轉成字符串
public static String toString(int[] arr)
B:自然排序
public static void sort(int[] arr)
C:二分查找
public static int binarySearch(int[] arr,int value)
(3)Arrays工具類的源碼。

3:StringBuffer類
(1)StringBuffer:是字符串緩衝區類，長度可以改變。
(2)面試題：
String和StringBuffer的區別?
String的長度固定。
StringBuffer的長度可變。
StringBuffer和StringBuilder的區別?
StringBuffer的線程安全,效率低。
StringBuilder的線程不安去,效率高。
(3)StringBuffer的構造方法
A:StringBuffer sb = new StringBuffer(); //默認容量16
B:StringBuffer sb = new StringBuffer(int capacity); //給定容量
C:StringBuffer sb = new StringBuffer(String s); //字符串長度+默認容量
注意：StringBuilder的功能和StringBuffer一模一樣。前者是JDK5以後出現的。
(4)要掌握的功能：(請自己把對應的方法寫出來)
A:添加功能
public StringBuffer append(String str);
public StringBuffer insert(int offset,String str)
B:刪除功能
public StringBuffer delete(int start,int end)
public StringBuffer deleteCharAt(int index)
C:其他功能
替換功能
public StringBuffer replace(int start,int end,String str)
截取功能
public String substring(int index);
public String substring(int start,int end)
反轉功能
public StringBuffer reverse()
(5)案例：
把一個字符串反轉。

import java.util.Arrays;

/*
 * 對字符串中字符進行自然順序排序
 * "basckd" -- "abcdks"
 * 
 * 思路：
 * 		A:定義一個字符串。
 * 		B:把字符串轉換成字符數組。
 * 		C:對字符數組進行排序
 * 		D:把字符數組轉換成字符串。
 * 		E:輸出轉換後的字符串。
 */
public class StringTest {
	public static void main(String[] args) {
		// 定義一個字符串。
		String s = "basckd";

		// 把字符串轉換成字符數組。
		char[] chs = s.toCharArray();

		// 對字符數組進行排序
		// bubbleSort(chs);
		Arrays.sort(chs); // 開發用

		// 把字符數組轉換成字符串。
		/*
		 * 1:構造方法 2:copyValueOf 3:valueOf
		 */
		String result = String.valueOf(chs);

		// 輸出轉換後的字符串。
		System.out.println(result);

	}

	// 面試用
	public static void bubbleSort(char[] 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]) {
					char temp = arr[y];
					arr[y] = arr[y + 1];
					arr[y + 1] = temp;
				}
			}
		}
	}
}

4:基本數據類型包裝類(掌握)
(1)由於我們對基本類型只能做一些最簡單的操作，
  爲了讓我們有更多的操作，java就針對每種基本類型提供了保證類。
(2)八種基本類型對應的包裝類是誰?
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
(3)Integer類的構造方法
A:Integer i = new Integer(int x);
B:Integer i = new Integer(String s);
注意：這裏的s必須是有數字字符組成的字符串。
(4)Integer的功能
A:String -- int
String s = "100";
int i = Integer.parseInt(s);


B:int -- String
int i = 100;
String s = String.valueOf(i);
(5)JDK5以後的新特性
A:自動裝箱 從int--Integer
B:自動拆箱 從Integer--int


請大家解釋下面的代碼：哪裏體現了自動裝箱，哪裏體現了自動拆箱
Integer i = 100; //自動裝箱 等價於Integer i=new Integer(100);
i += 200; //i+200 自動拆箱i.intValue(),轉換成基本數據類型運算，運算成功在自動裝箱賦值給i
System.out.println(i);

注意：
讓我們操作變得簡單，但是隱含了一個問題，這個時候，我們在使用對象前，最好做不爲空的校驗。
(6)面試題：(看代碼 IntegerTest.java)

byte常量池。自從有了自動裝箱以後，在byte 範圍內的數據賦值給包裝類時可以直接從byte常量池裏獲取

/*
 * 面試題：byte常量池。
 * 自從有了自動裝箱後，在byte範圍內的值直接賦值給包裝類的時候，是從常量池裏獲取的。
 */
public class IntegerTest {
	public static void main(String[] args) {
		Integer i1 = new Integer(127);
		Integer i2 = new Integer(127);
		System.out.println(i1 == i2);// false
		System.out.println(i1.equals(i2));// true

		Integer i3 = new Integer(128);
		Integer i4 = new Integer(128);
		System.out.println(i3 == i4);// false
		System.out.println(i3.equals(i4)); // true

		Integer i5 = 127;
		Integer i6 = 127;
		System.out.println(i5 == i6); // ??? -- true
		System.out.println(i5.equals(i6));// true

		Integer i7 = 128;
		Integer i8 = 128;
		System.out.println(i7 == i8); // ??? --false
		System.out.println(i7.equals(i8)); // true
	}
}

(7)案例：
把字符串"-34 29 76 11 27"中的數據排序並輸出。
思路：定義字符串
     將字符串分割爲字符串數組
     定義int類型的數組，使用包裝類將對應的字符串轉換爲int類型的元素，賦值給對應的int數組元素
     對int類型數組排序，可自定義方法，可使用Arrays工具類

     將int數組元素轉換爲字符串，使用StringBuilder類的append()方法

import java.util.Arrays;

/*
 * 需求：
 * 		我有這樣的一個字符串"34 -12 56 93 27"
 * 	             請想辦法實現把字符串中的數據進行排序。
 * 舉例：
 * 	   	有： "34 -12 56 93 27"
 * 		 結果："-12 27 34 56 93"	
 * 
 * 思路：  
 * 		A:定義一個字符串
 * 		B:把字符串按照空格進行分割得到一個字符串數組
 * 		C:把字符串數組轉成成int數組
 * 		D:對int數組排序
 * 		E:在把排序後的int數組轉換成String
 * 	
 *  */
public class StringTest {
	public static void main(String[] args) {
		//定義一個字符串
		String s = "34 -12 56 93 27";
		
		//把字符串按照空格進行分割得到一個字符串數組
		String[] strArray = s.split(" ");
		
		//把字符串數組轉成成int數組
		int[] arr = new int[strArray.length];
		
		for(int x=0; x<arr.length; x++) {
			arr[x] = Integer.parseInt(strArray[x]);
		}
		
		//對int數組排序
		Arrays.sort(arr);
		
		//在把排序後的int數組轉換成String
//		StringBuilder builder = new StringBuilder();
//		for(int x=0; x<arr.length; x++) {
//			builder.append(arr[x]).append(" ");
//		}
//		String result = builder.toString().trim();
		
		//調用功能
		String result = arrayToString(arr);
		
		System.out.println(result);
	}
	
	/*
	 * 返回值類型：String
	 * 參數類別：int[] arr
	 */
	public static String arrayToString(int[] arr) {
		StringBuilder builder = new StringBuilder();
		
		for(int x=0; x<arr.length; x++) {
			builder.append(arr[x]).append(" ");
		}
		
		return builder.toString().trim();
	}
	
}

5:Random(理解)
(1)是產生隨機數的類。
(2)構造方法：
A:Random r = new Random();
B:random r = new Random(long seed);


注意：種子一樣，隨機數一樣。
(3)掌握的方法：

public int nextInt(int n):產生在[0,n)之間的隨機數。

import java.util.Random;

/*
 * Random:是產生隨機數的類。跟種子相關。
 * 
 * 構造方法：
 * 		Random():沒有給種子產生隨機數,默認種子是當前時間的毫秒值。
 *		Random(long seed)：給定種子產生隨機數。如果種子相同，那麼， 將產生相同的隨機數。
 *
 * 要掌握的功能：
 * 		public int nextInt()：int範圍內的隨機數。
 * 		public int nextInt(int n)：獲取的是[0,n)之間的隨機數。
 */
public class RandomDemo {
	public static void main(String[] args) {
		// 不給種子
		// Random r = new Random();
		// 給種子
		Random r = new Random(250);

		// 表示我要生成10個[0,100)之間的隨機數
		for (int x = 0; x < 10; x++) {
			System.out.println(r.nextInt(100));
		}
	}
}