数组的使用和Arrays类

@Small_Dragon

已于 2023-04-17 08:38:21 修改

阅读量48

点赞数

文章标签：数据结构

于 2023-03-29 21:05:22 首次发布

本文链接：https://blog.csdn.net/qq_53611790/article/details/129818403

版权

数组的定义

数组声明和创建

内存分析

三种初始化

数组的四个特点

数组的使用

package com.zhou.array;

public class ArrayTest03 {
    public static void main(String[] args) {
      int a[]={1,2,3,4,5};
    printArrays(reverse(a));
    }
    //翻转数组
    public static int[] reverse(int[]a){
        int result[]=new int[a.length];
        for (int i = 0,j=a.length-1; i < a.length; i++,j--) {
          result[j]=a[i];
        }
        return result;
    }
   //遍历数组方法
    public static void printArrays(int[]a){
        for (int i = 0; i <a.length ; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

nt[]a={1,2,3,4,5};
    //JDK1.5 没有下标
        for (int array: a) {
            System.out.print(array);
        }

多维数组

package com.zhou.array;

public class ArrayTest05 {
    public static void main(String[] args) {
        /*
        * 1,2  a[0]
        * 2,3  a[1]
        * 3,4  a[2]
        * 4,5  a[4]
        * */
        int[][]a={{1,2},{2,3},{3,4},{4,5}};
        System.out.println(a[0][0]);
        System.out.println(a[0][1]);
        System.out.println(a[1][0]);
        System.out.println(a[1][1]);
        System.out.println("==============");
        System.out.println(a.length);
        System.out.println(a[0].length);
        System.out.println("===============");
        for (int i = 0; i <a.length ; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.println(a[i][j]);
            }

        }

    }
}

Array类

package com.zhou.array;

import java.util.Arrays;

public class ArrayTest06 {
    public static void main(String[] args) {
    int[]a={1,2,3,78,89,9985,889};

        // 打印数组元素Arrays.toString
      System.out.println(Arrays.toString(a));

        //数组进行排序
//        Arrays.sort(a);
//        printArrays(a);

        //数组填充

//        Arrays.fill(a,0);

        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));

    }


     public static void printArrays(int[]a){
         for (int i = 0; i <a.length ; i++) {
             if (i==0){
                 System.out.print("[");
             }
             if (i==a.length-1){
                 System.out.print(a[i]+"]");
             }else {
                 System.out.print(a[i]+", ");
             }

         }
     }
}

冒泡排序

package com.zhou.array;

import java.util.Arrays;

public class ArrayTest07 {
   /*
   * 1.比较数组中，两个相邻的元素，如果第一个数比第二数大，我们就交换他们的位置
   * 2.每一次比较，都会产生出一个最大，或者最小的数字；
   * 3.下一轮则可以少一次排序！
   * 4.依次循环，直到结束！
   * */


    public static void main(String[] args) {
        int[] a={1,8,65,7,36,45};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));

    }
    public static int[] sort(int[]a){
        //临时变量
        int temp=0;
        //外层循环，判断我们这个要走多少次；
        for (int i = 0; i < a.length-1; i++) {
            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
            for (int j = 0; j < a.length-1-i; j++) {
                //因为a[j+1] 所有要a.length-1避免下标溢出
                if (a[j+1]<a[j]){
                   temp=a[j+1];
                   a[j+1]=a[j];
                   a[j]=temp;
                }
            }
        }

       return a;
    }
}

稀疏数组

本质就是记录有效值的坐标

package com.zhou.array;

public class ArrayTest08 {
    public static void main(String[] args) {
        // 1.创建一个二维数组 11*11  0：没有棋子， 1:黑棋   2：白棋
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组");

        for (int[] ints : array1) {
            for (int anInt: ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i <11 ; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //2.创建一个稀疏数组的数组
        //有效值sum + 1 是行数 数组下标是从0开始 列是固定的3
        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 < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }

        }
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
        }
        System.out.println("还原");
     //1.读取稀疏数组
        int[][]array3=new int[array2[0][0]][array2[0][1]];
     //2.给其中的元素还原它的值
        for (int i=1;i<array2.length;i++){
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
     //3.打印
        System.out.println("输出还原始的数组");

        for (int[] ints:array1) {
            for (int anInt:ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}