遇见狂神说day08学Java

数组

1.相同类型数据的有序集合

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

3.其中，每一个数据成为一个数组元素，每个数组元素可以通过下标来访问他们

在创建的数组中，int类型没有赋值则是0，string类型没有赋值则是null

最重要：数组的长度是确定的，数组也是一个对象，new出来的

声明数组、创建数组、初始化数组

声明数组时，是在栈中进行，且并没有进行数组的创建，如图所示

数组的对象是在堆中，只要使用new关键词，都是在堆中的

public class Demo01 {
    public static void main(String[] args) {
        int[] nums;  //声明数组    这时，数组并不存在
        nums=new int[10];//定义数组
        nums[0]=1;
        nums[2]=2;
        nums[3]=3;
        int sum=0;
        //获取数组长度 array.length
        for (int i = 0; i < nums.length; i++) {
         sum+=nums[i];
        }
        System.out.println(sum);
    }
}
public class Demo02 {
    public static void main(String[] args) {
        //数组静态初始化   初始化+创建
        int[] nums={0,1,2,3,4,5};
        System.out.println(nums[0]);
        //数组动态初始化
        int[] b=new int[5];
        b[0]=3;
        b[1]=4;
        System.out.println(b[0]);
    }
}

注意数组下标越界异常，则会报错ArrayIndexOutOfBoundsException

数组的使用

public class Demo03 {
    public static void main(String[] args) {
        //打印所有的数组元素
        int[] nums={1,2,3,4,5};
        for (int i = 0; i < nums.length ; i++) {
            System.out.println(nums[i]);
        }
        //计算数组元素的和
        int sum=0;
        for (int i = 0; i < nums.length; i++) {
            sum+=nums[i];
            System.out.println("数组的和为"+sum);
        }
        //求最大值
        int max=nums[0];
        for (int i = 0; i < nums.length ; i++) {
            if(max<nums[i]){
                max=nums[i];
            }
        }
        System.out.println(max);
    }
}

增强型for循环

for(int：nums :num){}

二维数组

public class Demo05 {
    public static void main(String[] args) {
        //二维数组
        int[][] nums={{1,2},{3,4},{5,6}};
        for (int i = 0; i < nums.length ; i++) {
            for (int j = 0; j <nums[i].length; j++) {
                System.out.println(nums[i][j]);
            }
        }
    }
}

Arrays类

可以利用Arrays中的方法直接进行数组的输出、排序等操作

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        //Arrays类
        int[] nums={3,56,6,54,77,344,7778};
        //打印数组Arrays.toString
        System.out.println(Arrays.toString(nums));
        printArray(nums);
        //排列数组:升序Arrays.sort();
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums)) ;
    }

    //用常规方法自己打印
    public static void printArray(int[] nums)
    {
        for (int i = 0; i < nums.length; i++) {
            if (i==0){
                System.out.print("["+nums[0]);
            }
            if(i== nums.length-1){
                System.out.println("]");
            }else{
                System.out.print(","+nums[i+1]);
            }
            System.out.print("");
        }
    }
}

冒泡排序

此为嵌套循环，时间复杂度为o(n的平方)

public class Demo07 {
    public static void main(String[] args) {
        int[] a={4,5,323,33212556,7889,4343,323};
        int[] nums=sort(a);
        System.out.println(Arrays.toString(nums));
    }

    public static int[] sort(int[] num)
    {
        //需要；两层循环嵌套，一层是需要循环几次，一层是两个数进行交换
        int temp=0;
        boolean flag=false;
        for (int i = 0; i < num.length-1 ; i++) {
            for (int j = 0; j < num.length-1-i; j++) {
                if(num[j]>num[j+1]){
                    temp=num[j];
                    num[j]=num[j+1];
                    num[j+1]=temp;
                    flag=true;
                }
                else {
                    flag=false;
                }
            }
        }
        return num;
    }
}

稀疏数组

注：本小节中的增强for循环输出二维数组，很方便

public class Demo09 {
    public static void main(String[] args) {
        //创建矩阵
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //创建稀疏矩阵
        int sum=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[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 <11 ; i++) {
            for (int j = 0; j <11; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }

        }
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //还原稀疏矩阵
        System.out.println("还原稀疏矩阵");
        int[][] array3=new int[11][11];
        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();
        }
    }
}