java基础-数组

数组是一个固定长度的，包含了相同类型数据的 容器

1.创建数组

int[] a：声明了一个数组变量。

[]：表示该变量是一个数组。

int：表示数组里的每一个元素都是一个整数。

a：是变量名。

但是，仅仅是这一句声明，不会创建数组

有时候也会写成int a[]；没有任何区别

创建数组的时候，要指明数组的长度。
new int[5]

public class HelloWorld {
    public static void main(String[] args) {
        int[] a;// 声明一个引用
        a = new int[5];// 创建一个长度是5的数组，并且使用引用a指向该数组

        a[0] = 1; // 下标0，代表数组里的第一个数
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;
        a[4] = 5;

        int[] b = new int[5]; // 声明的同时，指向一个数组
        System.out.println("数组b的长度：" + b.length); // 打印数组的长度
    }
}

2.for循环，遍历数组找出最小的一个值

public class HelloWorld {
    public static void main(String[] args) {
        int[] a;// 声明一个引用
        a = new int[5];// 创建一个长度是5的数组，并且使用引用a指向该数组

        a[0] = (int) (Math.random() * 100); // 下标0，代表数组里的第一个数
        a[1] = (int) (Math.random() * 100);
        a[2] = (int) (Math.random() * 100);
        a[3] = (int) (Math.random() * 100);
        a[4] = (int) (Math.random() * 100);

        System.out.println("数组中的各个随机数是:");
        for (int i = 0; i < a.length; i++)
            System.out.println(a[i]);

        int c = a[0];
        for (int i = 0; i < a.length; i++) {
            System.out.println("数组中的a[" + i + "]随机数是:" + a[i]);
            if (c > a[i]) {
                c = a[i];
            }
        }

        System.out.println("数组中最小的一个值: " + c);
    }
}

3.分配空间，赋值

public class HelloWorld {
    public static void main(String[] args) {
        // 写法一： 分配空间同时赋值
        int[] a = new int[] { 100, 102, 444, 836, 3236 };

        // 写法二： 省略了new int[],效果一样
        int[] b = { 100, 102, 444, 836, 3236 };

        // 写法三：分配了长度是5的数组，但是没有赋值
        int[] c = new int[5];

        // 没有赋值，那么就会使用默认值
        // 作为int类型的数组，默认值是0
        System.out.println(c[0]);

        // 进行赋值
        c[0] = 100;
        c[1] = 102;
        c[2] = 444;
        c[3] = 836;
        c[4] = 3236;
    }
}

4.数组反转

public class HelloWorld {
    public static void main(String[] args) {
        // 声明并赋值数组
        int[] a = new int[] { 11, 2, 44, 577, 54, 4 };

        printArray(a);
        reverseArray1(a);
        printArray(a);

        reverseArray2(a);
        printArray(a);
    }

    // 使用for实现对数组的反转
    public static void reverseArray1(int[] a) {
        for (int i = 0; i < a.length / 2; i++) { // 注意i不可以等于a.length
            swap(a, i, a.length - 1 - i);
        }
    }

    // 交换方法--提高代码重用性
    public static void swap(int[] a, int x, int y) {
        int temp = a[x];
        a[x] = a[y];
        a[y] = temp;
    }

    // 遍历打印数组
    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println("
-----------"); // 可见java里也是可以使用 
 符的，用于换行
    }

    // 使用while反转数组元素
    public static void reverseArray2(int[] a) {
        int i = 0;
        while (i < a.length / 2) {
            swap(a, i, a.length - 1 - i);
            i++; // 注意i不可以写在上面
        }
    }
}

5.排序

1.选择法排序

把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来比较完后，第一位就是最小的然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来比较完后，第二位就是第二小的，以此类推。

2.冒泡法排序

第一步：从第一位开始，把相邻两位进行比较 如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的 第二步： 再来一次，只不过不用比较最后一位 以此类推

public class HelloWorld {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = { 9, 4, 7, 1, 3, 8, 2, 5, 6 };
        HelloWorld sort = new HelloWorld();
        sort.sort1(a);
        System.out.println();
        sort.sort2(a);

    }

    // 选择排序
    void sort1(int[] a) {
        int j;
        int i = 0;
        for (; i < a.length - 1; i++) {
            for (j = i + 1; j < a.length; j++) {

                if (a[i] < a[j]) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
        for (int d = 0; d < a.length; d++) {
            System.out.print(a[d] + " ");
        }
    }

    // 冒泡排序
    void sort2(int[] a) {
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length - i - 2; j++) {
                if (a[j + 1] > a[j]) {
                    int temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;
                }
            }
        }
        for (int d = 0; d < a.length; d++) {
            System.out.print(a[d] + " ");
        }
    }
}

6.增强型for循环

增强型for循环只能用来取值，却不能用来修改数组里的值

public class HelloWorld {
    public static void main(String[] args) {
        int values[] = new int[] { 18, 62, 68, 82, 65, 9 };
        // 常规遍历
        for (int i = 0; i < values.length; i++) {
            int each = values[i];
            System.out.print(each);
            System.out.print("	");
        }

        System.out.println();

        // 增强型for循环遍历
        for (int each : values) {
            System.out.print(each);
            System.out.print("	");
        }

        System.out.println();

        int c = values[0];
        for (int b : values) {
            System.out.print(b);
            System.out.print("	");
            if (b > c) {
                c = b;
            }
        }
        System.out.println("最大" + c);
    }
}

7.复制数组

数组的长度是不可变的，一旦分配好空间，是多长，就多长，不能增加也不能减少。

把一个数组的值，复制到另一个数组中

System.arraycopy(src, srcPos, dest, destPos, length)

src: 源数组
srcPos: 从源数组复制数据的起始位置
dest: 目标数组
destPos: 复制到目标数组的起始位置
length: 复制的长度

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        int b[] = new int[3];// 分配了长度是3的空间，但是没有赋值
        // 通过数组赋值把，a数组的前3位赋值到b数组

        // 方法一： for循环
        for (int i = 0; i < b.length; i++) {
            b[i] = a[i];
        }

        // 把内容打印出来
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
        System.out.println();

        // 方法二: System.arraycopy(src, srcPos, dest, destPos, length)
        // src: 源数组
        // srcPos: 从源数组复制数据的起始位置
        // dest: 目标数组
        // destPos: 复制到目标数组的启始位置
        // length: 复制的长度
        System.arraycopy(a, 0, b, 0, 3);

        // 把内容打印出来
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
    }
}

8.二维数组

//这是一个一维数组, 里面的每一个元素，都是一个基本类型int
int a[] =new int[]{1,2,3,4,5};

//这是一个二维数组，里面的每一个元素，都是一个一维数组；所以二维数组又叫数组的数组。
int b[][] = new int[][]{
   {1,2,3},
   {4,5,6},
   {7,8,9}
};

public class HelloWorld {
    public static void main(String[] args) {
        // 初始化二维数组，
        int[][] a = new int[2][3]; // 有两个一维数组，每个一维数组的长度是3
        a[1][2] = 5; // 可以直接访问一维数组，因为已经分配了空间

        // 只分配了二维数组
        int[][] b = new int[2][]; // 有两个一维数组，每个一维数组的长度暂未分配
        b[0] = new int[3]; // 必须事先分配长度，才可以访问
        b[0][2] = 5;

        // 指定内容的同时，分配空间
        int[][] c = new int[][] { { 1, 2, 4 }, { 4, 5 }, { 6, 7, 8, 9 } };
    }
}

定义一个5X5的二维数组。 然后使用随机数填充该二维数组。 找出这个二维数组里，最大的那个值，并打印出其二维坐标。

public class HelloWorld {
    public static void main(String[] args) {
        int[][] array = new int[5][5];

        // 第一轮嵌套循环，给数组赋值
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                array[i][j] = (int) (Math.random() * 100);
            }
        }

        System.out.println("二维数组的元素为：");
        // 遍历三维数组元素并打印
        // 输出看看
        for (int i = 0; i < array.length; i++) {
            for (int i1 = 0; i1 < array[i].length; i1++) {
                System.out.print(array[i][i1] + "	");
            }
            System.out.println();// 换行
        }

        // 第二轮嵌套循环，找出数组中最大值
        int temp = array[0][0];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (temp < array[i][j]) {
                    temp = array[i][j];
                }
            }
        }
        System.out.println("最大值为：" + temp);
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] == temp) {
                    System.out.println("最大值的坐标为：第" + (i + 1) + "行，第" + (j + 1) + "列");
                }
            }
        }
    }
}

拓展：定义一个5X5X5的三维数组。 然后使用随机数填充该三维数组。 找出这个三维数组里，最大的那个值，并打印出其三维坐标。

public class Arr {
    public static void main(String[] args) {
        int[][][] array = new int[5][5][5];

        // 第一轮嵌套循环，给数组赋值
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                for (int k = 0; k < array.length; k++) {
                    array[i][j][k] = (int) (Math.random() * 100);
                }
            }
        }

        System.out.println("三维数组的元素为：");
        // 遍历三维数组元素并打印
        // 输出看看
        for (int i = 0; i < array.length; i++) {
            for (int i1 = 0; i1 < array[i].length; i1++) {
                for (int i2 = 0; i2 < array[i][i1].length; i2++) {
                    System.out.print(array[i][i1][i2] + "	");
                }
                System.out.println();// 二维换行
            }
            System.out.println();// 三维换行
        }

        // 第二轮嵌套循环，找出数组中最大值
        int temp = array[0][0][0];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                for (int k = 0; k < array[i][j].length; k++) {
                    if (temp < array[i][j][k]) {
                        temp = array[i][j][k];
                    }
                }
            }
        }
        System.out.println("最大值为：" + temp);
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                for (int k = 0; k < array[i][j].length; k++) {
                    if (array[i][j][k] == temp) {
                        System.out.println("最大值的坐标为：第" + (i + 1) + "个二维数组，第" + (j + 1) + "行，第" + (k + 1) + "列");
                    }
                }
            }
        }
    }
}

9.Arrays

Arrays是针对数组的工具类，可以进行 排序，查找，复制填充等功能。 大大提高了开发人员的工作效率。

copyOfRange	数组复制
toString()	转换为字符串
sort	排序
binarySearch	搜索
equals	判断是否相同
fill	填充

数组复制

System.arraycopy(dataType[] srcArray,int srcIndex,int destArray,int destIndex,int length)

srcArray 表示原数组，srcIndex 表示源数组中的起始索引，destArray 表示目标数组，destIndex 表示目标数组中的起始索引，length 表示要复制的数组长度。

public class HelloWorld {
    public static void main(String[] args) {
        // 合并数组
        int[] a = new int[(int) (Math.random() * 5 + 5)];
        int[] b = new int[(int) (Math.random() * 5 + 5)];
        int[] c = new int[a.length + b.length];
        int[] d = new int[a.length + b.length];

        // 给a数组赋值
        System.out.println("a数组内容：");
        for (int i = 0; i < a.length; i++) {
            a[i] = (int) (Math.random() * 10);
            System.out.print(a[i] + " ");
        }

        // 给b数组赋值
        System.out.println(" ");
        System.out.println("b数组内容：");
        for (int i = 0; i < b.length; i++) {
            b[i] = (int) (Math.random() * 10);
            System.out.print(b[i] + " ");
        }

        // 第一种：for循环将a、b数组赋值到c
        for (int j = 0; j < a.length; j++) {
            c[j] = a[j];
        }
        int flag = 0;
        for (int k = a.length; k < a.length + b.length; k++) {
            c[k] = b[flag];
            flag++;
        }
        System.out.println(" ");
        System.out.println("c数组内容：");

        for (int i = 0; i < c.length; i++) {
            System.out.print(c[i] + " ");
        }

        // 第二种：通过System.arraycopy将a、b数组赋值到d;
        // System.arraycopy(src, srcPos, dest, destPos, length)
        System.arraycopy(a, 0, d, 0, a.length);
        System.arraycopy(b, 0, d, a.length, b.length);

        System.out.println(" ");
        System.out.println("d数组内容：");

        // 循环打印d
        for (int d1 : d) {
            System.out.print(d1 + " ");
        }
    }
}

Arrays.copyOf(dataType[] srcArray,int length);

srcArray 表示要进行复制的数组，length 表示复制后的新数组的长度。

Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)

srcArray 表示原数组，startIndex 表示开始复制的起始索引，endIndex 表示终止索引。

与使用System.arraycopy进行数组复制类似的， Arrays提供了一个copyOfRange方法进行数组复制。
不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。
除此之外，需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的。

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };

        // copyOfRange(int[] original, int from, int to)
        // 第一个参数表示源数组
        // 第二个参数表示开始位置(取得到)
        // 第三个参数表示结束位置(取不到)
        int[] b = Arrays.copyOfRange(a, 0, 3);

        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
    }
}

转换为字符串

Arrays.toString(Object[] array)

功能：返回数组的字符串形式

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        String content = Arrays.toString(a);
        System.out.println(content);
    }
}

Arrays.deepToString(Object[][] arrays)

功能：返回多维数组的字符串形式

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int[][] nums = { { 1, 2 }, { 3, 4 } };

        // 返回多维数组的字符串形式，Arrays.deepToString(Object[][] arrays)
        String content = Arrays.deepToString(nums);
        System.out.println(content);
    }
}

排序

Arrays.sort(Object[] array)

功能：对数组按照升序排序

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        System.out.println("排序之前 :");
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("排序之后:");
        System.out.println(Arrays.toString(a));
    }
}

Arrays.sort(Object[] array, int from, int to)

// 第一个参数表示源数组

// 第二个参数表示开始位置(取得到)

// 第三个参数表示结束位置(取不到)

功能：部分排序，对数组元素指定范围进行排序（排序范围是从元素下标为from，到下标为to-1的元素进行排序）

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        System.out.println("排序之前 :");
        System.out.println(Arrays.toString(a));
        Arrays.sort(a,0,3);
        System.out.println("排序之后:");
        System.out.println(Arrays.toString(a));
    }
}

搜索

binarySearch(Object[] a,Object key);

功能：查询元素出现的位置，返回数组下标，否则返回-1。
需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };

        Arrays.sort(a);

        System.out.println(Arrays.toString(a));
        // 使用binarySearch之前，必须先使用sort进行排序
        System.out.println("数字 62出现的位置:" + Arrays.binarySearch(a, 62));
    }
}

binarySearch(Object[] a,int fromIndex,int toIndex,Object key);

a 表示要进行查找的数组，fromIndex 指定范围的开始处索引（包含开始处），toIndex 指定范围的结束处索引（不包含结束处），key 表示要搜索的元素。

数组的比较

Arrays.equals(arrayA, arrayB);

功能：比较两个数组的内容是否一样
第二个数组的最后一个元素是8，和第一个数组不一样，所以比较结果是false

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        int b[] = new int[] { 18, 62, 68, 82, 65, 8 };

        System.out.println(Arrays.equals(a, b));
    }
}

deepEquals(Object[] array, Object[] array)

功能：比较的是对象中内容是否相等、比较两个多维数组的内容是否一样

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        int b[] = new int[] { 18, 62, 68, 82, 65, 8 };

        int c[][] = new int[][] { { 18, 62, 68, 82, 65, 9 }, { 18, 62, 68, 82, 65, 9 } };
        int d[][] = new int[][] { { 18, 62, 68, 82, 65, 9 }, { 18, 62, 68, 82, 65, 9 } };

        String[][] e = { { "G", "a" }, { "H", "u", "n" }, { "j", "e" } };
        String[][] f = { { "G", "a" }, { "H", "u", "n" }, { "j", "e" } };

        System.out.println(Arrays.equals(a, b)); // false
        // System.out.println(Arrays.deepEquals(a, b));// 会报错

        System.out.println(Arrays.equals(c, d)); // false
        System.out.println(Arrays.deepEquals(c, d));// true

        System.out.println(Arrays.equals(e, f)); // false
        System.out.println(Arrays.deepEquals(e, f));// true
    }
}

填充

Arrays.fill(array,value);

array 表示数组，value 表示填充的值。只能使用同一个数值进行填充。

功能：可以为数组元素填充相同的值

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[10];

        Arrays.fill(a, 5);

        System.out.println(Arrays.toString(a));
    }
}