將基本數(shù)據(jù)類型封裝成對象的好處在于可以在對象中定義更多的功能方法操作該數(shù)據(jù)，最常用的操作之一就是用于基本數(shù)據(jù)類型與字符串之間的轉(zhuǎn)換。
幾乎所有基本類型的包裝類都是該類型關(guān)鍵字的首字母大寫，除了以下特例：
int —>Integer
char —>Character
以Integer為例子，包裝類幾乎都具有以下方法：
| 方法名 | 說明 |
|---|---|
| public Integer(int value) | 根據(jù) int 值創(chuàng)建 Integer 對象(過時(shí)) |
| public Integer(String s) | 根據(jù) String 值創(chuàng)建 Integer 對象(過時(shí)) |
| public static Integer valueOf?(int i) | 返回表示指定的 int 值的 Integer 實(shí)例 |
| public static Integer valueOf?(String s) | 返回一個(gè)保存指定值的 Integer 對象 String |
| static int parseInt(String s) | 將字符串類型的整數(shù)變成int類型的整數(shù) |
| public static String valueOf(int i) | 返回 int 參數(shù)的字符串表示形式。該方法是 String 類中的方法 |
除此之外，還需要對上述數(shù)組進(jìn)行排序
重慶分公司
重慶分公司
import static java.lang.Integer.parseInt;
public class IntString {public static void main(String[] args) {String str = "91 27 46 38 50";
//先將字符串分割
String[] split = str.split(" ");
int[] number = new int[split.length];
//然后將分割后的字符串用parseInt轉(zhuǎn)換為int類型
for (int i = 0; i< number.length; i++) {number[i] = parseInt(split[i]);
}
//以下使用的是冒泡排序，最終得出的結(jié)果是降序排列，也可以做升序
for (int i = 0; i< number.length; i++) {int temp = 0;
for (int j = 0; j< number.length; j++) {if (number[i] >number[j]){temp = number[j];
number[j] = number[i];
number[i] = temp;
}
}
}
for (int i = 0; i< number.length; i++) {System.out.print(number[i] + " ");
}
}
}
其實(shí)上述操作中，不少都有現(xiàn)成的API可以使用，簡化版本在之后會提到。
裝箱：把基本數(shù)據(jù)類型轉(zhuǎn)換為對應(yīng)的包裝類類型；
拆箱：把包裝類類型轉(zhuǎn)換為對應(yīng)的基本數(shù)據(jù)類型。
在使用包裝類類型的時(shí)候，如果需要進(jìn)行操作，最好先判斷是否為 null。
推薦只要是對象，在使用前就必須進(jìn)行不為 null 的判斷。
public class Integer {public static void main(String[] args) {int age = 23;
java.lang.Integer.valueOf(age);//裝箱，將int包裝為Integer
age += 100;//拆箱，重新轉(zhuǎn)換為int
}
}二分查找找得快以及能對半對半的查，前提是要經(jīng)過排序，沒有排序也就無法通過二分查找。
二分查找原理步驟為
public class HalfSearch {public static void main(String[] args) {int[] numbers = {2, 3, 4, 5, 6, 34, 56, 78, 899};
//要用二分查找，數(shù)組必須是排序好的
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入要查找的數(shù)：");
int search = scanner.nextInt();
System.out.println(binarySearch(numbers, search));
}
public static int binarySearch(int[] array, int search){int min = 0;//默認(rèn)初始是數(shù)組頭部，索引為0
int max = array.length;//默認(rèn)初始是數(shù)組尾部，索引為array.length
while (min<= max){int mid = (min + max)/2;
int current = array[mid];//定義當(dāng)前基準(zhǔn)為mid位置的元素
if (current< search){min = mid + 1;
} else if(current >search){max = mid - 1;
} else {return mid;
}
}
return -1;
}
}
//查找6，返回4，即元素6的索引為4。二分查找相當(dāng)于每次去掉一半的查找范圍。
冒泡排序相鄰的數(shù)據(jù)兩兩比較，小的放前面，大的放后面。
如果有n個(gè)數(shù)據(jù)進(jìn)行排序，總共需要比較n-1次；每一次比較完畢，下一次的比較就會少一個(gè)數(shù)據(jù)參與。
public class PopSearch {public static void main(String[] args) {int[] numbers = {2, 3, 56, 78, 899, 6, 34,4, 5};
bubbleSort(numbers);
for (int i = 0; i< numbers.length; i++) {System.out.println(numbers[i]);
}
}
public static void bubbleSort(int[] array){int temp = 0;
//定義雙層for循環(huán)，保證每一次元素都是與剩下的所有元素比較過的
for (int i = 0; i< array.length -1; i++) {for (int j = i+1; j< array.length; j++) {//如果后一個(gè)元素比當(dāng)前元素小，那么將它們互換位置
if (array[i] >array[j]){temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
}
}
}
//排序后結(jié)果為：[2，3，4，5，6，34，56，78，899]遞歸就是自己調(diào)用自己，能不用就不用，遞歸很消耗內(nèi)存。
遞歸解決問題的思路：
遞歸解決問題要找到兩個(gè)內(nèi)容：
public class Factorial {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);
System.out.println("請輸入要求的階乘：");
//一個(gè)數(shù)的階乘就是從1到它自己的所有數(shù)相乘
int number = scanner.nextInt();
System.out.println(factorial(number));
}
public static int factorial(int n){if (n == 1) {return 1;
} else {return n * factorial(n - 1);//遞歸調(diào)用
}
}
}快速排序算法中，每一次遞歸時(shí)以第一個(gè)數(shù)為基準(zhǔn)數(shù)，找到數(shù)組中所有比基準(zhǔn)數(shù)小的。再找到所有比基準(zhǔn)數(shù)大的。小的全部放左邊，大的全部放右邊，確定基準(zhǔn)數(shù)的正確位置。
public class QuickSort {public static void main(String[] args) {int[] array = {6,3,7,1,9,4,8,5,2,10};
int low = 0,high = array.length - 1;
quickRow(array,low,high);
for (int i : array){System.out.println(i);
}
}
public static void quickRow(int[] array, int low, int high){int i,j,pivot;
//結(jié)束條件
if (low >= high) {return;
}
i = low;
j = high;
//選擇的節(jié)點(diǎn)，這里選擇的數(shù)組的第一數(shù)作為節(jié)點(diǎn)
pivot = array[low];
while (i< j){//從右往左找比節(jié)點(diǎn)小的數(shù)，循環(huán)結(jié)束要么找到了，要么i=j
while (array[j] >= pivot && i< j){j--;
}
//從左往右找比節(jié)點(diǎn)大的數(shù)，循環(huán)結(jié)束要么找到了，要么i=j
while (array[i]<= pivot && i< j){i++;
}
//如果i!=j說明都找到了，就交換這兩個(gè)數(shù)
if (i< j){int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
//i==j一輪循環(huán)結(jié)束，交換節(jié)點(diǎn)的數(shù)和相遇點(diǎn)的數(shù)
array[low] = array[i];
array[i] = pivot;
//數(shù)組“分兩半”,再重復(fù)上面的操作
quickRow(array,low,i - 1);
quickRow(array,i + 1,high);
}
}快排操作的步驟：
目前市面上有許多種排序，且都已經(jīng)經(jīng)過調(diào)試給出了API，因此，除非有特殊要求，否則不需要我們自定義排序方法，可以直接使用別人已經(jīng)給出的排序方法。
之所以學(xué)習(xí)排序是為了熟練的對數(shù)組元素進(jìn)行操作，了解一些排序算的基本原理。
Arrays 類包含用于操作數(shù)組的各種方法，主要有以下幾種：
| 方法名 | 說明 |
|---|---|
| public static String toString?(int[] a) | 返回指定數(shù)組的內(nèi)容的字符串表示形式 |
| public static void sort?(int[] a) | 按照數(shù)字順序排列指定的數(shù)組 |
| public static int binarySearch?(int[] a, int key) | 利用二分查找返回指定元素的索引 |
由此可見，關(guān)于數(shù)組的不少操作都有現(xiàn)成的，且提供了API可以快捷的調(diào)用，因此，最開始的那一個(gè)例題，也就有了更簡單的實(shí)現(xiàn)方法：
public class IntString {public static void main(String[] args) {String str = "91 27 46 38 50";
String[] split = str.split(" ");
int[] number = new int[split.length];
for (int i = 0; i< number.length; i++) {number[i] = parseInt(split[i]);
}
Arrays.sort(number);//排序
System.out.println(Arrays.toString(number));//轉(zhuǎn)換為字符串輸出
}
}
//[27, 38, 46, 50, 91]Arrays類中也有構(gòu)造方法，只不過構(gòu)造方法被private修飾，外界無法使用，所以幫助文檔中也看不到。
不過通過查看源碼，我們可以找到如下的內(nèi)容：
private Arrays() {}
說明Arrays類的設(shè)計(jì)是采用的常用的工具類的設(shè)計(jì)思想——構(gòu)造方法私有，成員都用static修飾。
你是否還在尋找穩(wěn)定的海外服務(wù)器提供商？創(chuàng)新互聯(lián)www.cdcxhl.cn海外機(jī)房具備T級流量清洗系統(tǒng)配攻擊溯源，準(zhǔn)確流量調(diào)度確保服務(wù)器高可用性，企業(yè)級服務(wù)器適合批量采購，新人活動首月15元起，快前往官網(wǎng)查看詳情吧
