Java基础笔记-数组

Java基础笔记-数组

一、练习代码

public class Demo003 {
    public static void main(String[] args) {
        //静态初始化
        int[] arr = {1, 2, 3, 4, 5};

//        增强for循环
        for (int i : arr) {
            System.out.println(i);
        }
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
//        所有数字之和
        System.out.println(sum);
//        查找最大元素
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println(max);
//动态初始化
        int[] b = new int[4];
        System.out.println(b.length);
        printArray(arr);
        int[] reverse = reverse(arr);
        printArray(reverse);
    }

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

    }

    //打印数组方法
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

二、数组

1、什么是数组

数组就是存储长度的固定容器,存储多个数据的数据类型要一致。

格式1：数据类型[] 数组名

int[] arr;
double[] arr;
char[] arr;

格式2：数据类型 数组名[]

int arr[];
double arr[];
char arr[];

什么是动态初始化:数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

动态初始化格式:数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];

等号左边： int:数组的数据类型

[]:代表这是一个数组

arr:代表数组的名称 等号右边：

new:为数组开辟内存空间

int:数组的数据类型

[]:代表这是一个数组

5:代表数组的长度

索引 :每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

2、数组的四个基本特点

1、其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。其元素必须是相同类型,不允许出现混合类型。
2、数组中的元素可以是任何数据类型，包括基本类型和引用类型。
3、数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就4、是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

3、二维数组

简单理解就是嵌套关系-数组里面有数组

public class Demo004 {
    public static void main(String[] args) {

        int[][] array = {{1, 2}, {2, 3}, {3, 4}, {5, 6}};

//        遍历二维数组
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

示例图：

4、冒泡排序

public class Demo002 {

    public static void main(String[] args) {
        int[] a = {3, 6, 4, 8, 4, 1, 5, 6, 3, 9};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));

    }

    public static int[] sort(int[] array) {
        int temp = 0;
        //外层判断比较次数
        for (int i = 0; i < array.length - 1; i++) {
            //判断无效比较
            boolean flag=false;
            //内层判断大小 交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] =temp;
                    flag=true;
                }
            }
            if (flag==false){
                break;
            }
        }
        return array;
    }
}

5、稀疏数组

public class Demo005 {

    public static void main(String[] args) {
//        创建二维数组  棋盘
        int[][] array = new int[11][11];
//        第一列第二行等于1
        array[1][2] = 1;
//        第二列第四行等于2
        array[2][4] = 2;

        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("=========================");
//        转换稀疏数组  获取有效个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array[i][j] != 0) {
                    sum++;
                }
            }
        }
        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 < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[i][j];
                }
            }
        }
//遍历稀疏数组
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t" +
                    array2[i][1] + "\t" + array2[i][2]);
        }
        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+"\t");
            }
            System.out.println();
        }
    }
}