java 数组

数组

一、数组特点：

1. 长度是确定的，数组一旦被创建，则它的大小就不可以改变，下标不可以越界
2. 数组的元素必须都是相同类型的，不允许出现混合类型
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
4. 数组变量属于引用类型，也可看成是对象，数组中的每个元素相当于该对象的成员变量

    public static void main(String[] args)
    {
        int[] arr=new int[10];//声明并且创建数组
        arr[0]=1;
        arr[1]=2;
        arr[2]=3;
        arr[3]=4;
        arr[4]=5;
        arr[5]=6;
        arr[6]=7;
        arr[7]=8;
        arr[8]=9;
        System.out.println(arr[1]);//2
        System.out.println(arr[9]);//0 如果没有赋值的话，输出默认值0

        int sum=0;
        for (int i = 0; i < arr.length; i++) {//length属性是数组的长度
            sum=sum+arr[i];//求数组的和
        }
        System.out.println(sum);//45
    }

 public static void main(String[] args)
    {
        int[] a={1,2,3,4}; //静态初始化，不用new
        System.out.println(a[0]);//1
        
        int[] b=new int[4]; //动态初始化
        b[0]=1;
        b[1]=1;
        b[2]=2;
        System.out.println(b[3]);//0,若是没有初始化则输出默认值0
    }

二、数组的使用

 public static void main(String[] args)
    {
        //动态初始化
//        int[] arr=new int[3];
//        arr[0]=1;
//        arr[1]=2;
//        arr[2]=3;
        //静态初始化
        int[] arr={1,2,3};
        for (int i = 0; i < arr.length; i++)
        {
            System.out.println(arr[i]);
        }
        int max=arr[0];
        for (int i = 0; i < 3; i++) {
            if(arr[i]>max)
            {
                max=arr[i];
            }
        }
        System.out.println("最大值为："+max);//最大值为：3
    }

三、数组的应用

 public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        int[] result=reserve(array);//接收反转后的数组
        print(array);//打印原数组
        print(result);//打印反转后的数组
    }
    public static void print(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
    public static int[] reserve(int[] arrays) {//返回值是数组
        int[] b = new int[arrays.length];
        for (int i = 0, j = b.length - 1; i < arrays.length; i++, j--) {
            b[j] = arrays[i];
        }
        return b;
    }

四、二维数组

  public static void main(String[] args)
    {
        int[][] array={{1,2},{3,4},{5,6}};
        print(array);
    }
    public static void print(int[][] array)
    {
        for (int i = 0; i < array.length; i++) {//行数
            for (int j=0;j<array[i].length;j++)//列数
            {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }

五、Arrays类使用

 public static void main(String[] args)
    {
        int[] arr={2,3,4,5};
        System.out.println(Arrays.toString(arr));//[2, 3, 4, 5]
    }

public static void main(String[] args)
    {
        int[] arr={2,3,4,5};
        for (int i = 0; i < arr.length; i++) {
            if (i==0)
            {
                System.out.print("["+arr[i]+", ");
            }else if(i==arr.length-1)
            {
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+", ");
            }
        }

 public static void main(String[] args)
    {
        int[] arr={8,3,1,5};
        Arrays.sort(arr);//排序
        System.out.println(Arrays.toString(arr));//[1, 3, 5, 8]
    }

六、冒泡排序

1.比较数组中两个相邻元素的大小，交换位置
2.每一次比较都会产生一个最大或最小值
3.下一轮就可以少一次排序
4.依次循环，直至结束
5.时间复杂度O(n^2)

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

    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]>array[j+1])//符合条件则进行交换
                {
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
            if(!flag)
            {
                break;
            }
        }
        return array;
    }

七、稀疏数组

//1.创建二维数组
int[][] arr1=new int[5][5];
        arr1[1][2]=1;
        arr1[2][3]=2;
        System.out.println("原始数组：");//2.输出原始的数组
        for(int[] ints:arr1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
/*
原始数组：
0	0	0	0	0	
0	0	1	0	0	
0	0	0	2	0	
0	0	0	0	0	
0	0	0	0	0	
*/

 //3.获取有效值的个数
int sum=0;
        for (int i = 0; i < 5; i++) {
            for (int j=0;j<5;j++){
                if(arr1[i][j]!=0)
                {
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数为："+sum);
//有效值的个数为：2

 //4.创建稀疏数组保存
int[][] arr2=new int[sum+1][3];
        arr2[0][0]=5;//行数
        arr2[0][1]=5;//列数
        arr2[0][2]=sum;//有效值个数

        int count=0;
        for (int i = 0; i < arr1.length; i++) {//5.遍历二维数组，将非零的值存放在稀疏数组中
            for (int j = 0; j < arr1[i].length; j++) {
                if (arr1[i][j]!=0)
                {
                    count++;
                    arr2[count][0]=i;
                    arr2[count][1]=j;
                    arr2[count][2]=arr1[i][j];
                }
            }
        }
        for (int i = 0; i <arr2.length ; i++) {
            System.out.println(arr2[i][0]+"\t"+arr2[i][1]+"\t"+arr2[i][2]);//打印出稀疏数组
        }
/*
5	5	2
1	2	1
2	3	2
*/

 
int[][] arr3=new int[arr2[0][0]][arr2[0][1]];//6.还原稀疏数组
        for (int i = 1; i < arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]]=arr2[i][2];
        }
        for(int[] ints:arr3) {//增强for循环，打印数组
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
/*
0	0	0	0	0	
0	0	1	0	0	
0	0	0	2	0	
0	0	0	0	0	
0	0	0	0	0	
*/