2.Java基础知识巩固-数组

方法

1. return：①返回方法的返回值；②终止方法；

2. 重载：一个类中，方法名相同，但形参（或形参，返回值）不同；

   ①名称必须相同；

   ②参数列表必须不同（个数不同；或者类型不同，排列顺序不同）；

   ③返回值类型可以相同，也可以不同；

   ④如果仅仅是返回值类型不同，参数相同，不足以成为重载；

   ⑤方法名相同时，编译器会根据参数个数，参数类型去逐个匹配，以选择对应方法；

3. 可变参数：

   ①JDK1.5开始，支持传递同类型的可变参数；

   ②在指定类型后加省略号（…），即为可变参数；

   ③一个方法中只能指定一个可变参数，同时必须时方法的最后一个参数；

   public static void test(int... a) {
       for (int i : a) {
           System.out.println(i);
       }
   }
   

java内存分析

栈内存

1. 存放基本变量类型，包含这个基本类型的具体数值；
2. 存放引用对象的变量，即存放这个对象的在堆内存的具体地址；

堆内存

1. 存放new出来的对象，数组（但不存放对象的引用）；
2. 可以被所有的线程共享；

方法区

1. 包含了所有的class和static变量；
2. 可以被所有的线程共享

数组

1. 定义：描述的是相同类型的若干数据，按照一定的先后顺序排列的一个数据结构；

   int[] num = new int[];
   num.length; //数组的长度
   

2. 初始化

   ①静态初始化

   int[] num1 = {1, 2, 23};
   Man[] mans = {new Man(1, 2), new Man(2, 3)};
   

   ②动态初始化

   int[] num = new int[2];
   num[0] = 1;
   num[1] = 2;
   

   ③数组是引用类型，它的元素相当于实例变量，一经分配内存空间，其中的每个元素会按照实例变量同样的方式被隐式初始化（即基本类型中，byte/short/int默认为0，float/double默认为0.0，布尔值默认false；非基本类型，默认为null）

3. 基本特点

   ①长度是确定的，一旦被创建，它的大小是不可以改变的；

   ②元素必须是相同类型，不允许出现混合类型；

   ③数组中元素可以是任何类型，包含基本类型和引用类型；

   ④数组本身属引用类型，也可以看成对象，其中的元素相当于该对象的成员变量；

   ⑤数组本身也是对象，存放于堆内存，即数组中无论保存的是基本类型还是引用类型，都保存在堆内存中；

   ⑥数组是有序的；

4. 稀疏数组

   ①当一个数组中大部分元素为0，或者为同一值的数值，可以用稀疏数据来保存（可以压缩大小）；

   ②记录数组一共有几行、几列，有多少个不同值；

   ③把具有不同值的元素的行、列、及值记录在一个小规模的数组中，从而缩小规模；
   

   public class Demo04 {
       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("原始数组：");
           printArr(array1);
   
           System.out.println("========================================");
   
           // 2.转换位稀疏数组
           // 获取原始数组有效数据的个数，创建系数数组
           int count = 0;
           for (int[] ints : array1) {
               for (int arr : ints) {
                   if (arr != 0) {
                       count++;
                   }
               }
           }
           int[][] array2 = new int[count + 1][3];
           // 获取原始数组中的有效数据的坐标，值，并赋值给系数数组
           array2[0][0] = 11;
           array2[0][1] = 11;
           array2[0][2] = count;
           int row = 0;
           for (int i = 0; i < array1.length; i++) {
               for (int j = 0; j < array1[i].length; j++) {
                   if (array1[i][j] != 0) {
                       row++;
                       array2[row][0]=i;
                       array2[row][1]=j;
                       array2[row][2] = array1[i][j];
                   }
               }
           }
           System.out.println("转换后的稀疏数组：");
           printArr(array2);
   
           System.out.println("========================================");
   
           // 3.将稀疏数组转成原始数组
           int[][] array3 = new int[array2[0][0]][array2[0][1]];
           for (int i = 1; i < array2.length; i++) {
               array3[array2[i][0]][array2[i][1]] = array2[i][2];
           }
           System.out.println("将稀疏数组转换位原始数组：");
           printArr(array3);
       }
   
       // 打印一个二维数组
       public static void printArr(int[][] arr) {
           for (int[] ints : arr) {
               for (int arr1 :ints){
                   System.out.print(arr1);
                   System.out.print("\t");
               }
               System.out.println();
           }
       }
   }