转载

从0开始学JAVA(4）数组

数组的初始化

数组的动态初始化(数组初始化完成后，数组的元素为对应的类型的默认是)
- 数据类型数组名称[] = new 数据类型[数组长度];
```
int i[] = new int[10];//10个元素默认值都为0
```
- 数据类型 []数组名称 = new 数据类型[数组长度];
```
int []i = new int[10];
```
数组的静态初始化（数组初始化完成时就定义好了每个元素的内容）
- （ 不推荐 ）简单模式：数据类型 []数组名称 = {元素1,元素2，元素3...}
```
int i[] = {1,2,3,4};
int []a = {4,3,2,1};
```
- （推荐）完整模式：数据类型 []数组名称 = new 数据类型[]{元素1,元素2，元素3...}
```
int i[] =new int[] {1,2,3,4};
    int []a = new int[] {4,3,2,1};
```

数组元素的访问

开发人员可以使用角标进行数组元素的访问，角标从0开始往后顺序叠加，所以角标最大值为数组的长度-1。

例如

int arr[] = new int[]{1,2,3}

开发人员想要字节获取数组中的第二个数据，则可以使用如下代码获取

int result = arr[1]

当然也可以进行修改

arr[1]=10

请注意，获取数组数据时，下标不能超过数组长度-1，如果超过会出现在“ArrayIndexOutOfBoundSException” 即数组越界异常。

数组长度可以通过数组名称.length获取。如：

int arrLength = arr.length;

数组排序问题分析

冒泡算法

分析

分2层循环，内层循环不难发现是为了把最大的值排序到数组的最后一个元素。

那么同理，如果要按照顺序对数组进行排序，则需要执行多次该操作，依次排列元素的值。

由于要执行最少的次数得到正确的结果，所以对外层循环进行优化，即，每次排序之后由于最大值已经在数组的最后一个下标上，那么再次排序时，第二大的值只需要到倒数第二个下标便不必再进行循环了。所以在内层循环循环时，只需要循环arr.length-j-1则足够了。

思路是：

第一步，将最大值找出来并置于最后

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

第二步考虑，按照数组的长度再循环一次必定能排出最大值。则在外层包一个循环

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

第三步，考虑到由于每次内层循环执行一个完整的循环之后，就能将一个元素按照大小排列出来，那么进行优化，希望能以最少的循环次数就能得到结果。所以最终代码就如下

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

数组反转

即将数组的元素顺序倒置。2种方法

新建一个数组，倒序存储数组，代码如下：

public static int[] reverseArrary(int[] data) {
        int[] newArr = new int[data.length];
        for (int j = 0 ; j < data.length; j++) {
            newArr[newArr.length-j-1] = data[j];
        }
        return newArr;
    }

倒置原数组的元素

public static void reverseArray2(int[] data) {
        int center = data.length/2; //确定转换的次数,无需判断奇数或偶数
        int head = 0;
        int end = data.length-1;
        for (int i = 0; i < center; i++) {
            int temp = data[head];
            data[head] = data[end];
            data[end] = temp;
            head++;
            end--;

        }
    }

原文 https://segmentfault.com/a/1190000020191800

正文到此结束