数组

最新推荐文章于 2024-10-08 13:19:19 发布

hjh3132778226

最新推荐文章于 2024-10-08 13:19:19 发布

阅读量165

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/hjh3132778226/article/details/114749919

版权

数组

数组的概述

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

内存分析

Java内存：堆、栈、方法区

堆：

存放new 的对象和数组
可以被所有的线程分享，不会存放别的对象引用

栈：

存放基本变量类型（会包含这个基本类型的具体数值）
引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区：

可以被所有的线程共享
包含了所有的class和static变量

数组的声明创建

1.首先必须声明数组变量，才能在程序中使用数组

声明了一个数组推荐使用这个

int [] nums;

这个也可以声明一个数组

int nums2[];

2.Java语言使用new操作符来创建数组

nums = new int[10];//创建了一个数组,这里面可以存放10个int类型的变量

3.给数组元素中赋值

数组的元素是通过索引访问的，数组索引从0开始

nums[0] =1;
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;
System.out.println(nums[9]); //10

计算所有数组的和

int sum = 0;

获取数组长度 arrays.length

for (int i = 0; i <nums.length; i++) {
    sum = sum+nums[i];
}
System.out.println(sum);//55

数组的三种初始化

1.静态初始化创建+赋值

int [] a = {1,2,3,4,5,6,7}; //这种一旦定义了就不可改变
System.out.println(a[0]);//1

2.动态初始化 :包含默认初始化

int [] b = new int[10]; //需要手动去赋值
 b[0] = 10;
 System.out.println(b[0]);//10

3.默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。初始化值为0
就是如果没有数组的值赋值，它也会有值,int类型的就是0，string类型的就是null

数组使用

数组的基本特点

数组时相同数据类型（数据类型可以为任意类型）的有序集合。
数组也是对象。数组元素相当于对象的成员变量
数组长度是确定的，不可变的。如果越界，则报： ArrayIndexOutOfBounds

int [] arrays = {1,2,3,4,5};

打印全部的数组元素

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

计算所有元素的和

int sum = 0;
for (int i = 0; i <arrays.length ; i++) {
    sum += arrays[i];
}
System.out.println(sum); // 15

查找最大元素

int da = arrays[0];
for (int i = 1; i <arrays.length ; i++) {
    if (arrays[i]>da){
        da = arrays[i];
    }
}
System.out.println("最大值:"+da);//5

不用下标打印数组

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

数组作为方法入参

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

反转数组

意思就是原本结果为1，2, 3, 4, 5 变成了 5 , 4，3, 2，1

public static int[] reverse(int [] arrays){
    int[] ints = new int[arrays.length];
    //反转的操作
    for (int i = 0,j=ints.length-1; i <arrays.length ; i++,j--) {
        ints[j] = arrays[i];
    }
    return ints;
}

public static void main(String[] args) {
        int [] reverse = reverse(arrays);
        printArray(reverse);
 }

多维数组

public class ShuZu05 {
    public static void main(String[] args) {
        int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
        printArray(array[1]); // 2,3
        System.out.println(array[0][0]); //1
        System.out.println(array[0][1]); //2
        System.out.println(array[3][0]); //4
        System.out.println(array[3][1]); //5

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

    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

Arrays

public static void main(String[] args) {
    int [] a = {1,545,1164,15,4545,156,445,648,964};
     System.out.println(Arrays.toString(a));

结果为:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gJtSnaM8-1615621823329)(C:\Users\HJH\Desktop\捕获.PNG)]

当然我们也可以自己写出来

public static void shuzu(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]+", ");
        }


    }
    
     public static void main(String[] args) {
         shuzu(a);
         }

效果也是一样的，不过有前辈帮我们写出来了，我们可以大大节省代码量，节省代码空间，还是推荐Arrays

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

Arrays.sort(a);
System.out.print(Arrays.toString(a)+"\n");

数组填充 Arrays.fill();

  Arrays.fill(a,0);
  System.out.println(Arrays.toString(a)); //全部数据为0

Arrays.fill(a,2,3,0);
System.out.println(Arrays.toString(a)); //包括下标2，不包括下标3  所以输出为2

冒泡排序

技巧:

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

public static int[] sort(int[] a) {
    //定义临时变量
    int temo = 0;

    //通过flag标识位减少没有意义的比较
    boolean flag = false;

    //外层循环，判断我们这个走多少次
    for (int i = 0; i <a.length-1 ; i++) {
        //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
        for (int j = 0; j <a.length-1-i ; j++) {
            if (a[j+1]<a[j]){ 
                temo = a[j];
                a[j] = a[j+1];
                a[j+1] = a[j];
                flag = true;
            }
        }
         if (flag == false){
             break;
         }
    }
    return a;
}

public static void main(String[] args) {
    int [] a = {12,13,45,15,454,154,745,454};
    int [] b =  sort(a); //调用完我们自己写的排序方法后，返回一个排序后的数组
    System.out.println(Arrays.toString(b));
}

稀疏数组

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();//换行作用
}

2.转换为稀疏数组保存

获取有效值的个数

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);

创建一个稀疏数组的数组

这是第一排的效果

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"
    );
}

3.还原

System.out.println("还原");
int[][] array3 = new int[array2[0][0]][array2[0][1]];

给其中的元素还原它的值

for (int i = 1; i <array2.length ; i++) {
    array3[array2[i][0]][array2[i][1]]= array2[i][2];
}

打印

System.out.println("输出还原的数组");
for (int[] ints : array3) {
    for (int anInt : ints) {
        System.out.print(anInt+"\t");
    }
    System.out.println();
}

此博客为本人学习时候写的，写的可能只有我能看懂，要是想学可以直接去B站搜索狂神，我是跟他学的~~ 各位一起加油，下面是他的博客地址：
https://space.bilibili.com/95256449?spm_id_from=333.788.b_765f7570696e666f.2