选择排序：
                每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
                每次比较仅做一次交换。
                public static void selectionSort(int[] arr) {
                        // 外循环控制比较的次数
                        for (int i = 0; i < arr.length - 1; i++) {
                                // 定义变量，用于记录每次比较中最小值的索引
                                int mark = i;
                                // 内循环控制每次比较中，元素比较的过程。每次需要比较的数据是逐渐减少的。
                                for (int j = i + 1; j < arr.length; j++) {
                                        if (arr[mark] > arr[j]) {
                                                mark = j;
                                        }
                                }
                                // 判断，如果最小值不是每次比较时的第一个，将这个最小值交换到每次比较的起始索引处。
                                if (mark != i) {
                                        int temp = arr[i];
                                        arr[i] = arr[mark];
                                        arr[mark] = temp;
                                }
                        }
                }
       
        练习：对字符串中字符进行自然排序。
                思路：
                        A:把字符串转换成字符数组。
                        B:对字符数组进行排序。
                        C:把排序后的字符数组转换成字符串。
                // main method
                main {
                        String s = "basckd";
                        // A:
                        char[] chs = s.toCharArray();
                        // B:
                        bubbleSort(chs);
                        // C:
                        String result = new String(chs); // String.copyValueOf();  // String.valueOf();
                }
                // 排序方法(采用冒泡排序)
                public static void bubbleSort(char[] chs) {
                        for (int i = 0; i < chs.length - 1; i++) {
                                for (int j = 0; j < chs.length - 1 - i; j++) {
                                        if (chs[j] > chs[j + 1]) {
                                                char temp = chs[j];
                                                chs[j] = chs[j + 1];
                                                chs[j + 1] = temp;
                                        }
                                }
                        }
                }

3、数组查找。
        问题提出：        已知int[] arr = {37, 92, 54, 18, 76};
                                求元素92索引是多少？
        普通查找：遍历数组，把数组中的元素与给定的值依次进行比较，一旦查找到，返回该元素索引，如果没有，返回-1.
                public static void commonSearch(int[] arr, int target) {
                        for (int i = 0; i < arr.length; i++) {
                                if (arr[i] == target) {
                                        return i;
                                }
                        }
                        return -1;
                }
       
        思考：效率问题。如果数组较大，想查找的元素位于数组索引较大处，要将数组全部遍历才能找到。
       
        折半查找(二分查找)：
                前提：数组必须有序。
                public static int getIndex(int[] arr, int value) {
                        int maxIndex = arr.length - 1;
                        int minIndex = 0;
                        int midIndex = (maxIndex + minIndex) / 2;

                        while (arr[midIndex] != value) {
                                if (arr[midIndex] > value) {
                                        maxIndex = midIndex - 1;
                                } else if (arr[midIndex] < value) {
                                        minIndex = midIndex + 1;
                                }
                                if (minIndex > maxIndex) {
                                        return -1;
                                }
                                midIndex = (maxIndex + minIndex) / 2;
                        }
                        return midIndex;
                }
               
4、Arrays工具类，对数组进行操作的工具类。
        常用功能就是排序和查找。
        public static String toString(数组):把数组变成字符串。
        public static void sort(数组):对数组进行排序。
        public static int binarySearch(int[] arr,int value):二分查找
       
5、System的方法
        (1)系统类，提供了静态的变量和方法供我们使用。
        (2)成员方法：
                public static void exit(int value):退出jvm，非0表示异常退出。
                public static long currentTimeMillis():返回当前系统时间的毫秒值。和1970 年 1 月 1 日午夜之间的时间差
                        -- 常用来测试某些代码执行的时间长度。
                public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
                        -- 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
                从数组src中复制一个数组(从索引为srcPos处开始，长度为length)，把这个数组复制到目标数组dest中，替换目标数组dest中从索引destPos开始，长度为length的数组元素。
                注意角标越界异常。

6、StringBuffer 字符串缓冲类。字符个数可以发生改变的字符串类。
        与String区别：
                String一旦被赋值，值不能发生改变。而StringBuffer，值还可以改变。
        为什么呢?
                StringBuffer采用的是缓冲区机制。
                一开始，首先开辟一些空间，然后，随着数据的增多，还可以继续开辟空间。这些操作针对的是同一个对象。
       
        构造方法：
                A: StringBuffer()
                B: StringBuffer(int capacity)
                C: StringBuffer(String str)
        成员方法：
                        public int length()：字符个数。实际长度。
                        public int capacity():字符容量。理论长度。
                A：添加功能
                        public StringBuffer append(int i); -- 在结尾处添加
                        public StringBuffer insert(int index, int i); -- 在指定索引处添加
                B：删除功能
                        StringBuffer deleteCharAt(int index); -- 删除指定位置处的字符
                        StringBuffer delete(int start, int end); -- 删除指定开始位置和结束位置之间的字符
                C: 替换功能
                        StringBuffer replace(int start, int end, String str); -- 将指定范围内（索引从start到end，左闭右开）的字符串替换为指定字符串str
                D: 截取功能
                        public String substring(int start); -- 从索引为start处截取到结尾
                        public String substring(int start, int end); -- 从索引为start，截取到end。左闭右开。
                E: 反转功能
                        public StringBuffer reverse(); -- 将此字符序列用其反转形式取代
               
        补充：关于String类的面试题。
                1.        
                public static void main(String[] args) {
                        String s = "abc";
                        change(s);
                        System.out.println(s);
                }
                public static void change(String s) {
                        s += "hello";
                }
                注：基本类型 -- 形式参数改变不影响实际参数。
                        引用类型 -- 形式参数改变直接影响实际参数。
                        但是，字符串是特殊的引用类型，实参传递到形参时，实际上是把值传递给了形参。
               
                -- 如果是StringBuffer.则打印的是abchello。StringBuffer容量可变。
               
                2. 字符串拼接问题
                public static void main(String[] args) {
                        String s1 = "a";
                        String s2 = "b";
                        String s3 = "ab";
                        System.out.println(s3 == s1 + s2); // false
                        System.out.println(s3 == "a" + "b"); // true
                }
                注：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的。
                        JVM对于字符串常量的"+"号连接，在程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值。

7、基本类型的包装类。
        (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 num);
                B:Integer i = new Integer(String s);
                        注意：s必须是一个由数字字符组成的字符串。
        (4)String和int类型的转换
                A:String -- int
                        Integer:
                                public static int parseInt(String s)
                B:int -- String
                        Integer:
                                public static String toString(int i)
                        String:
                                public static String valueOf(int i)
        (5)JDK5以后的新特性
                A:自动装箱        基本类型--引用类型
                B:自动拆箱        引用类型--基本类型

                举例：
                        Integer i = 100;
                        i += 200;
        (6)byte常量池面试题。
               
                Integer i1 = new Integer(127);
                Integer i2 = new Integer(127);
                System.out.println(i1 == i2);  // false
                System.out.println(i1.equals(i2));  // true

                System.out.println("--------");

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

                System.out.println("--------");

                Integer i7 = 127;
                Integer i8 = 127;
                System.out.println(i7 == i8); // true
                System.out.println(i7.equals(i8)); // true

                结论：byte范围内的值（-128 ~ 127），java提供了一个常量池。直接赋值给Integer，是从常量池里面获取的。
8、常用API
        (1) Object
                -- toString()
                        为了让对象显示的有意义，一般重写此方法。
                -- equals()
                        默认比较地址值。一般按实际需求重写此方法，比较有意义的值。
        (2) Math
                -- floor()
                        小于等于参数的最大整数
                -- ceil()
                        大于等于参数的最小整数
                -- round()
                        四舍五入
                -- random()
                        返回[0.0 - 1.0)的随机数
                -- pow()
                        x的y次方
                -- sqrt()
                        平方根
        (3) Random
                -- nextInt(int n)
                        返回[0 - n)的随机整数
        (4) Scanner
                -- nextInt()
                        获取int类型
                -- next()
                        获取下一个完整标记
                -- nextLine()
                        获取String类型一行
        (5) String
                判断、获取、转换、其他（替换、切割）
               
        (6) StringBuffer
                -- append()
                        在结尾处添加
                -- insert()
                        在指定索引处添加
                -- reverse()
                        反转
        (7) System
                -- exit()
                        退出jvm，非0表示异常退出。               
        (8) Arrays
                -- sort()
                        排序方法
                -- binarySearch()
                        二分查找
        (9) Integer
                -- parseInt(String str)
                        String 转换成 int

总结的好详细