java复习之数组

今天简单复习数组的几个常用方法

1. 数组的填充
   （1）fill(int[] a,int value）
   a:表示要填充的数组，value：表示要填充的值
   （2）fill(int [] a,int fromIndex,int toIndex,int value)
   Arrays.fill(…)

2. 对数组进行排序
   Arrays.sort(Object oj)
   Object:指定排序的数组名，排序顺序按字典顺序

3. 数组的复制
   （1）CopyOf(array arr,int newLength):复制数组到指定的长度
   arr:要复制的数组
   newLength：新数组的长度

   （2） CopyOfRange（Array arr，int fromIndex，int toIndex）：将指定数组的长度复制到新数组中，返回一个新数组

4. 数组查询
   （1）数组查询
   binarySearch（Object[] a,Object key）
   a:要查找的数组，key:要查找的值
   （2）binarySearch（Object[] a,int formIndex,int toIndex,Object key）:在指定数组中查询每个范围的某个值
   注意：查询方法必须在排序方法之前调用，先排好序，再根据顺序查询

5. 几种数组排序算法
   （1）冒泡排序
   基本思想：将相邻两个数进行对比，如果前面的数大于后面的数，则进行位置的交换

代码：

public class BubbleSort {

    public static void main(String[] args) {
        int[] array={8,10,6,3,9,7};
        BubbleSort ma=new BubbleSort();
        ma.sort(array);
    }


    public void sort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i; j++) {
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

        for (int i : arr) {
            System.out.println(">"+i);
        }
    }


}

（2）直接选择排序
基本思想：指定排序位置，将指定位置的元素，与其他元素进行对比，如果满足条件，则进行位置的交换
代码：

public class selectSort {
    public static void main(String[] args) {
        int[] arrays = { 63, 4, 24, 1, 3, 15 };
        selectSort select = new selectSort();
        select.sort(arrays);
    }

    public void sort(int[] arr) {

        for (int i = 1; i < arr.length; i++) {
            int index = 0;
            for (int j = 1; j < arr.length - i; j++) {
                if (arr[j] > arr[index]) {
                    index = j;
                }
            }
            int temp = arr[arr.length - i];
            arr[arr.length - i] = arr[index];
            arr[index] = temp;
        }
        // 输出顺序
        for (int i : arr) {
            System.out.println(">" + i);
        }
    }
}

（3）反转排序
基本思想：顾名思义，最后一个与第一个，倒数第二与第二……依次类推

代码：

public class ReverseSort {

    public static void main(String[] args) {
        int[] arr = { 10, 9, 11, 45, 67,33};
        ReverseSort rev = new ReverseSort();
        rev.sort(arr);
    }

    public void sort(int[] arr) {
        // 显示初始数组顺序
        System.out.print("翻转前的数据");
        showArr(arr);
        int temp;
        int len = arr.length;
        for (int i = 0; i < len / 2; i++) {
            temp = arr[i];
            arr[i] = arr[len - 1 - i];
            arr[len - 1 - i] = temp;
        }
        // 数组翻转后的顺序
        System.out.print("翻转后的数据");
        showArr(arr);

    }

    public void showArr(int[] arr) {
        for (int i : arr) {
            System.out.print(">" + i);
        }

    }
}

更多数组内容，以后继续研究