java数组

数组

数组的定义

1. 数组是相同类型数据的有序集合

2. 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成

3. 每个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们

数组的声明创建

1. 声明数组变量的语法：

   dataType[] arrayRefVar;(首选)

   dataType arrayRefVar[];

2. 用new操作符来创建数组：

   dataType[] arrayRefVar = new dataType[arraySize];

3. 给数组元素赋值

   int[] nums;//声明

   nums = new int[10];//创建

   nums[0] = 1;

   nums[1] = 2;

   .

   .

   nums[9] = 10;

4. 数组的元素是通过索引访问的，数组索引从0开始

5. 获取数组长度：nums.length

6. 初始化：

   静态初始化：int[] a={1,2,3,4};

   Man[] mans={new Man(1,1),new Man(2,2)};

   动态初始化：int[] a = new int[2];

   a[0] = 1;

   a[1] = 2;

   数组的默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方法被隐式初始化。（int类型的默认初始化是0，String类型是null）

    

 

内存分析

数组的四个基本特点

1. 长度确定，一旦被创建，大小不变

2. 元素必须是相同类型，不能出现混合类型

3. 数组中的元素可以是任何数组类型，包括基本类型和引用类型

4. 数组变量属引用类型，数组也可看成是对象，数组中的每个元素相当于该对象的成员变量，数组对象是在堆中

5. 下标合法区间：[0,length-1],如果越界就会报错：ArrayIndexOutOfBoundsException

Ctrl+/ 多行注释

数组的使用

多维数组的使用

1. 二维数组：int a[] []=new int[2] [5];

2.  //遍历数组
    int[][]array={{1,2},{2,3}{3,4}{4,5}};
    for(int i = 0;i<array.length;i++){
        for(int j = 0;j < array[i].length ; j++){
            System.out.println(array[i][j]);
        }
    }

Arrays类

1. Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用。而不用使用对象来调用

2. 具有以下常用功能：

   给数组赋值：fill方法 Arrays.fill(a,2,4,0)//将数组a中从下标2到4位用0填充

   对数组排序：sort方法，按升序

   比较数组：equals方法比较数组中元素值是否相等

   查找数组元素：通过binarySearch进行二分查找法

冒泡排序

1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置

2. 每一次比较，都会产出一个最大或最小的值

3. 下一轮则可以少一次排序

4. 依次循环，直到结束

     public static void main(String[] args) {
            int[] a = {1,4,0,2,5};
            int[] sort = sort(a);
    ​
            System.out.println(Arrays.toString(sort));
    ​
    ​
        }
        public static int[] sort(int[] arrays)
        {
            int temp=0;
            for(int i = 0;i < arrays.length - 1;i++) {
                for (int j = 0; j < arrays.length - 1 -i; j++) {
                    if(arrays[j+1]<arrays[j]) {
                        temp = arrays[j];
                        arrays[j] = arrays[j+1];
                        arrays[j+1] = temp;
                    }
                }
            }
            return arrays;
        }

    

ToString()将对象转换为字符串

 int[] a={1,2,3,4,5}
 System.out.println(Arrays.toString(a));

稀疏数组

 int[][] arrays1 = new int[11][11];
        arrays1[1][2]=1;
        arrays1[2][3]=2;
         System.out.println("输出原稀疏矩阵");
        for(int[] x: arrays1) {
            for (int y : x) {
                System.out.print(y + " ");
            }
            System.out.println();
        }
         System.out.println("输出三元数组:");
         int num=0;
         for(int i = 0;i < arrays1.length;i++) {
             for (int j = 0; j < arrays1[i].length; j++) {
                 if (arrays1[i][j] != 0)
                     num++;
             }
         }
        int[][] arrays2 = new int[num+1][3];
 ​
        arrays2[0][0]= 11;
        arrays2[0][1]= 11;
        arrays2[0][2]= num;
        //遍历二维数组，将非零的值，存放稀疏数组中
        int count = 0;
         for(int i = 0;i < arrays1.length;i++) {
             for (int j = 0; j < arrays1[i].length; j++) {
                 if (arrays1[i][j] != 0) {
                     count++;
                         arrays2[count][0] = i;
                         arrays2[count][1] = j;
                         arrays2[count][2] = arrays1[i][j];
                 }
             }
         }
         for (int i = 0; i < arrays2.length; i++) {
             System.out.println(arrays2[i][0]+"\t"+arrays2[i][1]+"\t"+arrays2[i][2]);
         }
         //还原稀疏数组
         System.out.println("还原的稀疏数组:");
         int[][] arrays3 = new int[arrays2[0][0]][arrays2[0][1]];
         for (int i = 1; i < arrays2.length; i++) {
                 arrays3[arrays2[i][0]][arrays2[i][1]] = arrays2[i][2] ;
         }
         for (int[] x:arrays3) {
             for (int y:x) {
                 System.out.print(y+" ");
             }
             System.out.println();
         }