Java数组

在无清风

于 2022-05-01 13:15:29 发布

阅读量156

点赞数

文章标签： java 排序算法算法

本文链接：https://blog.csdn.net/qq_53573029/article/details/123994545

版权

数组的定义

数组是相同类型数据的有序集合。(在一个数组只能存在一个类型，不能有两个不同的类型，一个数组都为int（double,string等）不能一个数组元素为int，一个数组元素为double。)
数组描述的是相同类型的若干个数据，按照一定先后顺序排列组合而成
其中，每一个数据称作一个数组元素，每一个数组元素可以通过下标来访问它们。（数组同通过下标来确定数组元素）

实例

定义数组
有两种方法定义数组

int[] nums1;//1.定义(主流)
int nums2[];//2.定义

实例化（两种方法）

        nums1 = new int[10];  
        nums1[0] = 1;
        nums1[1] = 2;
        nums1[2] = 3;
        nums1[3] = 4;
        nums1[4] = 5;
        nums1[5] = 6;
        nums1[6] = 7;
        nums1[7] = 8;
        nums1[8] = 9;
        nums1[9] = 10;

        nums1 = new int[10];
for (int i = 0; i < nums1.length; i++) {
            nums1[i] = i+1;
        }

循环打印

 for (int i = 0; i < nums1.length; i++) {
            System.out.println(nums1[i]）;
        }

数组求和

        int sun = 0;
        for (int i = 0; i < nums1.length; i++) {
            sun += nums1[i];
        }

反转数组

反转数组顾名思义就是从后向前输出数组如果数组输出是1，2，3，4反转后就因该输出的是4，3，2，1.这就是反转数组。

代码

package com.kuang.array;

public class ArrayDome02 {
    public static void main(String[] args) {
        int[] arrays = {1,2,4,3,5};
        int[] reverse = reverse(arrays);
        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[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]+"");
        }
    }
    //
}

输出结果：

二维数组

就向下x,y轴一样（下标从0开始）

x y
1 2
3 4
6 7

代码
定义二维数组

int[][] array = {{1,2},{3,4},{6,7}};
        System.out.println(array[1][0]);

遍历二维数组

int[][] array = {{1,2},{3,4},{6,7}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[j].length; j++) {
                System.out.println(array[i][j]);
            }
        }

Arrays类

常用功能

给数组赋值：通过fill方法

//fill填充为0
        int[] arr1 = new int[10];
        Arrays.fill(arr1,0);
        System.out.println(Arrays.toString(arr1));

对数组排序：通过sotr方法，按升序

//sort排序
        int[] arr = {5,1,6,3,6,7,4};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

比较数组：通过equals方法比较数组中元素值是否相等

//equals判断
        int[] arr3 = {5,1,6,3,6,7,4};
        int[] arr4 = {5,1,6,3,6,7,4};
        int[] arr5 = {2,1,3,3,5,4,9};
        boolean arr34 =  Arrays.equals(arr3,arr4);
        boolean arr35 = Arrays.equals(arr3,arr5);
        System.out.println(arr34);
        System.out.println(arr35);

查找数组元素：通过binarySearch方法能对排序好的进行二分查找操作

冒泡排序

介绍：
1. 比较数组中的相邻的元素，如果第一个数组比第二个数大，我们就交换他们的位置。
2. 并且每一次比比较都会产生出一个最大或最小的数字。
3. 下一轮，就少一次排序，直到结束。

代码

  public static void main(String[] args) {
        int[] arr = {1,2,3,7343,56,544,6,4,56,34,4,3};
        System.out.println("排序前:"+Arrays.toString(arr));
        int[] sort =sort(arr);
        System.out.println("排序后:"+Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length; i++) {
            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
            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;
                }
            }
        }
        return array;
    }

输出结果：

稀疏数组

介绍：
1. 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用洗漱数组保存该数组
2. 洗漱数组的处理方式事：
  1. 记录数组一共有几行几列，有多少个不同的值
  2. 八具有不同值的元素和行列及值记录在一个小规模数组中，从而缩小程序的规模
3. 左边是原始数组，右边是稀疏数组

代码：输出棋盘

package com.kuang.array;

public class ArrayDemo06 {
    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] = 1;
        //输出原始的数组
        System.out.println("输出原始的数组");

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


    }
}

输出结果：

代码：稀疏数组实现和还原

package com.kuang.array;

public class ArrayDemo06 {
    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] = 1;
        //输出原始的数组
        System.out.println("输出原始的数组");

        for(int[] ints:array1){
            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 (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //2.创建一个稀疏数组的数组
        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("===============================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        //如果i给0会下表
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][0];
        }
        //3.打印
        System.out.println("输出还原的数组");
        for(int[] ints:array3){
            for (int anInt : ints ){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

输出结果：

代码来源以及讲解均为j 狂神说Java使用的代码。

在无清风

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java数组

数组的定义数组是相同类型数据的有序集合。(在一个数组只能存在一个类型，不能有两个不同的类型，一个数组都为int（double,string等）不能一个数组元素为int，一个数组元素为double。) 数组描述的是相同类型的若干个数据，按照一定先后顺序排列组合而成其中，每一个数据称作一个数组元素，每一个数组元素可以通过下标来访问它们。（数组同通过下标来确定数组元素）...
复制链接

扫一扫