Java数组

01 什么是数组

02 数组的声明和创建

• 练习
  
  
  
  

public class Demo8 {
    public static void main(String[] args) {
        //如何使用数组
        //1.声明一个数组,创建一个数组
        //2.给数组赋值
        //3.数组的如何调用
        int[] num;
        int num1[];//数组的两种声明
        num =new int[10];//创建一个数组
        int[] nums2 =new int[10];
        
        //给数组元素赋值
        num[0]=1;
        num[1]=2;
        num[2]=3;
        num[3]=4;
        num[4]=5;
        num[5]=6;
        num[6]=7;
        num[7]=8;
        num[8]=9;
        num[9]=10;

        System.out.println(num[9]);

        //计算所有元素的和
        int sum=0;
        //获取数组的长度arrays.length
        for (int i = 0; i < num.length; i++) {
            sum=sum+num[i];
        }
        System.out.println("数组里元素的和为："+sum);

    }
}

03 内存分析

• 初始化分为静态和动态初始化
  

public class Demo10 {
    public static void main(String[] args) {
        //静态初始化 创建+赋值
        int [] arrays={1,2,3,4,5,6};
        System.out.println(arrays[0]);

        //动态初始化 默认初始化
        int[] arrays1=new int[10];
        arrays[0]=2;
        System.out.println(arrays[0]);

    }
}

04 下标越界及小结

05 数组的使用

• 练习
  

public class Demo12 {
    public static void main(String[] args) {
        //打印数组元素
        //数组作方法入参
        int[] arrays = {1, 2, 3, 4, 5,};
        printArray(arrays);
        System.out.println("=============");
        int[] reverse=reverse(arrays);
        printArray(reverse);
        //数组不能直接输出 System.out.println(result);
    }

    //数组作为参数，打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]);
            System.out.print('\t');
        }
        System.out.println("");
    }


    //数组作为返回值，反转数组
    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 - 1 - i];
        }
        return result;
    }

}

06 多维数组

• 练习
  

public class Demo13 {
    public static void main(String[] args) {
        //二维数组
        /*
        1，2 array[0]
        3,4  array[1]
        5.6  array[2]
        7,8  array[3]
         */
        //静态赋值
        int[][] arrays={{1,2},{3,4},{5,6},{7,8}};
        //动态赋值
        int[][] array=new int[4][4];
        array[0][0]=1;
        array[0][1]=2;
        System.out.println(array[0][0]=1);
        //二维数组长度
        System.out.println(arrays.length);
        System.out.println(arrays[0].length);
        System.out.println("=============");
        //输出二维数组里的所有元素
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.println(arrays[i][j]);
            }

        }
    }
}

07 arrays类

• 练习
  

import java.util.Arrays;

public class Demo14 {
    public static void main(String[] args) {
        int[] a={1,2,3,47,9,6};
        //打印数组 Arrays.toString
        System.out.println(Arrays.toString(a));
        printArrays(a);
        System.out.println();

        //数组排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //数组填充
        Arrays.fill(a,1);
        System.out.println(Arrays.toString(a));
    }

    //自己写一个打印数组的方法
    public static void printArrays(int[] b){
        for (int i = 0; i < b.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i<b.length-1){
                System.out.print(b[i]+", ");
            }

            if (i==b.length-1){
                System.out.print(b[b.length-1]+"]");
                //System.out.println("]");
            }
        }
    }
}

08 冒泡排序

• 原理
  
  

public class Demo15 {
    public static void main(String[] args) {
        int[] array={2,1,6,99,9,7,3};
        sort(array);
        System.out.println(Arrays.toString(array));

    }

    //冒泡排序
    public static void sort(int[] array){
        int temp=0;
        for (int i = 0; i <array.length-1; i++) {
            for (int j = i+1; j < array.length; j++) {
                if (array[i]>array[j]){
                    temp=array[i];
                    array[i]=array[j];
                    array[j]=temp;
                }
            }

        }
    }
}

09 稀疏数组

• 练习
  
  
  
  

public class Demo16 {
    public static void main(String[] args) {
        //创建一个二维数组 11/11
        int[][] array1=new int[11][11];
        array1[2][5]=6;
        array1[6][6]=10;
        //打印二维数组
        for (int[] array:array1){
            for (int arr:array){
                System.out.print(arr+"\t");
            }
            System.out.println();
        }
        System.out.println("=============================");
        //转为稀疏数组
        //1.得到有效值个数
        int sum=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("sum="+sum);
        //创建一个稀疏数组
        int[][] array2=new int[sum+1][3];
        int count=0;
        array2[0][0]=array1.length;
        array2[0][1]=array1.length;
        array2[0][2]=sum;
        //拿到数组里的值和坐标给稀疏数组赋值
        for (int i = 1; i < array1.length; i++) {
            for (int j = 1; j < array1.length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }
        //输出稀数组
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2.length; j++) {
                System.out.print(array2[i][j]+"\t");
                }
            System.out.println();
            }
        }
}

总结

关于稀疏数组，其实就是用另外一个形式来记录一个有很多空值的数组，从而节约内存空间
稀疏数组第零行 记录数组几行几列和有效值
稀疏数组第n行 记录数组有效值的坐标和值