其他分享
首页 > 其他分享> > 数组

数组

作者:互联网

数组

数组定义

数组声明创建

//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[] a = {1, 32, 223, 321, 1};
  for (i = 0; i < a.length; i++){
      System.out.print(a[i] + "\t");
  }

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

  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();
        }
    }
}

标签:sparseArray,int,System,数组,array,out
来源: https://www.cnblogs.com/shiranai/p/15440778.html