Java数组

Java数组

1.数组定义

1. 数组是相同数据类型的有序集合
2. 每一个数据称为一个数组元素，可以通过下标来访问数组元素

2.数组声明创建

1. 声明数组变量

   //语法
   数据类型[] 变量名;//首选
   数据类型 变量名[];//效果相同，非首选
   

2. 创建数组

   //语法
   数据类型[] 变量名 = new 数据类型[数组长度];
   

3. 访问数组元素：通过索引访问，索引从0开始

4. 获取数组长度：变量名.length

5. 代码

   public class Demo {
       public static void main(String[] args) {
           //1.声明一个数组
           int[] array;
           //2.创建一个数组
           array = new int[5];
           //3.给数组元素赋值
           for (int i = 0; i < 5; i++) {
               array[i] = i + 1;
               System.out.println(array[i]);
           }
           //4.计算所有数组元素的和
           int sum = 0;
           for (int i : array) {
               sum += i;
           }
           System.out.println(sum);
       }
   }
   

3.Java内存

1. 堆内存
   • 存放new的对象和数组
2. 栈内存
   • 存放基本类型【具体数值】
   • 引用对象的变量【具体地址】
3. 方法区
   • 包含了所有class和static变量

4.数组的三种初始化状态

• 静态初始化、动态初始化、默认初始化

  public class Demo {
      public static void main(String[] args) {
          //静态初始化
          int[] a = {1,2,3,4,5};
          System.out.println(a[0]);//1
  
          //动态初始化
          int[] b = new int[10];
          b[0] = 1;
          System.out.println(b[0]);//1
  
          //默认初始化
          System.out.println(b[1]);//0
      }
  }
  

5.数组的四个基本特点

1. 长度确定，一旦创建大小不可改
2. 所有数组元素类型相同
3. 数组元素可以是任何数据类型【基本数据类型和引用数据类型】
4. 数组变量属于引用数据类型，数组对象本身是在堆中

6.数组边界

1. 下标的合法区间：[0,length-1]
2. 数组是相同数据类型的有序集合
3. 数组也是对象，数组元素相当于对象的成员变量
4. 数组长度确定，不可变
5. 越界报错：ArrayIndexOutOfBoundsException:数组下标越界异常！

7.数组的使用

1. 普通For循环
2. For-Each循环
3. 数组作方法入参
4. 数组作返回值

public class Demo {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //1. 普通For循环
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + "\t");
        }
        System.out.println();
        //2. For-Each循环
        for (int array : arrays) {
            System.out.print(array + "\t");
        }
        System.out.println();
        //3. 数组作方法入参
        printArray(arrays);
        System.out.println();
        //4. 数组作返回值
        int[] reverse = reverse(arrays);
        for (int i : reverse) {
            System.out.print(i + "\t");
        }
    }

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

    //反转数组
    public static int[] reverse(int[] arrays) {
        int[] result = new int[arrays.length];
        for (int i = 0, j = arrays.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

8.多维数组

1. 定义

   • 数组元素也是一个数组

2. 使用

   public class Demo {
       public static void main(String[] args) {
           int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};
   
           for (int i = 0; i < arrays.length; i++) {
               for (int j = 0; j < arrays[i].length; j++) {
                   System.out.print(arrays[i][j] + "\t");
               }
           }
       }
   }
   

9.Arrays类

1. 查看JDK帮助文档
2. Arrays类中的方法都是static修饰的静态方法，可直接用类名调用，可以不用对象来调用【不用而非不能】
3. 常用功能
   • fill()：给数组赋值
   • sort()：给数组按升序排序
   • equals()：比较数组元素值是否相等

10.冒泡排序

public class Demo {
    public static void main(String[] args) {
        int[] arrays = {1,2,532,345,3254,2345,32,2,341};

        for (int i = 0; i < arrays.length-1; i++) {
            for (int j = 0; j < arrays.length-1-i; j++) {
                if (arrays[j] > arrays[j+1]) {
                    int temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays));
    }
}

11.稀疏数组

1. 什么时候用？
   • 一个数组中大部分数组元素为0或同一值的数组，可用稀疏数组来保存该数组
2. 怎么用？
   • 记录数组几行几列几个有效值
   • 将每个有效值的行列记录在小规模数组中

public class Demo {
    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;
        //打印棋盘
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        /**
         * 2.获取有效值
         */
        int sum = 0;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                if (anInt != 0) {
                    sum++;
                }
            }
        }

        /**
         * 3.创建一个稀疏数组
         */
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        /**
         * 4.遍历二维数组，将有效值放入稀疏数组中
         */
        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[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        /**
         * 5.还原稀疏数组
         */
        //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.打印数组
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}