Array 数组

Array 数组

1.数组的概述

• 数组是相同类型的有序集合
• 每一个数据称作一个数组元素，并且可以通过一个下标来访问他们。

2.数组声明创建

2.1声明数组

数组必须先声明数组变量，才能被程序中使用。

int[] array ;  //声明一个 int的数组集合  (首选)
或
int array[] ;  //声明一个 int的数组集合  (不推荐)

2.2创建数组

Java是使用new操作符来创建数组的。

int[] array ;  // 声明int类型的数据类型集合数组变量
array = new int[2];        //用new操作符创建数组
或
    //动态初始化
int[] array2 = new int[2];  //声明int类型的数组变量,同时创建长度为2数组.
array2[0] = 1; 				//将数组索引0的元素值设置为1
array2[1] = 2;              //将数组索引1的元素值设置为2
或
    //静态初始化
int[] array3 = {1,2,3,4,5,6};  //声明int类型的数组,并声明其中的值

• 方式一是方式二的简写,是等价的

• 动态初始化与静态初始化一个是声明长度,一个是指定其中的值

• 数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也会被按照实例变量被隐式初始化.

2.3数组的边界

数组的合法区间: [0, length-1] ,如果数组越界会报错

java.lang.ArrayIndexOutOfBoundsException

2.4数组的四个基本特点

1. 其长度是确定的,一旦被创建,大小是不可以被改变的.
2. 其元素必须是相同类型,不允许出现混合类型.
3. 数组中的元素可以是任何数据类型,包括基本类型和引用类型
4. 数组本身就是对象,java中的 数组和数组中的元素都在堆中.

3.数组的使用

3.1案例一

数组的基本使用

package com.zhao.array;

public class Array02 {
    public static void main(String[] args) {
        // 定义一个10个数组
        double[] array = new double[10];
        array[0] = 3.1;
        array[1] = 2.5;
        array[2] = 4.8;
        array[3] = 100;
        array[4] = 6.7;
        array[5] = 3.7;
        array[6] = 3.99;
        array[7] = 2.87;
        array[8] = 1.1;
        array[9] = 3.444;
        // 计算所有元素总和
        double sum = 0.0;
        for (int i = 0 ; i < array.length; i++){    //array.length 指的是该数组的长度
            sum += array[i];
        }
        System.out.println("所有元素的总和为:" + sum);

        //计算整个数组的元素的平均值
        double average;
        average = sum / (array.length+1);
        System.out.println("整个数组的元素的平均值为:" + average);

        //查找最大的元素值
        double max = array[0];
        for (int i = 0; i <array.length ; i++) {
        }

        }
    }

运行结果:

所有元素的总和为:132.204
整个数组的元素的平均值为:12.018545454545455

3.2案例二

数组可以作为对象当方法传参入参

public class Array04 {
    public static int[] array = {1,2,3,4,5,6,7,8,9};
    public static void main(String[] args) {
        print(reverseArray(array));        //打印反转后的array数组
        print(maxArray(array));            //打印数组中的最大值
        print(minArray(array));            //打印数组中的最小值
        print(productArray(array));        //打印数组中所有元素的乘积
    }

    /**
     * 打印数组元素
     * @param arrays
     */
    public  static void print(int[] arrays){
        for (int i = 0; i <arrays.length ; i++) {
            System.out.print(arrays[i]);
        }
        System.out.println("");
    }

    /**
     * 打印数字元素
     * @param a
     */
    public static void print(int a){
        System.out.println(a);
    }

    /**
     * 反转数组
     * 声明一个新数组来接收原先数组
     * @param arrays
     */
    public static int[] reverseArray(int[] arrays){
        int[] array2 = new int[arrays.length];
        for (int i=0, j= arrays.length-1 ; i <arrays.length ; i++,j--) {
            array2[j] = arrays[i];
        }
        return array2;
    }

    /**
     * 求函数中最大值
     * @param arrays
     * @return
     */
    public static int maxArray(int[] arrays){
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            // max = max与arrays的元素两者中的较大值
            max = max >= arrays[i] ? max : arrays[i] ;
        }
        return max;
    }

    /**
     * 求元素中的最小值
     * @param arrays
     * @return
     */
    public static int minArray(int[] arrays){
        int min = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            // min = min与arrays的元素两者中的较小值
            min = min <= arrays[i] ? min : arrays[i];
        }
        return min;
    }

    /**
     * 求所有元素的乘积
     * @param arrays
     * @return
     */
    public static int productArray(int[] arrays){
        int product = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            product *= arrays[i];
        }
        return product;
    }
}

结果:

987654321
9
1
362880

4.多维数组

多维数组可以看成一个数组的数组,其中每一个元素都可以是个数组

4.1二维数组

4.1.1二维数组的声明和创建

int[][] arrays = new int[2][3];   //声明并创建一个二维数组,长度为2,且子数组长度为3 (动态初始化)

int[][] arrays2 = new int[2][];   //声明并创建一个二维数组,长度为2    (动态初始化)
arrays2[0] = new int[3];          //索引为0的子数组长度为3
arrays2[1] = new int[2];          //索引为1的子数组长度为2

int[][] arrays3 = {{1,2},{3,4,5}};声明并创建一个二维数组,并元素初始化   (静态初始化)

4.1.2二维数组的使用

arrays[0][1] = 1;    //将1赋值给二维数组第0号索引中,索引1号的元素.

4.1.3遍历二维数组

public class Array06 {
    public static void main(String[] args) {
        int[][] arrays3 = {{1,3},{66,4,5},{7},{356,67,99}};   //声明并创建一个二维数组,并元素初始化

        for (int i = 0; i < arrays3.length; i++) {         //遍历arrays3数组
            for (int j = 0; j < arrays3[i].length; j++) {  //遍历arrays3[i]的数组
                System.out.print(arrays3[i][j]);           //打印输出每个元素
            }
            System.out.println("");                        //每个子数组中间断开
        }
    }
}

结果:

13
6645
7
3566799

5.Arrays类

5.1概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

5.2常用类

Arrays.toString(array);						// 将数组转化成字符串形式
Arrays.sort(array);  						// 将数组进行升序
char[] arrays = string.toCharArray();		// 将字符串转化成字符数组

5.2.1案例一

public static void main(String[] args) {
    int[] array = {1,9,55,45,37,4445,66,9945,331,12};
    // 打印数组哈希值
    System.out.println(array);                       //[I@4554617c
    // 将数组转化成字符串形式
    System.out.println(Arrays.toString(array));      //[1, 9, 55, 45, 37, 4445, 66, 9945, 331, 12]
    // 将数组进行升序
    Arrays.sort(array);
    System.out.println( array);                      //[I@4554617c
    System.out.println(Arrays.toString(array));      //[1, 9, 12, 37, 45, 55, 66, 331, 4445, 9945]
}

5.2.2案例二

import java.util.Arrays;

public class Array09 {
    public static void main(String[] args) {
        String string = "sajskashdsjvagdcmzkkfldsa";
        // 将字符串转化成字符数组
        char[] arrays = string.toCharArray();
        // 对字符数组进行升序排序
        Arrays.sort(arrays);
        for (int i = arrays.length-1; i >= 0 ; i--) {
            System.out.print(arrays[i]+ " ");	//z v s s s s s m l k k k j j h g f d d d c a a a a 
        }
    }

}

5.3冒泡排序

import java.util.Arrays;

public class Array07 {
    /**
     * 定义创建数组
     */
    public static int[] array = {1,99,48,66,7,3,4,26,78,6,2};

    /**
     * 冒泡排序
     * @param array
     * @return
     */
    public static int[] BubbleSort (int[] array){
        int a ;  // 中间值
        for (int j = 0; j < array.length-1; j++) {
            for (int i = 0; i < array.length-1; i++) {
                if (array[i] <= array[i+1]){
                }else {
                    a = array[i];
                    array[i] = array[i+1];
                    array[i+1] = a;
                }
            }
        }
        return array;
    }

    public static void main(String[] args) {
        //toString类方法是用来输出数组的
        System.out.println(Arrays.toString(BubbleSort(array)));
    }
}

6.稀疏数组

6.1概述

什么叫稀疏数组呢？
如果一个数组(包括多维数组)中的大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组，节约空间。
一般来说，稀疏数组的处理方法是：
1.记录数组一共有几行几列，有多少个不同的数值。
2.把具有不同值的元素的行列及记录在一个小规模的数组中，从而缩小程序的规模。
如图所示，一般来说，第一行存取几行几列以及几个数值。

6.2实例

public class Array10 {
    public static void main(String[] args) {
        // 生成一个11*11的棋盘, 白色 :1 黑色:2 ,其他都为0
        int [][] array = new int[11][11];
        array[2][3] = 1;
        array[3][4] = 2;
        // 生成棋盘
        for (int a = 0; a < array.length; a++) {
            for (int b = 0; b < array[a].length; b++) {
                System.out.print(array[a][b] + "\t");
            }
            System.out.println();
        }

        System.out.println("------------------");

        // 计算稀疏数组需要保存的非0值的个数
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0 ){
                    sum++;
                }
            }
        }
        // 创建稀疏数组
        int[][] array2 = new int[sum + 1][3];
        // 稀疏数组的首行为 11 11 个数
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        int sum2 = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0 ){
                    sum2++;
                    array2[sum2][0] = i+1;
                    array2[sum2][1] = j+1;
                    array2[sum2][2] =array[i][j];
                }
            }
        }

        System.out.println("稀疏数组的有效个数为:" + sum);
        // 遍历稀疏数组
        System.out.println("稀疏数组为:");
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j] + "\t" );
            }
            System.out.println();
        }
        System.out.println("------------------");
        //还原稀疏数组
        System.out.println("还原稀疏数组");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        for (int a = 1; a < array2.length; a++) {
            array3[array2[a][0]-1][array2[a][1]-1] = array2[a][2];
        }

        for (int aa = 0; aa < array3.length; aa++) {
            for (int bb = 0; bb < array3[aa].length; bb++) {
                System.out.print(array3[aa][bb] + "\t");
            }
            System.out.println("");
        }

    }
}

结果:

0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	1	0	0	0	0	0	0	0	
0	0	0	0	2	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
------------------
稀疏数组的有效个数为:2
稀疏数组为:
11	11	2	
3	4	1	
4	5	2	
------------------
还原稀疏数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	1	0	0	0	0	0	0	0	
0	0	0	0	2	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0