JavaEE-05、13-Java中数组的定义,排序和查找,Array类的引入

数组定义:

　　存储同一种数据类型的多个元素的集合,也可以看成是一个容器.

数组的格式:

　　格式1:　　数组类型[] 数组名　　int[] a　　//一般采用这种方式定义

　　格式2:　　数据类型 数组名[]　　int a[]　　//早期使用这种方式定义

数组初始化:

　　所谓初始化,就是为数组中的数组元素分配内存空间,并为每个数组元素赋值

　　　　动态初始化:初始时只指定数组长度,由系统为数组分配初始值

　　　　　　格式:　　数组类型[] 数组名 = new 数据类型[数组长度];　　

　　　　　　　　　　int[] a = new int[3];

　　　　静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度

　　　　　　格式:　　数组类型[] 数组名 = new 数据类型[]{元素1,元素2,......};　　

　　　　　　　　　　int[] a = new int[]{3,4,5,6};

　　　　　　　　　　简化写法:int[] a = {3,4,5,6};

　　注:Java中的数组必须先初始化才能使用.

数组遍历:

　　依次输出数组中的每一个元素.

　　遍历数组的方法:　

public class ArrayTest {
    public static void main(String[] args) {
        int[] arr= {11,22,33,44,55};
        
        for(int x=0;x<arr.length;x++) {
            if(x==arr.length-1) {//这是最后一个元素
                System.out.println(arr[x]);
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
}

数组获取最值:

　　求取元素随机排序的数组中的最大值或者最小值.　

public class ArrayTest2 {
    public static void main(String[] args) {
        int[] arr = { 34, 98, 10, 25, 67 };

        int max = arr[0];
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > max) {
                max = arr[x];                
            }
        }
        System.out.println("最大值是:"+max);
        
        int min=arr[0];
        for(int x=1;x<arr.length;x++) {
            if(arr[x]<min) {
                min=arr[x];
            }
        }
        System.out.println("最小值是:"+min);
    }
}

数组逆序:

　　就是把数组中的元素进行对调.　

public class ArrayTest3 {
    public static void main(String[] args) {
        int[] arr = { 12, 98, 50, 34, 76 };
        reverse(arr);
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.println(arr[x]);
            } else {
                System.out.print(arr[x] + ", ");
            }
        }
    }

    public static void reverse(int[] arr) {
        for (int x = 0; x < arr.length / 2; x++) {//注意这里的循环次数上限,长度的一半即可,否则又重复了一次对调
            int temp = arr[x];
            arr[x] = arr[arr.length - 1 - x];
            arr[arr.length - 1 - x] = temp;
        }
    }
}

数组元素查找:

　　在指定数组中查找指定元素的索引.　

public class ArrayTest5 {
    public static void main(String[] args) {
        int[] arr= {200,250,38,888,444};
        
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入需要查找的数:");
        int num=sc.nextInt();
        if(num>0) {
        for(int i=0;i<arr.length;i++) {
            if(num==arr[i]) {
                System.out.println("该数字在数组中的索引是:"+i);
                break;
            }
        }
        System.out.println("该数字在数组中不存在!");
        }else {
            System.out.println("请输入正确的数字!");
        }
    }
}

 数组排序:

　　　　1.冒泡排序

　　　　　　思想:相邻元素两两比较,大的往后放，比完一轮后，最大数会被放到末尾。

　　　　　　第二轮比较时，排除末尾的那个最大数，从剩下的数中再次选出最大数，直到排到第一个数为最大。

　　　　　　 动图说明：

 　　　　　　代码：

    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;
                }
            }
        }
    }

 

　　　　2.选择排序

　　　　　　思想：将第1个元素依次与后面的元素进行比较，遇到比第1个元素小的元素，双方进行位置对调。

　　　　　　　　　然后继续在剩余元素中查找最小值，将其放到已排序的数组中的末尾。

　　　　　　　　　重复以上步骤，直到所有元素排序完成。

　　　　　　动图说明：

 　　　　　　代码：

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[y];
                    arr[y] = arr[x];
                    arr[x] = temp;
                }
            }
        }
    }

　　

　　　　举例：利用上面学到的两种排序，将字符串中的字符进行排序　　

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);//遍历冒泡排序后的字符数组
        selectSort(chs);//使用选择排序
        System.out.println(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;
                }
            }
        }
    }
    
    public static void selectSort(char[] chs) {
        for (int x = 0; x < chs.length - 1; x++) {
            for (int y = x + 1; y < chs.length; y++) {
                if (chs[y] < chs[x]) {
                    char temp = chs[y];
                    chs[y] = chs[x];
                    chs[x] = temp;
                }
            }
        }
    }
}

 二分查找：

　　前面已经介绍过数组元素的查找，是从索引0开始一个一个的查找，直到找到所需的元素为止，这种方法效率较低。

　　而二分查找是一种效率更高的高级查找，代码如下：

　　二分查找的重要前提：元素必须是有序的。(没有经过排序的元素是不能乱用二分查找的)

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = { 11, 22, 33, 44, 55, 66, 77 };
        int index = getIndex(arr, 9);
        System.out.println("指定值的索引是：" + index);
    }

    public static int getIndex(int[] arr, int value) {
        int max = arr.length - 1;
        int min = 0;
        int mid = (min + max) / 2;

        while (arr[mid] != value) {
            if (arr[mid] > value) {
                max = mid - 1;
            } else if (arr[mid] < value) {
                min = mid + 1;
            }
            /*加入判断：
             * 两种情况，当要求的值特别小时，max值会一直变小，直到比min值还小；
             * 当要求的值特别大时，min值会一直变大，直到比max值还大。
             * 这两种情况都可以使用条件(min>max)
             */
            if(min>max) {
                return -1;
            }
            mid = (min + max) / 2;
        }
        return mid;
    }
}

 Arrays类的引入：

　　前面我们有说到数组的各种自定义方法，比如遍历、查找、排序，其实这些方法在Arrays类中都有现成的方法可以调用，不需要花时间自己编写。

　　由此可见，Arrays类就是一个针对数组操作的工具类。

　　常用方法：

　　　　排序 sort()，转成字符串 toString()，二分查找 binarySearch()

 　　特殊方法：

　　　　可变参数方法asList()

　　　　格式：public static <T> List<T> asList(T. . . a)：可把数组转成集合

　　注意：asList()虽然可将数组Arrays转成集合List，但转换后的本质还是一个数组，数组最大的特点就是长度固定。

　　　　　所以，转换后的List集合不能增删(即不能调用add和remove方法)，只能修改(调用set方法)

public class ArrayDemo {
    public static void main(String[] args) {
        List<String> list=Arrays.asList("hello","world","java");
        
        for(String s:list) {
            System.out.println(s);
        }
    }
}