如题：(1)排序
                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索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了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[x];
                                                        arr[x] = arr[y];
                                                        arr[y] = temp;
                                                }
                                        }
                                }
                        }
        (2)查找
                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 binarySearch(int[] arr,int value) {
                                int min = 0;
                                int max = arr.length-1;
                                int mid = (min+max)/2;
                               
                                while(arr[mid] != value) {
                                        if(arr[mid] > value) {
                                                max = mid - 1;
                                        }else if(arr[mid] < value) {
                                                min = mid + 1;
                                        }
                                       
                                        if(min > max) {
                                                return -1;
                                        }
                                       
                                        mid = (min+max)/2;
                                }
                               
                                return mid;
                        }
        (3)Arrays工具类
                A:是针对数组进行操作的工具类。包括排序和查找等功能。
                B:要掌握的方法(自己补齐方法)
                        把数组转成字符串：
                        排序：
                        二分查找：
        (4)Arrays工具类的源码解析
        (5)把字符串中的字符进行排序
                举例：
                        "edacbgf"
                        得到结果
                        "abcdefg"

整理的不错，赞一个！