数组的整理

小白程序员的翻身之旅

于 2021-06-07 20:32:16 发布

阅读量233

点赞数 1

分类专栏：公益普及文章标签：数组稀疏数组冒泡排序 Arrays 多维数组

本文链接：https://blog.csdn.net/sinat_40775402/article/details/117649083

版权

公益普及专栏收录该内容

32 篇文章 0 订阅

订阅专栏

【小白数组语录】

数组的概念有点抽象，

命名规范死记硬背也可以，但是对于我这脑袋不够用的很容易前面学后面忘，知道黑熊掰棒子吧！！！

什么动态数组、静态数组，跟天书一样！！！

数组能解决哪些问题？学习成绩为啥要放到数组里？Excel不行吗？

~~~

数组概念

通俗来说数组就是相同类型的一组数据（相同类型如有疑惑，请看数据类型知一二）

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

看到这张图片你懂我的意思你吗？

图中人数为17人，别看他们球服的号码，假设我给球服重新编码从0-16，从左到右从上到下依次编号，当我说道5号时，是不是站着的人中的第一high对应的就是5号？

这一步懂了，基本数组也就没什么问题了。

数组声明创建

对比变量的定义：数据类型变量名 = 变量的值；

数组的创建：

声明数组变量：数组类型数组名 = new 数组类型[元素个数]；

数组类型数组名 = {数组元素1，数组元素2，数组元素3，```};

依然以球员为例：

/**
图片中有17个球员，对应的姓名依次是张三、李四、王五···
现在需要创建数组，并给与赋值
静态初始化
动态初始化
默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化
*/
//第一种方式：动态初始化，包含数组的默认初始化
String[] players = new String[17];//1、声明一个数组并创建
players[0]="张三"；//2、给数组元素赋值
players[1]="李四"；//
players[2]="王五"；//
...
players[16]="杜十九";//

//第二种方式：静态初始化：创建+赋值

String[] players = {"张三","李四","王五",```，"杜十九"};

数组特点：

1、长度确定，一旦被创建，大小是不可以被改变的，获取数组长度的方法：数组名.length;

2、数组元素必须是相同类型，不允许出现混合类型；（思考：想要出现混合类型如何解决？）

3、数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型；

4、数组变量属于引用数据类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量；

5、数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。（待更：堆和栈）

数组边界：

在数组概念介绍时我们提到了角标的问题，那么此处提到的边界即为角标的取值。

下标的合法区间：[0,length-1],如果超过length-1，则会报错数组角标越界。

ArrayIndexOutOfBoundsException:数组角标越界异常

数组使用

遍历数组元素（任何数据类型都会被用到）

//遍历数组中的元素
int[] arrays = {23,18,21,45,35};
for(int i = 0;i<arrays.length;i++){
    System.out.println(arrays[i]);
}

int类型数组中元素的各种运算（求和、求最大值元素）用于整数型、浮点型

/**
数组中元素的运算：各元素之和、元素的最大值
*/

//数组中各元素之和
int sum = 0;
for(int i = 0;i<arrays.length;i++){
    sum += arrays[i];
}

System.out.println(sum);>

//数组中元素的最大值

int max = arrays[0];
for(int i = 0;i<arrays.length;i++){
    if(arrays[i]>max){
        max=arrays[i];
    }
}

System.out.println(max);

练习：根据上述代码的实现尝试写出数组元素的最小值

进阶使用：增强for循环遍历每一个数组（for-each）

//增强for循环的格式    for（数组元素：数组名）{}

int[] arrays = {23,21,34,54,25};

for(int array:arrays){
    System.out.println(array);
}

数组做返回值入参——打印数组元素（自写方法）


public static void main(String[] args){
    int[] arrays = {23,21,34,54,25};

    printArray(arrays);
}


//自主设计遍历数组的方法printArray
public static void printArray(int[] arrays){
    for(int i=0;i<arrays.length;i++){
        System.out.print(arrays[i]);
    }
}

数组做返回值——反转数组

public static void main(String[] args){
    int[] arrays = {23,21,34,54,25};

   int[] reArray = reverse(arrays);

    printArray(reArray);

//通过上面两种方法的调用回顾一下有返回值和无返回的方法的调用方式
}

//反转数组设计(即新的数组为原数组元素倒序排列)
public static int[] reverse(int[] arrays){
    int[] reArray = new int[arrays.length]
    for(int i=0,int j=reArrays.length-1;i<arrays.length;i++,j--){

        reArray[j]=arrays[i];
    }

    return reArray;

}

//自主设计遍历数组的方法printArray
public static void printArray(int[] arrays){
    for(int i=0;i<arrays.length;i++){
        System.out.print(arrays[i]);
    }
}

多维数组

多维数组又称为数组的数组，如：二维数组为一个特殊的一维数组，其每个元素都是一个一维数组；
二维数组的表现形式给

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


int[][] a = {{12,2},{13,3},{11,2},{12,4},{5,3}};

二维数组的遍历

int[][] arrays = {{12,2},{13,3},{11,2},{12,4},{5,3}};

for(int i=0;i<arrays.length;i++){

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

Arrays类

java 工具类中的包装类，即java.util.Arrays

小白的困惑：现有的程序中并没有Arrays相关的代码，为什么能够直接用Arrays.toString()方法？

解答疑惑： 大家是否还记得前面学习的Scanner类，当我们在程序中引入该类时，类名的上方会出现一个java.util.Scanner; 类似均为java常用工具类中已经封装好的类，具体为什么能用等到我们在面向对象（封装、继承、多态）时会深入的讲解，当前你仅需记住包装类为java工具类时，工具类中的方法是可以任意调用的。

由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而对数据对象进行一些基本的操作。

Arrays类中方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（当然可以用对象来调用，只是常见使用方法直接用类名调用）

常见方法使用

遍历数组中的元素：通过toString方法

import java.util.Arrays;
public class Demo{
public static void main(String[] args){
    int[] a = {100,25,333,64,777,123};

    //打印数组元素时，大家就会想到直接打印a，但是a是打的地址值

    //引入一种打印数组元素的方法，即Arrays包装类中的toString方法
    System.out.println(Arrays.toString(a));

    }
}

给数组赋值：通过fill方法

import java.util.Arrays;
public class Demo{
public static void main(String[] args){
    int[] a = {100,25,333,64,777,123};

   //填充数组中的元素，fill方法有各种重载方法，此处仅示例一种
    Arrays.fill(a,1000);
    System.out.println(Arrays.toString(a));//此时数组的每个元素都变成1000
    }
}

给数组排序：通过sort方法（升序）

import java.util.Arrays;
public class Demo{
public static void main(String[] args){
    int[] a = {100,25,333,64,777,123};

   //数组排序（升序）用sort方法
    Arrays.sort(a);
    System.out.println(Arrays.toString(a));//此时数组元素依次为[25,64,100,123,333,777]
    }
}

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

import java.util.Arrays;
public class Demo{
public static void main(String[] args){
    int[] a = {100,25,333,64,777,123};
    
    int[] b = {100,25,333,64,777,123};

    boolean judge = a.equals(b);//返回值类型是boolean类型
  
    System.out.println(judge);
    }
}

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

该部分代码作为独立查找API，然后实践的过程，记得一定要练哦！

拓展：

冒泡排序

比较数组中，两个相邻元素，如果第一个元素比第二个元素大，交换位置；
每一次比较都会产生一个最大，或者最小的数字；
下一轮则可以少一次排序；
依次循环，直到结束。

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+1]>array[j]){
                temp=array[j];
                array[j]=array[j+1];
                array[i]=temp;

            }
        }

    }
    return array;
}

稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组时，可以用稀疏数组来保存该数组。

处理方式：

记录数组总共的行和列，有多少个不同值；

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

左侧为原始数组，右侧为稀疏数组

public static void main(String[] args){
    //创建一个二维数组6*7,0代表无数据，凡是含有数据的均注明数据大小
    int[][] array1=new int[6][7];
    array1[0][3] = 22;
    array1[0][6] = 15;
    array1[1][1] = 11;
    array1[1][5] = 17;
    array1[2][3] = 6;
    array1[3][5] = 39;
    array1[4][0] = 91;
    array1[5][2] = 28;

    System.out.prinln("输出原始数组");

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


    //转换为稀疏数组保存
    //1.获取有效值个数
    int count=0;
    for(int i=0;i<6;i++){
        for(int j=0;j<7;j++){
            if(array1[i][j]!=0){
                count++;
            }
        }

    }

    System.out.println("有效值的个数"+count);
    
    //2.创建一个稀疏数组的数组
    int[][] array2=new int[count+1][3];
    
    array2[0][0] = 6;
    array2[0][1] = 7;
    array2[0][2] = count;
    
    //3、遍历原二维数组，将非零的值，存放在稀疏数组中
    int count1=0;
    for(int i=0;i<array1.length;i++){
        for(int j=0;j<array1[i].length;j++){
            if(array1[i][j]!=0){
                count1++;
                array2[count1][0]=i;
                array2[count1][1]=j;
                array2[count1][2]=array1[i][j];
            }


        }
    }

    //输出稀疏数组
    System.out.println("稀疏数组");
    for(int i=0;i<array2.length;i++){
        System.out.println(array2[i][0]+"\t"+array[i][1]+"\t"+array[i][2]+"\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[] ints:array3){
        for(int anInt:ints){
            System.out.print(anInt+"\t");
        }
    }
 }

一口老气终于将数组介绍完了，大家慢慢看，切忌心浮气躁！！！