JAVA基础再回首（十一）——数组高级(冒泡排序和选择排序)、Arrays类、基本类型包装类、Integer类

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 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
我在群里等你。