本文主要是介绍数组，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

数组

数组定义

• 数组是一个相同类型的有序集合

• 每一个数据是数组元素，可以通过下标来访问它们

数组声明创建

//dataType[] arratRefVar  正常是这格式 
int[] numbers = new int[10];

这样就是一个numbers数组的创建了，这个数组的长度为10，也就是里面可以存放10个数组元素

三种初始化方式

• 静态初始化

  //创建 + 赋值
  int[] a = {1, 2, 3, 43, 231}
  //也可以是类 
  //Class[] class = {new Class(1, 2), new Class(4, 2)};

• 动态初始化

  int[] b = new int[2];
  b[0] = 3;
  b[1] = 42;

动态初始化我们就要给他开辟一块空间，然后要给它手动的去赋值

• 默认初始化

  这个是包含在动态初始化里面的

  数组是一个引用类型，一旦数组分配了空间，它的每个元素也会按照实例变量类型相同方式被隐式初始化，比如int类型数组，像上面一个new int[2]那么b[0] b[1]就默认赋值0，如果是double数组b，那就是0.0，其他类型就是null

数组的特点

• 数组一经创建，他的大小就不变了
• 数组内所有元素都保持一致，int就是int 不允许又是int又是String混合
• 数组元素可以是任何类型，可以是基本类型 也可以是引用类型
• 数组本身就是一个引用类型，可以看成一个对象，每个数组元素就相当与这个对象的成员变量，Java中对象是在堆里的，所以数组无论保存原始类型，还是对象类型，数组也是在堆里的。

数组的使用

• for-each循环

  int[] a = {1, 32, 223, 321, 1};
  for (i = 0; i < a.length; i++){
      System.out.print(a[i] + "\t");
  }

这个for-each循环就是遍历数组，然后可以访问到数组的每一个下标，然后给他打印出来

• 数组做方法入参

  实际上就是增强for循环

  int[] arrays = {1, 32, 223, 321, 1};
  for (int array : arrays) {
      System.out.print(array);
  }

这个array就数组arrays里的数组元素，这个增强for循环就是遍历arrays数组，然后打印每一个元素，这个方法适合打印输出数组。比较遗憾的是这个方法并不能访问数组的下标，有时候要通过访问下标来进行一些操作的时候还是得靠for-each循环呐。

• 数组当返回值

  public static void main(String[] args) {
  	int[] array = {1, 32, 223, 321, 1};
      printArray(array);
  }
  static void printArray(int[] arrays){
      for (i = 0; i < arrays.length; i++){
          System.out.print(arrays[i] + "\t");
      }
  }

这样就是把array传值给printArray方法，然后就打印出数组array了

二维数组

看成数组的数组，类比数学里的集合的集合，很好理解

//把这个二维数组当成数组套数组
//先定义 然后分配空间，便于理解可以看成一个2*3的矩阵
//然后他的下标就是00 01 02  10 11 12 还是有规律的
int[][] a = new int[2][3];
//现在数组a的状态就是 a = {{0，0，0}，{0，0，0}} 集合的集合 和数学里的那个一模一样

通过二维数组也可以类推出三维，四维，或更高维的数组，也会去使用了

毕竟下标是唯一的，弄清楚下标也就明白数组的一些操作，当然实际上也用不到三四或者高维的数组常用的多维数组也是二维数组，也很好理解

冒泡排序

经典排序

    public static void main(String[] args) {
//        经典冒泡排序
        int[] array = {1, 8, 62, 47, 2, 65, 4};
        for (int i = 0; i < array.length - 1; i++) {//这里数组长度为7 两两对比6个大循环就可													  //以循环完毕
            for (int j = 0; j < array.length - 1 - i; j++) {
                //i的每一次循环完毕，
                // 自然保证有一个最大的数在后面，需要对比的数字就少一个，这样循环次数就会少i次
                int temp = 0;
                if (array[j+1] < array[j]){//如果前一个数比后一个数小，那么就交换位置，这样保											//证有一个最大的数字在后面
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        //这里用到Arrays类的toString方法
        System.out.println(Arrays.toString(array));

    }

稀疏数组

稀疏数组就是一个压缩数组的一个方法

比如 0 0 2 0 0 这个数组就是4*5的数组 有效值两个 坐标(0, 2) (1, 1)
0 1 0 0 0 行 列 有效值
0 0 0 0 0 4 5 2
0 0 0 0 0 0 2 2
1 1 1

这样就把一个4×5的数组压缩成一个 3×3的数组了 稀疏数组的第0行存放的是原数组的行 列 有效值个数，从第1行开始存放的就是有效值的下标，第三列就是有效值的值，当然也可以通过稀疏数组来还原原数组。

​

public class SparseArray {
    //稀疏数组
    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        array[2][1] = 1;


        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("=====================");
        //获取有效值个数
        int sum = 0;
        for (int[] ints : array) {
            for (int anInt : ints) {
                if (anInt != 0){
                    sum ++;
                }
            }
        }
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = array.length;
        sparseArray[0][1] = array[0].length;
        sparseArray[0][2] = sum;
        int count = 0;//获取稀疏数组的行号
        //遍历原数组，获取横纵下标，值并赋给稀疏数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                if (array[i][j] != 0){
                    count ++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = array[i][j];
                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < sparseArray.length; i++) {
            System.out.println(sparseArray[i][0] + "\t"
                    + sparseArray[i][1] + "\t"
                    + sparseArray[i][2] + "\t");
        }
        System.out.println("=====================");
        //还原稀疏数组
        //从稀疏数组第一行开始遍历，i行第1列是横坐标，i行第2列是纵坐标，i行第3列是存放的值
        int[][] array1 = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
                array1[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //打印数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

这篇关于数组的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！