Java数组

数组

数组声明创建

dataType[] = arrayRefval; //首选方法
dataType arrayRefval[];   //效果相同，但不是首选方法

数组创建

dataType[] arrayRefval = new dataType[arraysize]

• 获取数组长度

  array.length
  

内存分析

数组初始化

• 静态初始化

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

• 动态初始化

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

• 数组的默认初始化

  • 数组时引用类型，它的元素相当于类的实例变量（有默认值），因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化，也就是说有默认初值

特点

• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素都相当于该对象的成员变量，数组本身就是对象，Java中对象是在堆中，因此数组无论保存原始数据类型还是其他对象类型，数组对象本身是在堆中的

数组使用

• For-Each循环

  public class Hello {
      public static void main(String[] args) {
          int []arr = new int[6];
          arr[0] = 1;
          arr[1] = 2;
          arr[2] = 3;
          arr[3] = 4;
          arr[4] = 5;
          arr[5] = 6;
          for (int i : arr) {
              System.out.print(i+" ");
          }
      }
  }
  

  

• 数组作方法入参

• 数组作返回值

多维数组

int a[][] = new int[2][5];

Array类

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

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

• 查看JDK帮助文档

• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）

• 具有以下常用功能：

  • 给数组赋值：通过fill方法

    Arrays.fill(arr,temp) //将数组中的每一个元素被temp覆盖
    Arrays.fill(arr,index1,index2,temp) //数组序号从index1到index2的元素被temp覆盖 ，大于等于index1，小于index2
    

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

  • 比较数组：通过equals方法比较数组中元素是否相等

  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

  • 输出数组：通过toString方法

    package exercise;
    import java.util.Arrays;
    public class Hello {
        public static void main(String[] args) {
            int []arr = {44,1,89,3,4,5,6};
            System.out.println(arr);  //打印的是array的Hashcode,[I@16b98e56
            System.out.println(Arrays.toString(arr)); //通过Arrays类的toString方法将数组的元素打印
        }
    }
    

冒泡排序

package exercise;
import java.util.Arrays;
public class Hello {
    public static void main(String[] args) {
        int []array = {3,7,8,82,33,5,6,77};
        int []arrSort = sort(array);
        System.out.println(Arrays.toString(arrSort));
    }

    public static int[] sort(int []a){
        for (int i = 0; i <a.length-1; i++) {  //通过i来控制比较次数，
            int temp = 0;
            for(int j=0;j<a.length-1-i;j++){   //第一次循环就将最大的值排到了最后，所以j-i来控制排序次数
                if(a[j+1]<a[j]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        return a;
    }
}

稀疏矩阵

package exercise;
import java.util.Arrays;
public class sparseMatrix {
    public static void main(String[] args) {
        preArr();
    }

    public static void preArr(){
        int [][]arr = new int[11][11];
//        for (int i = 0; i <11; i++) {
//            for(int j=0;j<11;j++){
//                arr[i][j] = 0;
//            }
//            System.out.println(Arrays.toString(arr[i]));  输出二维数组
//        }
        arr[1][2] = 1;
        arr[2][3] = 2;
        int totalNum = 0;
        System.out.println("原始数组：");
        for(int[] index1 :arr){   //index1是arr里面的数组,所以声明数组index1
            for(int index2 :index1){  //index2是数组index1里面的值，是int型
                System.out.print(index2+"\t");
                if(index2!=0)
                totalNum++;
            }
            System.out.println();
        }

        int [][]sparseMatrix = new int[totalNum+1][3];
        sparseMatrix[0][0] = 11;
        sparseMatrix[0][1] = 11;
        sparseMatrix[0][2] = totalNum;
        for(int k=1;k<totalNum+1;k++){
            for (int i = 0; i <11; i++) {
                for(int j=0;j<11;j++){
                    if(arr[i][j]!=0){
                        sparseMatrix[i][0] = i;
                        sparseMatrix[i][1] = j;
                        sparseMatrix[i][2] = arr[i][j];
                    }
                }
            }
        }
        System.out.println("有效值个数：");
        System.out.println(totalNum);
        System.out.println("压缩数组：");
        System.out.println(sparseMatrix[0][0]+"行  "+sparseMatrix[0][1]+"列   "+"值");
//        for (int i = 0; i < sparseMatrix.length; i++) {
//            System.out.print(sparseMatrix[i][0]+"\t"+sparseMatrix[i][1]+"\t"+sparseMatrix[i][2]);
//        }
        for (int i = 1; i < totalNum+1; i++) {
            for(int j=0;j<3;j++){
                System.out.print(sparseMatrix[i][j]+"  \t");
            }
            System.out.println();
        }

        System.out.println("还原矩阵：");
        int [][]reduction = new int[11][11];
        for (int i = 1; i < totalNum+1; i++) {
            for(int j=0;j<3;j++){
                reduction[i][j] = sparseMatrix[i][j];
            }
        }
        
        for(int[] index1 :arr){
            for(int index2 :index1){
                System.out.print(index2+"\t");
            }
            System.out.println();
        }
    }

}