Java数组

Java数组

1. 数组概述

• 相同类型的若干数据，按一定先后次序排列的有序集合
• 每个数据被称作一个数组元素，可通过他的下标来访问

2. 数组声明创建

1. 声明与创建

   • 首先声明数组变量

     int[] aname;//首选方法
     int aname[];
     

   • Java使用new操作符来创建数组

     int[] aname = new int[size];
     

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

   • 获取数组长度：arrays.length

2. 内存分析

   Java：

   • 堆
     • 存放new对象和数组
     • 可以被线程共享，不会存放在别的对象引用
   • 栈
     • 存放基本数据类型
     • 引用对象的变量，存放引用在堆地址
   • 方法区
     • 可以被线程共享
     • 包含所有class和static变量

3. 三种初始化

   • 静态初始化

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

   • 动态初始化

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

   • 数组默认初始化

     数组是引用类型，相当于类的实例变量，按同样方式隐式初始化。

4. 数组四个基本特点

   • 长度确定，大小不变
   • 元素必须是相同类型
   • 可任意类型
   • 数组变量是引用类型，数组对象存放在堆中

5. 数组下标越界

   • 下标合法区间：[0,length-1],越界报错.

     ArrayIndexOutOfBoundsException:数组下标越界异常

   • 小结:

     • 数组是相同类型有序集合
     • 数组是对象
     • 数组长度不可变，超出报越界异常

3. 数组使用

• for each

• 数组作方法入参

• 数组作返回值入参

  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.println(arrays[i]);
  //        }
          //2.for each
  //        for (int array:arrays) {
  //            System.out.println(array);
  //        }
          //3.调用入参方法
  //        printArray(arrays);
          //4.数组作返回值
          int[] reverse = reverse(arrays);
          printArray(reverse);
          System.out.println("=====================");
          int[][] array = {{1,2},{3,4},{5,6},{7,8}};
          for (int i = 0; i < array.length ; i++) {
              for (int j = 0; j < array[i].length ; j++) {
                  System.out.println(array[i][j]);
              }
          }
      }
  
      //3.方法入参
      public static void printArray(int[] arrays){
          for (int array:arrays) {
              System.out.println(array);
          }
      }
  
      //4.数组作返回值
      public static int[] reverse(int[] arrays){
          int[] result = new int[arrays.length];
          for (int i = 0; i < arrays.length ; i++) {
              result[i] = arrays[arrays.length-i-1];
          }
          return result;
      }
  

4. 多维数组

• 多维数组定义：可看成是数组的数组，二维数组是特殊的一维数组，其中每个元素都是一维数组。

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

5. Arrays类

1. 数组工具类Arrays:java.util.Arrays
2. 数组对象本身没什么方法，可调用Arrays类中的
3. 查看java API手册
4. Arrays类中方法有static修饰，可直接调用
5. 功能:
   • 给数组赋值:fill
   • 排序：sort,升序
   • 比较数组：equals,比较数组中元素是否相等
   • 查找数组元素：binarySearch,对已排序数组二分查找

public static void main(String[] args) {
        int[] a = {1,2,3,87,2678,431,17,77899};

        //System.out.println(a); //[I@531be3c5
        //1.输出数组
        //System.out.println(Arrays.toString(a)); //依次输出数组元素
        //自写toString
        //printArrays(a);

        //2.升序排序
        //Arrays.sort(a);
        //System.out.println(Arrays.toString(a));

        //3.填充
        //Arrays.fill(a,0);
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));

        //4.比较 ==与equals
        int[] b = a;
        System.out.println(a==b);
        System.out.println(Arrays.equals(a,b));
        Integer i1 = 128;
        Integer i2 = 128;
        System.out.println(i1==i2);
        System.out.println(i1.equals(i2));

        //5.二分查找
        System.out.println(Arrays.binarySearch(a,17));
        System.out.println(Arrays.binarySearch(a,77899));
    }

    public static void printArrays(int[] a){
        for (int i = 0; i < a.length ; i++) {
            if (i == 0){
                System.out.print("[");
            }
            if (i == a.length-1){
                System.out.print(a[i]+"]");
            }else{
                System.out.print(a[i]+", ");
            }
        }
    }

6. 稀疏数组

1. 介绍：
   • 一个数组大部分元素为0，或同一值可用稀疏算法
   • 处理方式：
     • 记录数组中一共几行几列，有多少个不同值
     • 把巨头不通知的元素和行列及值记录在小规模数组中，从而缩小规模

//稀疏数组
        //1.创建一个二维数组 0：无，1：黑棋，2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        System.out.println("输入原始数组");
        for (int[] ints:array1) {
            for (int anInt:ints) {
                System.out.print(anInt+"	");
            }
            System.out.println();
        }
        //2.稀疏数组
        int sum = 0;
        for (int i = 0; i < 11 ; i++) {
            for (int j = 0; j < 11 ; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("======================================");
        System.out.println("有效值个数："+sum);
        //打印稀疏数组
        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 < 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];
                }
            }
        }
        //输出
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array2.length ; i++) {
            System.out.println(
                    array2[i][0]+"	"+
                    array2[i][1]+"	"+
                    array2[i][2]+"	"
            );
        }

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