数组

数组

概述

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

数组描述的是相同类型的若干个数据，按照一定先后次序排列组合而成

其中每一个数据称为一个数组元素，每个数组元素可以通过一个下标来访问

package arrays;

public class Demo1 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6,7,8,9,0};//静态初始化

        int[] b = new int[10];//动态初始化，都有默认值0
        int[] nums;//声明一个数组
        nums = new int[10];//创建一个数组，分配十个存储空间，默认是0
        for (int i = 0;i < 10;i++)
        {
            nums[i] = i;
        }
        for (int x : nums) {
            System.out.println(x);
        }
    }
}

初始化

特点

package arrays;

public class Demo2 {
    public static void main(String[] args) {
        //foreach循环
        int[] a = {1,2,3,4,5,6};
        for (int x :
                reverse(a)) {
            System.out.println(x);
        }

    }
    //反转数组
    public static int[] reverse(int[] a){
        int[] result = new int[a.length];
        for (int i = 0,j = a.length - 1;i < a.length;j--, i++) {
            result[i] = a[j];
        }
        return result;
    }
}

二维数组

package arrays;

public class Demo3 {
    public static void main(String[] args) {
        int array[][] = {{12,12,22}
        ,{11}
        ,{234,23,10,24,26}};//二维数组就相当于数组里面嵌套数组
        for (int[] x : array) {//增强for循环，遍历第一层数组
            for (int s : x) {//再遍历第二层数组
                System.out.println(s);
            }
        }
    }
}

Arrays类

冒泡排序

package arrays;

public class Demo4 {
    public static void main(String[] args) {
        int[] array = {1,22,12,13,21,343,23,34,98,76,45};
        //冒泡排序
        int sum = 0;//设置记录运行次数
        int temp;
        for (int i = 0; i < array.length; i++) {
            boolean flag = false;//设置标签，减少运行次数
            for (int j = 1; j < array.length - i; j++) {
                if (array[j]<array[j - 1]){//如果前比后大，交换
                    temp = array[j - 1];
                    array[j-1] = array[j];
                    array[j] = temp;
                    flag = true;//如果交换了。则改变flag值
                }
                sum++;//记录运行次数
            }
            if (!flag) break;//去掉55次，添加34次
        }
        for (int x :
                array) {
            System.out.println(x);
        }
        System.out.println(sum);//
    }
}

稀疏矩阵

什么是稀疏数组

package arrays;

public class Demo5 {
    public static void main(String[] args) {
        //稀疏数组
        int [][] array = new int[11][11];
        array[3][4] = 4;
        array[5][7] = 1;
        array[1][5] = 7;
        array[9][3] = 9;
        for (int[] a : array) {
            for (int b : a) {
                System.out.print(b + "\t");
            }
            System.out.println();
        }
        System.out.println("==========================");
        int sum = 0;//计算数组中非0元素个数
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0)
                    sum++;
            }
        }
        System.out.println(sum);
        //将二维稀疏数组转换存储
        int array1[][] = new int[sum+1][3];
        array1[0][0] = array.length;
        array1[0][1] = array[0].length;
        array1[0][2] = sum;
        int count = 0;
        for (int i = 0; i < array.length; i++)
            for (int j = 0; j < array.length; j++)
                if (array[i][j] != 0){
                    count++;
                    array1[count][0] = i;
                    array1[count][1] = j;
                    array1[count][2] = array[i][j];
                }
        //遍历array1
        for (int[] a : array1) {
            for (int b : a)
                System.out.print(b + "\t");
            System.out.println();
        }
        //将array1转换为二维数组
        System.out.println("==============");
        int array2[][] = new int[array1[0][0]][array1[0][1]];
        for (int i = 1; i < array1.length; i++) {
            array2[array1[i][0]][array1[i][1]] = array1[i][2];
        }
        for (int[] a : array2) {
            for (int b : a) {
                System.out.print(b + "\t");
            }
            System.out.println();
        }
    }
}