数组的使用

一、数组的概述

• 数组的定义

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

  • 数组描述的是相同类型的若3 F个数据,按照一定的先后次序排列组合而成。

  • 其中,每一个数据称作-个数组元素每个数组元素可以通过一一个 下标来访问它们.

二、数组声明创建

• 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:

   dataType[] arrayRefVar;
   //首选的方法
   或
   dataType arrayRefVar[] ;
   // 效果相同， 但不是首选方法

• Java语言使用new操作符来创建数组，语法如下:

   dataType[ ]arrayRefVar =new dataType[arraySize];

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

• 获取数组长度:

  arrays .1ength

• Java内存分析：

• 三种初始化

  • 静态初始化

     int []a={1,2,3};
     Man[ ]mans ={new Man(1,1)，new1 Man(2,2)};

  • 动态初始化

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

  • 数组的默认初始化

    • 数组是引用类型，它的元素相当于类的实例变量，因此数组-经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

• 数组的四个基本特点

  • 其长度是确定的。数组一= 旦被创建，它的大小就是不可以改变的。。

  • 其元素必须是相同类型,不允许出现混合类型。

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

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

  • 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

• 数组边界

  • 下标的合法区间; [0, length-1],如果越界就会报错;

     public static void main(String[ ] args) {
     int[] a=new int[2];
     System. out . println(a[2]);
     }

    ArrayIndexOutOfBoundsException :数组”下标越界异常!

• 小结：

  • 数组是相同数据类型(数据类型可以为任意类型)的有序集合

  • 数组也是对象。数组元素相当于对象的成员变量

  • 数组长度是确定的，不可变的。如果越界，则报: ArrayIndexOutofBounds

三、数组的使用

• For- Each循环

• 数组作方法入参

• 数组作返回值

四、多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是-个特殊的-一维数组，其每一个元素都是一个一维数组。

• 二维数组 int a [ ] [ ]= new int [2] [5]; 解析:以上二维数组a可以看成一 个两行五列的数组。

五、Arrays 类

• 数组的工具类java.util.Arrays

• 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了-个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。

• 查看JDK帮助文档

• Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用"而不是“不能")

• 具有以下常用功能: ◆给数组赋值:通过fill方法。 ◆对数组排序:通过sort方法,按升序。 ◆比较数组:通过equals方法比较数组中元素值是否相等。

  ◆查找数组元素: 通过binarySearch方法能对排序好的数组进行二_分查找法操作.

• 冒泡排序

  • 冒泡排序无疑是最为出名的排序算法之一， 总共有八大排序!

  • 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较,人尽皆知。

  • 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为0(n2)

     package Array;
     ​
     import java.util.Arrays;
     ​
     public class Demo7 {
         public static void main(String[] args) {
             int[] a={1,2,5,21,0,12,10};
             int[] sort = sort(a);//调用完我们自己写的排序方法以后。返回一个排序后的数组
             System.out.println(Arrays.toString(sort));
         }
     ​
     ​
         //冒泡排序
         //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
         //2.每一次比较，都会产生出一个最大，或者最小的数字；
         //3.下一轮则可以少一次排序！
         //4.依次循环，直到结束！
     ​
     ​
         public static int[] sort(int[] array){
     ​
             //临时变量
             int temp =0;
     ​
             //外层循环，判断我们这个要走多少次
             for (int i = 0; i <array.length-1 ; i++) {
                 //通过flag表示位减少没有意义的比较
                 boolean flag =false;
                 
                 //内层循环，比价判断两个数，如果第一个数比第二个数大，则交换位置
                 for (int j = 0; j <array.length-1-i; j++) {
                     if (array[j+1]>array[j]){   //由大到小排序
                         //由小到大排序：array[j+1]<array[j]
                         temp = array[j];
                         array[j] =array[j+1];
                         array[j+1]=temp;
                         flag = true;
                     }
                 }
                 if(flag==false){
                     break;
                 }
     ​
             }
             return array;
         }
     ​
     }
     ​

六、稀疏数组

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组

• 稀疏数组的处理方式是: ◆记录数组-共有几行几列，有多少个不同值 ◆把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

• 如下图:左边是原始数组，右边是稀疏数组

•  package Array;
   ​
   public class Demo8 {
       public static void main(String[] args) {
           //1.创建一个二维数组11*11   0:没有， 1:黑  2:白
           int[][] arry1 = new int[11][11];
           arry1[2][3] =1;
           arry1[3][6] =2;
           //输出原始数组
           System.out.println("输出原始数组");
   ​
           for (int[]ints:arry1) {
               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 (arry1[i][j]!=0){
                       sum++;
                   }
               }
           }
           System.out.println("有效值个数"+sum);
   ​
   ​
           //2.创建一个稀疏数组
           int[][] array2 = new int[sum+1][3];
           array2[0][0] =11;
           array2[0][1] =11;
           array2[0][2] =sum;
   ​
           //遍历二维数组，将非零的值，存放稀疏数组中
           int count =0;
           for (int i = 0; i <arry1.length ; i++) {
               for (int j = 0; j <arry1[i].length ; j++) {
                   if (arry1[i][j]!=0){
                       count++;
                       array2[count][0] = i;
                       array2[count][1] = j;
                       array2[count][2] = arry1[i][j];
                   }
               }
           }
           //输出稀疏数组
           System.out.println("稀疏数组");
           for (int i = 0; i <array2.length ; i++) {
               System.out.println(array2[i][0]+"\t"
                       +array2[i][1]+"\t"
                       +array2[i][2]+"\t");
           }
   ​
           System.out.println("*************");
           System.out.println("还原");
   ​
           //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();
           }
       }
   }
   ​