Java 数组

数组

一维数组

一维数组
一维数组是个容器保存数据保存相同数据类型数据
数组第一种声明方式:
数据类型[] 数组名 = 初值;
其中数据类型代表:数组中盛放数据的数据类型

// 声明一个长度为5的整型数组
// 注意:数组的长度一旦给定,就不能修改
// 如何访问数组中的元素?数组使用什么来保存数据?
// 数组使用下标(角标)来访问元素(保存元素)下标从0开始
int[] array = new int[5];
// 访问(存/取)数组中的元素    数组名[下标]
// ArrayIndexOutOfBoundsException
// 数组下标越界异常
// System.out.println(array[5]);
// 保存一个数据
array[2] = 8;
System.out.println(array[2]);
// 相当于指向空
array = null;
// NullPointerException
// 空指针异常:访问一块不属于你的空间
// System.out.println(array[2]);

数组的第二种声明方式:
int[] array = new int[] {1, 2, 3, 4, 5};
// 获取数组的长度
int length = array.length;
// 获取数组中每个元素的值(遍历数组)
// 只要是数组,肯定需要使用遍历
System.out.println(length);
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

例如:
    // 需求:声明一个长度为10的数组
    // 随机10个数,范围是[18,300]存入数组中
    // 打印数组中的最大值与最小值
    int[] random = new int[10];
    // 声明最大值和最小值
    int max = 0;
    int min = 400;
    // 遍历数组
    for (int i = 0; i < random.length; i++) {
        // 给数组中的元素赋值
        random[i] = (int)(Math.random() * (300 - 18 + 1) + 18);
        // 找最大值
        if (max < random[i]) {
            max = random[i];
        }
        // 找最小值
        if(min > random[i]) {
            min = random[i];
        }
    }
    // 输出最值
    System.out.println("最大值为:" + max);
    System.out.println("最小值为:" + min);

    // 遍历数组
    for (int i = 0; i < random.length; i++) {
        System.out.print(random[i] + "  ");
    }

查找数组内元素/角标

1.通过角标查找对应的元素
2.通过元素查找该元素在数组中的位置(角标)
// 需求: 封装一个函数 传入数字1 返回 一  数组2 返回 二 ….. 
int n = (int)(Math.random() * 5 + 1);
System.out.println(findArray(n));
// 查表法
public static char findArray(int index) {
    // 声明一个 char 数组
    char[] array = new char[] {'一', '二', '三', '四', '五'};
    // 按角标 返回对应的字符
    return array[index - 1];
}
// 需求: 定义一个数组 数组值 分别 3,6,11,22 
// 传入11查找对应位置
int[] array = new int[] {3, 6, 11, 22};
int n = findIndex(10, array);
if (n == -1) {
    System.out.println("输入数字不存在!");
} else {
    System.out.println(n);
}
// 为了然方法的使用性更强,可以把数组也当参数传进来
public static int findIndex(int num, int[] array) {
    // 遍历查找元素对应位置
    for (int i = 0; i < array.length; i++) {
        // 有可能传入的值不在数组中,可能会没有返回值
        if (array[i] == num) {
            // 如果找到对应的值,就保存一下
            return i;
        }
    }
    // 如果函数执行到这步,就说明上面没有找到对应角标,直接返回-1提示一下
    return -1;
}

变量在内存中的表现图解

数组定义图解

数组元素反转

// 数组元素反转 反转 reverse (将数组中的值倒过来)注:操作原数组
// 分析:
// 1.换 length / 2 整数次
// 2.第一个数和最后一个数换,依次换...
// array[0]和 array[array.length - 1 - 0]
// array[1]和 array[array.length - 1 - 1]
// array[2]和 array[array.length - 1 - 2]
// ......
// 分析:
// array[i] = array[array.length - 1 - i];相互交换
// 如何交换?
// 利用中间值来交换
// int a = 10;
// int b = 15;
// int c = 0;
// c = a;
// a = b;
// b = c;
int[] array = new int[] {1, 2, 3, 4, 5};
// 数组为地址的传递
reverse(array);
// 遍历数组的方法
String string = Arrays.toString(array);
System.out.println(string);
public static void reverse(int[] array) {
    for (int i = 0; i < array.length / 2; i++) {
        // 数组元素交换
        int temp =array[i];
        array[i] = array[array.length - i - 1];
        array[array.length - i - 1] = temp;
    }
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }

}

例如:
    // 写一个交换两个整数的方法
    int x = 10;
    int y = 15;
    // 数字为值得传递
    reverseNum(x, y);
    // 写一个交换两个整数的方法
    public static void reverseNum(int a, int b) {
        int temp;
        temp = a;
        a = b;
        b = temp;
        System.out.println("x = " + a + ",y = " + b);
    }   

数组反转图解

数字元素和数组元素交换的不同图解

数组排序

冒泡排序

冒泡排序(冒泡其实就是按照什么思想去排序)
核心排序思想:相邻两个数进行比较,交换位置
分析:
int[] array = new int[]{3, 2, 5, 1}
3       2   5   1
第一趟     比较完毕,确定一个最大值,放到最后
第一次:2   3   5   1
第二次:2   3   5   1
第三次:2   3   1   5

length - 1 - 0

第二趟     
第一次:2   3   1   5
第二次:2   1   3   5

length - 1 - 1

第三趟     
第一次:1   2   3   5

length - 1 - 2

例如:
public static void main(String[] args) {
    // 封装一个函数,交换数组 x 和 y 角标的值
    int[] array = new int[] {1, 2, 3, 4, 5};
    changeArray(2, 3, array);
    System.out.println(Arrays.toString(array));

    int[] array1 = new int[] {3, 2, 5, 1, 7, 6, 9};
    // 1.把双层循环结构搭出来
    // 注意:内循环-1防止数组越界
    // 外循环相当于比较多少趟(外循环-1代表5个数比较4趟比较数组长度-1趟)
    // 内循环相当于一趟比多少次(内循环-i代表每一趟都比前一趟少比一次)
    for (int i = 0; i < array1.length - 1; i++) {
        for (int j = 0; j < array1.length - 1 - i; j++) {
            // 2.相邻两个数比较交换
            if (array1[j] > array1[j + 1]) {
                // 交换
                int temp = array1[j];
                array1[j] = array1[j + 1];
                array1[j + 1] = temp;
            }
        }
    }
    // 打印
    System.out.println(Arrays.toString(array1));
}
public static void changeArray(int x, int y, int[] array) {
    int temp = array[x];
    array[x] = array[y];
    array[y] = temp;
}

冒泡排序图解

选择排序

核心排序思想:选择一个数依次和后面的数比较换位
分析:
array[0] --- array[1]       array[2]        array[3]
array[1] --- array[2]       array[3]
array[2] --- array[3]

例如:
    public static void main(String[] args) {
        int[] array = new int[] {5, 3, 4, 2, 1, 7, 9, 6, 8};
        // 1.双层循环架构
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 1 + i; j < array.length; j++) {
                /*
                 * 1 + 0
                 * 1 + 1
                 * 1 + 2
                 * 1 + i
                 * 外循环 -1(5个数比4趟)相当于比较数组长度-1趟
                 * 内循环 1 + i 把不需要比较的数去除(array[0]与array[0])
                 *             每一次确定一个数
                 */
                // 2.比较交换
                if (array[i] > array[j]) {
                    int temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

折半查找

折半查找(提高效率的查找)
前提:数组中查找 查找这个数在数组中的角标
注意:在有序的数组中查找

思想:
    // 1.随机[1,100]的数
    // 2.让用户输入一个数
    // 3.输入的这个数和随机出来这个数比较
    // 4.告诉用户猜的是大还是小了
    // 5.循环一直到猜中为止
    public static void main(String[] args) {
        // 随机数
        int random = (int)(Math.random() * (100 - 1 + 1) + 1);
        // 提示用户输入
        System.out.println("请输入一个数:");
        Scanner scanner = new Scanner(System.in);

        // 循环猜
        while (true) {
            // 循环接收输入的数
            String string = scanner.nextLine();
            // 字符串转数字
            int newNum = Integer.parseInt(string);
            // 比较是大还是小
            if (newNum > random) {
                System.out.println("大了");
            } else if (newNum < random) {
                System.out.println("小了");
            } else {
                System.out.println("猜中了");
                // 结束当前的循环
                break;
            }
        }
        System.out.println("电脑随机数为:" + random);
        scanner.close();
    }

例如:
    // 查找25的角标
    // int[] array = new int[] {11, 25, 37, 48, 54, 62, 75, 87, 98};
    public static void main(String[] args) {
        int[] array = new int[] {11, 25, 37, 48, 54, 62, 75, 87, 98};
        // 把要用到的变量全部声明一遍
        int min = 0;
        int max = array.length - 1;
        int mid = (min + max) / 2;
        // 要查找的值
        int key = 10;
        /*
         * 循环查找
         * array[mid] == key
         */
        while (key != array[mid]) {
            // 比较:如果比中间角标大就挪动小角标
            //      如果比中间角标大就挪动小角标
            if (key > array[mid]) {
                min = mid + 1;
            } else if (key < array[mid]) {
                max = mid - 1;
            }
            // 挪动完角标后还要进行折半操作
            mid = (min + max) / 2;
            // 当最大角标小于最小角标的时候说明数组中不存在这个数
            if (max < min) {
                // 进到这里说明不存在这个数, 停止循环
                mid = -1;
                break;
            }
        }
        if (mid == -1) {
            System.out.println("这个数不存在于数组中");
        } else {
            System.out.println("这个数在数组中的角标为:" + mid);
        }
    }

折半查找图解

二维数组

二维数组
二维数组是个容器保存相同数据类型的一维数组
二维数组声明方式:
    数据类型[][] 数组名 = 初值;
声明方式一:  
    int[][] array = new int[长度][长度];
声明方式二:可以把数组中元素定义出来
    int[][] array = new int[][] {{元素1, 元素2, 元素3, ..., 元素n},
                                 {元素1, 元素2, 元素3, ..., 元素n},
                                 {元素1, 元素2, 元素3, ..., 元素n},
                                 {...},
                                 {元素1, 元素2, 元素3, ..., 元素n}};

// 如何描述下面定义的二维数组
声明方式一: 
// 该二维数组中有3个一维数组,每个一维数组中有4个元素
int[][] array = new int[3][4];
// 打印二维数组的长度相当于打印数组中有多少个元素(二维数组中的元素为一维数组,只不过一维数组中也包含元素)
System.out.println(array.length);
// 打印二维数组中第一个元素的长度相当于打印一维数组中有多少个元素
System.out.println(array[0].length);

声明方式二: 可以把数组中元素定义出来
int[][] array = new int[][] {
    {1, 2, 3, 4, 5},
    {2, 3, 4, 5, 6},
    {3, 4, 5, 6, 7}
};

// 遍历数组
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        System.out.print(array[i][j] + "\t");
    }
    System.out.println();
}

多维数组

三维数组是容器保存多个相同类型的二维数组
....

// 3层2行5列的三维数组
int[][][] array1= new int[][][] {
    {
        {1, 2, 3, 4, 5},
        {2, 3, 4, 5, 6},
    },
    {
        {1, 2, 3, 4, 5},
        {2, 3, 4, 5, 6},
    },
    {
        {1, 2, 3, 4, 5},
        {2, 3, 4, 5, 6},
    },
};
int sum = 0;
for (int i = 0; i < array1.length; i++) {
    for (int j = 0; j < array1[i].length; j++) {
        for (int k = 0; k < array1[i][j].length; k++) {
            sum = sum + array1[i][j][k];
            System.out.print(array1[i][j][k] + "\t");
        }
        System.out.println();
    }
    System.out.println();
}
System.out.println(sum);

http://blog.csdn.net/huzongnan/article/list