Java数组

大力萌萌怪

已于 2022-10-18 22:12:40 修改

阅读量85

点赞数

分类专栏： Java基础学习文章标签： java

于 2022-10-06 16:33:40 首次发布

本文链接：https://blog.csdn.net/qq_40649588/article/details/127184770

版权

Java基础学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

一、数组概述
二、数组使用
三、多维数组
四、Arrays类
五、稀疏数组

一、数组概述

数组是相同类型数据的有序集合

数组描述的是相同类型的若干个数据，按照一定先后顺序排列组合而成

每一个数据称做一个数据元素，每个数组元素可以通过一个下标来访问它

数组声明（两种方式）：

int[] nums; //1.定义
int nums2[]; //定义效果相同，但不是首选方法

数组创建：

使用new操作符来创建数组，可以存放十个int类型的数字

nums = new int[10]
数组赋值：

nums[i] = 3
内存分析：
- 堆：存放new对象和数组；可以被所有线程共享，不会存放别的对象引用
- 栈：存放基本变量类型(包含这个基本类型的具体数值)；引用对象的变量(会存放这个引用在堆里面的具体地址)
- 方法区：可以被所有线程共享；包含了所有的class和static变量
三种初始化：
- 静态初始化
  
  int[] a = {1,2,3,4,5,6,7,8};
- 动态初始化
```
int[] b = new int[10];
b[0] = 10;
```
- 数组默认初始化
  
  数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也按照实例变量同样的方式被隐式初始化。
```
int[] b = new int[10];
b[0] = 10;
System.out.println(b[2]); //0，不赋值默认为0
```
数组的四个基本特点：
1. 其长度是确定的。一旦被创建，它的大小不可改变，如果越界则报错
2. 其元素必须是相同类型，不允许出现混合类型
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
4. 数组变量属于引用类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量；数字本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身是在堆中。

二、数组使用

for循环
for-each循环
数组作为方法入参
数组作为返回值

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};
        //array.for 会自动生成for循环语句
        //没有下标
        //for-each循环
        for (int array : arrays) {
            System.out.println(array);
        }
        System.out.println("=================");
        printArray(arrays);
        printArray(reverseArray(arrays));
        printArray(arrays);

    }
    //打印数组元素（数组作为方法入参）
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
        System.out.println("");
    }
    //反转数组（数组作为返回值）
    //原始的数组也被修改了，如果不想修改原始数组，就在方法里新建一个数组进行值传递
    public static int[] reverseArray(int[] arrays){
        int temp;
        int j=arrays.length-1;
        for (int i = 0; i < j; i++) {
            temp = arrays[i];
            arrays[i] = arrays[j];
            arrays[j] = temp;
            j--;
        }
        return arrays;
    }
}

三、多维数组

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

    }
}

四、Arrays类

数组的工具类 java.util.Arrays

可以查看 jdk 帮助文档

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用(是不用而不是不能)

常用功能：

给数组赋值：通过fill方法
对数组排序：通过sort方法
比较数组：通过equals方法比较数组中元素值是否相等
查找数组元素：通过binarySearch方法能够对排序好的数组进行二分查找法操作
……

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,8,2323,44442,2111};
        System.out.println(a);//正常输出是一个哈希code  [I@1b6d3586
        //打印数组
        System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 8, 2323, 44442, 2111]
        System.out.println("=================================");
        //数组排序 升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //填充
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序：(时间复杂度O(n^2))

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {3,2,5,6,8,7,9,1};
        bubbleSort(a);
        System.out.println(Arrays.toString(a));
    }
    //冒泡排序
    //比较数组中两个相邻的元素
    public static int[] bubbleSort(int[] array){
        int temp=0;
        for (int i = array.length-1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (array[j]>array[j+1]){
                   temp=array[j+1];
                   array[j+1]=array[j];
                   array[j]=temp;
                }
            }
        }
        return array;
    }
}

五、稀疏数组

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

稀疏数组的处理方式：

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

public class ArrayDemo08 {
    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();
        }
        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 m =1;
        //遍历二维数组，将非零的值，存放在稀疏数组中
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0){
                    array2[m][0]= i;
                    array2[m][1]= j;
                    array2[m][2]= array1[i][j];
                    m++;
                }
            }
        }
        //输出系稀疏矩阵
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        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];
        }
        //打印
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}