java 数组

最新推荐文章于 2024-07-10 21:37:49 发布

沉淀_0.0

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量319

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_44720241/article/details/127564151

版权

java 数组

文章目录

java 数组

（1）数组概况

相同类型数据的有序集合。通过下标访问数组元素。索引从0开始。

声明数组的语法：

dataType[] arrayRefVal;//首选
dataType arrayRefVal[];//效果一样，但不建议使用，以前c、c++过渡使用

创建数组的语法：（用new关键字）

dataType[] arrayRefVal = new dataType[arraySize];

public class Demo01 {
    public static void main(String[] args) {
        int[] nums;//声明了一个数组
        nums = new int[10];//创建了一个数组。这里存放了10个int类型数字
        //声明和创建 int[] nums = new int[10];
        nums[0] = 5;//给数组元素赋值，没有赋值，用默认值
        System.out.println(nums[0]);//5
        System.out.println(nums[1]);//0
        System.out.println(nums[11]);//ArrayIndexOutOfBoundsException: 11 数组下标越界【问题提示记住，很重要】数组超了
    }
}

（2）内存分析及三种初始化

Java内存分析（简易版）：

Java代码分析：数组在声明时数组并不存在，创建时存在

数组三种初始化：
- 静态初始化
  int[] a = {1,2,3};//一旦定义就不可以改变（创建+ 赋值）
  Man[] man = {new Man(1,1), new Man(2,2)}
- 动态初始化
  int[] a = new int[2];//包含默认初始化
  a[0] = 1;
  a[1] = 2;
- 默认初始化
  - 数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例同样的方式被隐式初始化。

（3）下标越界及数组小结

数组的四个基本特点：

长度是确定的。一旦被创建，它的大小不可以改变。
元素的类型必须相同。不允许出现混合类型。
数组中的元素可以是任何类型，包括基本类型和引用类型。
数组变量属于引用类型，数组也可以看成对象，数组中的每一个元素相当对该对象的成员变量。数组本身就是对象，Java对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身在堆中。

数组边界：

下标的合法区间：[0,length-1]，越界就会报错；
ArrayIndexOutOfBoundsException：数组下标越界异常

小结：

数组是相同数据类型（任意类型）的有序集合。
数组也是对象。数组元素相当于对象的成员变量。
数组长度是确定的，不可变的。如果报错，则报:ArrayIndexOutOfBoundsException

（4）数组的使用

foreach循环与for循环：
foreach循环（for(int array:arrays)）遍历数组，只能打印数组元素。
for循环（这个数组常用）这个循环可以取数出数组，使用下标赋值。

public class Demo02 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        printArray(reverse(arrays));
    }
    // 反转数组
    public static int[] reverse(int[] arrays) {
        int[] result = new int[arrays.length];
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
            result[i] = arrays[j];
        }
        return result;
    }
    // 打印数组元素
    public static void printArray(int[] arrays) {
        for (int array : arrays) {
            System.out.print(array + " ");
        }
    }
}

（5）多维数组

可以看成是数组的数组，比如二维数组就是一个特殊一维数组，其每一个元素都是一个一维数组。
二维数组 int a[][] = new int[2][5];
解析：以上二维数组a可以看成一个两行五列的数组。

public class Demo03 {
    public static void main(String[] args) {
        /*
          3行2列的数组
          1,2 array[0]
          3,4 array[1]
          5,6 array[2]
        */
        int[][] array = {{1, 2}, {3, 4}, {5, 6}};
        printArray(array[0]);//1 2
        System.out.println(array[2][0]);//5
    }

    // 打印数组元素
    public static void printArray(int[] arrays) {
        for (int array : arrays) {
            System.out.print(array + " ");
        }
    }
}

（6）Array类

数组的工具类，java.util.Arrays
查看JDK帮助文档：http://blog.fondme.cn/apidoc/jdk-1.8-google/
直接用类名调用。

常用功能：
- 给数组赋值：fill
- 对数组排序：sort
- 比较数组：equals(比较数组中元素值是否相等)
- 查找数组元素：binarySearch对排序号的数组进行二分查找法操作。

import java.util.Arrays;
public class Demo04 {
    public static void main(String[] args) {
        int[] a={1,2,4,21,21,32,112,3,9};
        //打印
        System.out.println(a);//[I@1b6d3586 打印的是对象的HashCode
        System.out.println(Arrays.toString(a));//[1, 2, 4, 21, 21, 32, 112, 3, 9] 工具类都是自己写的
        printArray(a);//[1, 2, 4, 21, 21, 32, 112, 3, 9] 用自己方法打印
        //排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 9, 21, 21, 32, 112]
        //填充
        Arrays.fill(a,2,4,0);//将a数组index为[2,4)之间填充0
        System.out.println(Arrays.toString(a));//[1, 2, 0, 0, 9, 21, 21, 32, 112]
    }
    //打印数组
    public static void printArray(int[] arrays) {
        System.out.print("[");
        for (int i = 0; i < arrays.length; i++) {
            if (i == arrays.length - 1) {
                System.out.print(arrays[i] + "]");
            } else {
                System.out.print(arrays[i] + ", ");
            }
        }
        System.out.println();
    }
}

（7）冒泡排序【笔试】

最出名的排序算法之一，共有八大排序。
冒泡的代码很简单，两层循环，外层冒泡轮数，里层依次比较。（两两比较，小的往前）
嵌套循环，这个算法的时间复杂度为O(n2)。

import java.util.Arrays;
public class Demo05 {
    public static void main(String[] args) {
        int[] a = {112, 121, 2, 45, 2, 54, 6, 34, 454, 1};
        sort(a);
        System.out.println(Arrays.toString(a));//[1, 2, 2, 6, 34, 45, 54, 112, 121, 454]
        int[] b = {112, 121, 2, 45, 2, 54, 6, 34, 454, 1};
        sort(b);
        System.out.println(Arrays.toString(a));//[1, 2, 2, 6, 34, 45, 54, 112, 121, 454]
    }
    /*
       冒泡排序：
       1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置
       2.每一次比较，都会产生出一个最大，或最小的数字；
       3.下一轮则可以少一次排序
       4.依次循环，直到结束
     */
    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次。length-1防止溢出
        for (int i = 0; i < array.length - 1; i++) {
            //内存循环，比价判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                //升序 前面的大于后面的就交换 每次获得一个最小的数字
                if (array[j] > array[j + 1]) {
                    temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }
    //优化：我们设置一个标志位flag；如果本趟交换了，就把flag = true,继续执行下一趟；如果没有交换，那本趟就已经排序完成了，直接结束循环。
    public static int[] sort2(int[] array) {
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次。length-1防止溢出
        for (int i = 0; i < array.length - 1; i++) {
            //内存循环，比价判断两个数，如果第一个数比第二个数大，则交换位置
            boolean flag = false;//通过标识位来减少没有意义的比较
            for (int j = 0; j < array.length - 1 - i; j++) {
                //升序 前面的大于后面的就交换
                if (array[j] > array[j + 1]) {
                    temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                    flag = true;
                }
            }
            //没有交换
            if(!flag){
                System.out.println("没有交换，说明排序已经完成" );
                break;
            }
        }
        return array;
    }
}

（8）稀疏数组

当数组中大部分元素为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 0 
	0 0 0 0 0 0 0 0 0 0 0 	
*/

public class Demo06 {
    public static void main(String[] args) {
        //1.创建一个二维数组  11*11  0：没有棋子  1：黑棋  2：白旗
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("=================");
        //转换为稀疏数组保存
        //1.获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }

            }
        }
        System.out.println("有效值的个数：" + sum);
        //2.创建一个稀疏数组的数组 (第一行记录写的总体所以记录行数为sum+1,列数固定为3[列、行、值])
        int[][] array2 = new int[sum + 1][3];
        //记录第一条列、行、值
        array2[0][0] = 11;//11行
        array2[0][1] = 11;//11列
        array2[0][2] = sum;//sum个有效值
        //遍历二维数组，将非零的值，存放稀疏数组中
        int count = 0;//计数作用
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    //记录的列、行、值
                    array2[count][0] = i;//行
                    array2[count][1] = j;//列
                    array2[count][2] = array1[i][j];//值
                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < array2.length; i++) {
            /*
               11	11	2
               1	2	1
               2	3	2
             */
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2]);
        }
        System.out.println("=================");
        System.out.println("还原");
        System.out.println(array2.length);
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还远它的值,第一行去掉
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}