JAVA基礎再回首（十一）——數組高級(冒泡排序和選擇排序)、Arrays類、基本類型包裝類、Integer類
寫完了博客，我又到文章的開頭和你們說點題外話。
昨天說了所謂情商高，就是懂得好好說話。今天我還想說一下，所謂情商高，就是要有分寸感。這算是昨天的續集吧。
所謂情商高，就是要把別人放在心上。
觀察我們身邊那些特別給人好感的人，也都有一種讓人舒服的分寸感。很多時候，幽默和刻薄就在一線之間，牛逼的人可以掌握一種微妙的平衡。
我們可能做不到那麼高級，但至少可以學習一些基本規則，起碼做到不讓對方難堪吧。
- 不要覺得混熟了，就可以隨便開玩笑，每個人的底線不一樣。
- 當別人自黑的時候，不要去附和。
- 不必對異性拘謹，但要保持界限。（大家都是成年人了，要懂得友情是有邊界的，隨意越界的人，真的是人品有問題。）
- 既然你說了“隨便”，讓別人做了決定，那你就不要瞎比比。
- 不要隨便評價別人的生活方式。（生活方式是沒有標準答案的。我很贊同當年明月的話，所謂成功，就是以自己的方式過一生。每個人都有選擇自己生活方式的權利，不要把你的價值觀強加給別人。）
- 不要好爲人師，在別人做事的時候指手畫腳。（既然你選擇了讓別人做，就尊重對方，信任對方，不然的話，你行你上啊！）
- 你提了問，別人給了一個模糊的答案，就不要再追問了。
- 講自己狀況的時候，儘量避開對方的痛點。
- 其實，說話處事有沒有分寸感，不取決於你的感受，而取決於對方的感受。
希望你在人生的道路中，你收穫的不僅僅只是技術，還有更多你想要的，但是沒有付出，那來收穫。記得天道酬勤，既然不能改變世界，那就改變自己吧！讓自己強大。
我們繼續來學習java的常用類
數組高級(排序)
- 排序
- 冒泡排序
- 相鄰元素兩兩比較，大的往後放，第一次完畢，最大值出現在了最大索引處.同理，即可得到排好序的數組
- 選擇排序
- 從0索引開始，依次和後面元素比較，小的往前放，第一次完畢，最小值出現在了最小索引處
- 冒泡排序
我們來一起做一個練習
//數組排序之冒泡排序
public class ArrayDemo {
public static void main(String[] args) {
// 定義一個數組
int[] arr = { 24, 69, 80, 57, 13 };
System.out.println("排序前：");
printArray(arr);
bubbleSort(arr);
System.out.println("排序後：");
printArray(arr);
// 遍歷功能
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ", ");
}
}
System.out.println("]");
}
//冒泡排序代碼
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個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。
- 在第二趟：仍從第一對數開始比較（因爲可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數）將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重複以上過程，直至最終完成排序。
//數組排序之選擇排序
//我們在上面的Demo中，只需用把上面冒泡排序的方法換成下面我們選擇排序的方法
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[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}可以看到輸出結果和上面的結果相同。
這個思路很簡單，把第一個元素依次和後面的所有元素進行比較。第一次結束後，就會有最小值出現在最前面。依次類推
我們一起在做一個練習題。 把字符串中的字符進行排序。舉例：”dacgebf”。結果：”abcdefg”
//首先我們將一個字符串"dacgebf"經過排序後成爲"abcdefg"下面先來分析一下
//1.定義一個字符串 2.把字符串轉換爲字符數組 3.把字符數組進行排序 4.把排序後字符數組轉成字符串 5.輸出最後的字符串 思路明確，趕緊書寫
public class ArrayTest {
public static void main(String[] args) {
// 定義一個字符串
String s = "dacgebf";
// 把字符串轉換爲字符數組
char[] chs = s.toCharArray();
// 把字符數組進行排序
bubbleSort(chs);
//把排序後的字符數組轉成字符串
String result = String.valueOf(chs);
//輸出最後的字符串
System.out.println("result:"+result);
}
// 冒泡排序
public static void bubbleSort(char[] chs) {
for (int x = 0; x < chs.length - 1; x++) {
for (int y = 0; y < chs.length - 1 - x; y++) {
if (chs[y] > chs[y + 1]) {
char temp = chs[y];
chs[y] = chs[y + 1];
chs[y + 1] = temp;
}
}
}
}
}
是不是感覺在這個Demo中，思路明確了，直接用我們上面的那個冒泡方法就可以完成我們想要的結果了。
所以冒泡排序很有必要掌握，因爲我以前在面試的時候就遇到過，要求寫出冒泡排序。
Arrays類概述及其常用方法
- Arrays類概述
- 針對數組進行操作的工具類。
- 提供了排序，查找等功能。
- 成員方法
- public static String toString(int[] a)：把數組轉成字符串
- public static void sort(int[] a)：對數組進行排序
- public static int binarySearch(int[] a,int key)：二分查找
public class ArraysDemo {
public static void main(String[] args) {
// 定義一個數組
int[] arr = { 24, 69, 80, 57, 13 };
// public static String toString(int[] a) 把數組轉成字符串
System.out.println("排序前：" + Arrays.toString(arr));
// public static void sort(int[] a) 對數組進行排序
Arrays.sort(arr);//底層是快速排序，瞭解就可以了
System.out.println("排序後：" + Arrays.toString(arr));
// [13, 24, 57, 69, 80]
// public static int binarySearch(int[] a,int key) 二分查找
System.out.println("binarySearch:" + Arrays.binarySearch(arr, 57));
System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));
}
}輸出結果：
基本類型包裝類概述
- 將基本數據類型封裝成對象的好處在於可以在對象中定義更多的功能方法操作該數據。
- 常用的操作之一：用於基本數據類型與字符串之間的轉換。
- 基本類型和包裝類的對應
- byte —-Byte
- short —- Short
- int —- Integer
- long —- Long
- float —- Float
- double —- Double
- char —- Character
- boolean —- Boolean
有了基本類型包裝類我們就可以調方法、調成員變量了，方便了很多。
上車上車，我要繼續開車了。
Integer類概述及其構造方法
- Integer類概述
- Integer 類在對象中包裝了一個基本類型 int 的值
- 該類提供了多個方法，能在 int 類型和 String 類型之間互相轉換，還提供了處理 int 類型時非常有用的其他一些常量和方法
- 構造方法
- public Integer(int value)
- public Integer(String s)
- 注意：這個字符串必須是由數字字符組成
public class IntegerDemo {
public static void main(String[] args) {
// 方式1
int i = 100;
Integer ii = new Integer(i);
System.out.println("ii=" + ii);//ii=100
// 方式2
String s = "100";
Integer iii = new Integer(s);
System.out.println("iii=" + iii);//iii=100
}
}我們開車去看int類型和String類型的相互轉換
- int 轉 String
- String.valueOf(number)
- String 轉 int
- Integer.parseInt(s)
知道了開車技巧，還不去開兩圈
public class IntegerDemo {
public static void main(String[] args) {
// int -- String
int number = 100;
// 方式1
String s1 = "" + number;
System.out.println("s1:" + s1);
// 方式2
String s2 = String.valueOf(number);
System.out.println("s2:" + s2);
// 方式3
// int -- Integer -- String
Integer i = new Integer(number);
String s3 = i.toString();
System.out.println("s3:" + s3);
// 方式4
// public static String toString(int i)
String s4 = Integer.toString(number);
System.out.println("s4:" + s4);
System.out.println("-----------------");
// String -- int
String s = "100";
// 方式1
// String -- Integer -- int
Integer ii = new Integer(s);
// public int intValue()
int x = ii.intValue();
System.out.println("x:" + x);
//方式2
//public static int parseInt(String s)
int y = Integer.parseInt(s);
System.out.println("y:"+y);
//方式3
int z = Integer.valueOf(s);
System.out.println("z:"+z);
}
}是不是很意外，竟然有這個多種方法可以讓int和String互相轉換。
所以我們在開發中要善於總結，你總會有收穫的。
輸出結果就不說了，都一樣。
其實上面那些方法都屬於Integer的成員方法
- Integer類成員方法
- public int intValue()
- public static int parseInt(String s)
- public static String toString(int i)
- public static Integer valueOf(int i)
- public static Integer valueOf(String s)
在Integer類的成員方法中不僅僅只有上面5中，還有以下幾種：
- 常用的基本進制轉換
- public static String toBinaryString(int i)
- public static String toOctalString(int i)
- public static String toHexString(int i)
- 十進制到其他進制
- public static String toString(int i,int radix)
- 其他進制到十進制
- public static int parseInt(String s,int radix)
- public static int parseInt(String s,int radix)
不多說，開車練習
public class IntegerDemo {
public static void main(String[] args) {
// 十進制到二進制，八進制，十六進制
System.out.println(Integer.toBinaryString(100));
System.out.println(Integer.toOctalString(100));
System.out.println(Integer.toHexString(100));
System.out.println("-------------------------");
// 十進制到其他進制
System.out.println(Integer.toString(100, 10));
System.out.println(Integer.toString(100, 2));
System.out.println(Integer.toString(100, 8));
System.out.println(Integer.toString(100, 16));
System.out.println(Integer.toString(100, 5));
System.out.println(Integer.toString(100, 7));
System.out.println(Integer.toString(100, -7));
System.out.println(Integer.toString(100, 70));
System.out.println(Integer.toString(100, 1));
System.out.println(Integer.toString(100, 17));
System.out.println(Integer.toString(100, 32));
System.out.println(Integer.toString(100, 37));
System.out.println(Integer.toString(100, 36));
System.out.println("-------------------------");
//其他進制到十進制
System.out.println(Integer.parseInt("100", 10));
System.out.println(Integer.parseInt("100", 2));
System.out.println(Integer.parseInt("100", 8));
System.out.println(Integer.parseInt("100", 16));
System.out.println(Integer.parseInt("100", 23));
}
}輸出結果：
![這裏寫圖片描述]()
從上面的結果中我們可以得到一個結論：
那就是進制的範圍：2-36
爲什麼呢？因爲在進制中的數是由，0~9，a~z組成的，剛好36個。
今天的車就開到這裏，讓我們休息一下，明天再戰。
歡迎有興趣的同學加我朋友的QQ羣：555974449
我在羣裏等你。
