JavaSE数组 2021.05.07-09

最新推荐文章于 2021-11-21 18:05:05 发布

Beckham_chen

最新推荐文章于 2021-11-21 18:05:05 发布

阅读量102

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/Beckham_chen/article/details/116507921

版权

JavaSE 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

时间是挤出来的，只要有时间就要投入学习，减少放松休闲时间！
放松好了就该好好学习！

在这里插入图片描述

数组的定义

数组是相同类型数据的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
其中每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。

数组声明创建

-首先必须声明数组变量，才能在程序中使用数组。声明数组变量的语法：

//变量的类型 变量的名字 = 变量的值； 
//数组类型
dataType[] arrayRefVar;//首选的方法，Java建议
dataType arrayRefVar[];//效果相同，但不是首选；C\C++风格

Java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的，数组索引从0开始
获取数组长度：

arrays.length

实例：

int[] nums; //1.声明一个数组（定义）
nums = new int[10];  //2.创建一个数组
// int[] nums = new nums[10]; 声明和创建可以总和成一句话

nums[0]=1; //3.给数组元素中赋值，没有赋值的是默认值，下标都是从0开始的。
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
nums[9]=10;

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

内存分析

在这里插入图片描述

声明数组
创建数组
赋值

三种初始化

静态初始化：创建+赋值

        int[] a = {1,2,3,4};
        Man[] mans= {new Man(1,1),new Man(2,2)};// 知道就行

动态初始化：包含默认初始化

        int[] a = new int[2];
        a[0]=1;
        a[1]=2;

数组的默认初始化
数组是引用类型，它的元素相当于实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的基本特点：

其长度是确定的，数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型，不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组边界

下标的合法区间：[0,length-1]，如果越界就会报错：
数组下标越界异常：java.lang.ArrayIndexOutOfBoundsException
小结：
1. 数组是相同数据类型（数据类型可以为任意类型）的有序集合
2. 数组也是对象。数组元素相当于对象的成员变量
3. 数组长度是确定的，不可变的。如果越界，则报错误：ArrayIndexOutOfBounds

数据的使用

        int[] a ={1,2,3,4,5};
        
        //打印全部的数组元素
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }

        //计算所有元素的和
        int sum=0;
        for (int i = 0; i <a.length ; i++) {
            sum+=a[i];
        }
        System.out.println("sum="+sum);

        //查找最大元素
        int max =a[0];
        for (int i = 1; i <a.length ; i++) {
            if (a[i]>max){
                max=a[i];
            }
        }
        System.out.println("max="+max);

For-Each循环（for增强）

        int[] a ={1,2,3,4,5};
        //JDK1.5 ；没有下标
        for (int i : a) {
            System.out.println(i);//遍历
        }

数组作方法入参
数组作返回值

    public static void main(String[] args) {
        int[] a ={1,2,3,4,5};

        printArray(a);//打印数组

        int[] reverse = reverse(a);
        printArray(reverse);//输出反转数组
    }

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

    //反转数组
    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;
    }

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
二维数组：

        int[][] a=new int[5][2];//可以看成是一个五行两列的数组

        int[][] arrays ={{1,2},{2,3},{3,4},{4,5},{5,6}};
        /*
          1,2 arrays[0]
          2,3 arrays[1]
          3,4 arrays[2]
          4,5 arrays[3]
          5,6 arrays[4]
         */
        System.out.println(arrays[2][0]);//输出结果为3
        System.out.println(arrays[2][1]);//输出结果为4

        System.out.println(arrays.length);//输出结果为5
        System.out.println(arrays[0].length);//输出结果为2

        for (int i = 0; i <arrays.length ; i++) {
            for (int j = 0; j <arrays[i].length ; j++) {
                System.out.print(arrays[i][j]+" ");
            }
            System.out.println("");
        }
        /*
        结果为：
        1 2
        2 3
        3 4
        4 5
        5 6
         */

Arrays类

数组的工具类 java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作
查看JDK帮助文档
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用，（注意：是“不用”而不是“不能”）
常用功能：
1. 给数组赋值：通过fill方法
2. 对数组排序：通过sort方法，按升序
3. 比较数组：通过equals方法比较数组中元素值是否相等
4. 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

①打印数组元素Arrays.toString()：

    public static void main(String[] args) {
        int[] a = {13,3,5245,24,343,434,1,5};
        System.out.println(a);//输出结果为 [I@1b6d3586

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

相当于自己手写的：

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

②数组进行排序：升序 Arrays.sort()：

        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

③数组填充：Arrays.fill()：

        Arrays.fill(a,1);//数组填充

        Arrays.fill(a,2,5,0);//数组下标为2与5之间填充0，即第3，4，5个元素填充为0

冒泡排序

冒泡排序是最为出名的排序算法之一，总共有八大排序！
冒泡的代码，两层循环，外层冒泡轮数，里层依次比较
看到嵌套循环，就可以得出这个算法的时间复杂度为O(n2)，即O的n次方。

    public static void main(String[] args) {
        int[] a = {12,41,43,1432,4,2};
        //冒泡排序
        //1.比较数组中，两个相邻的元素，如果第一个比第二个大，交换位置
        //2.每一次比较，都会产生出一个最大或者最小的数字
        //3.下一轮则可以少一次排序
        //4.依次循环，直到结束
        System.out.println(Arrays.toString(sort(a)));
    }

    public static int[] sort(int[] array){
        int temp=0;//临时变量

        for (int i = 0; i <array.length-1 ; i++) { //外层循环，判断走多少次
            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;
                }
            }
        }
        return array;
    }

稍微优化：

    public static int[] sort(int[] array){
        int temp=0;//临时变量

        for (int i = 0; i <array.length-1 ; i++) { //外层循环，判断走多少次

            boolean flag =false;//通过flag标识位减少没有意义的比较
            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;
                    flag=true;
                }
            }
            if (flag==false){
                break;
            }
        }
        return array;
    }

稀疏数组

稀疏数组是一种数据结构
压缩算法，让数据量变小
记录有效坐标、原始坐标的大小以及它的有效值，记录每一个值的坐标
当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
稀疏数组的处理方法是：
1. 记录数组一共有几行几列，有多少个不同值
2. 把具体不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
3. 如下图：左为原始数组，有为稀疏数组

操作例子：
在这里插入图片描述

①打印原始数组

        //创建一个二维数组 11*11  0：没有棋子 1：黑棋 2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2]= 1;
        array1[2][3]= 2;
        //输出原始数组
        System.out.println("输出原始数组：");
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array1[i].length ; j++) {
                System.out.print(array1[i][j]+"  ");
            }
            System.out.println();
        }

       /* for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        for-each循环
        */

在这里插入图片描述

②转换为稀疏数组

        //转换为稀疏数组
        //1.获取有效值的个数
        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);

        //2.创建一个稀疏数组的数组
        int[][] array2= new int[sum+1][3];

        array2[0][0]=array1.length;
        array2[0][1]=array1[0].length;
        array2[0][2]=sum;

        //3.遍历二维数组，将非零的值，存放在稀疏数组中
        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];
                }
            }
        }
        //4.输出稀疏数组
        System.out.println("输出稀疏数组：");
        for (int i = 0; i <array2.length ; i++) {
            for (int j = 0; j <array2[i].length ; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }

在这里插入图片描述
③还原

        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 i = 0; i <array3.length ; i++) {
            for (int j = 0; j <array3[i].length ; j++) {
                System.out.print(array3[i][j]+"  ");
            }
            System.out.println();
        }

在这里插入图片描述

Beckham_chen

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE数组 2021.05.07-09

时间是挤出来的，只要有时间就要投入学习，减少放松休闲时间！放松好了就该好好学习！数组的定义数组是相同类型数据的有序集合数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成其中每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。数组声明创建-首先必须声明数组变量，才能在程序中使用数组。声明数组变量的语法：//变量的类型变量的名字 = 变量的值； //数组类型dataType[] arrayRefVar;//首选的方法，Java建议dataType .
复制链接

扫一扫