java基础四之数组

最新推荐文章于 2024-07-27 15:45:10 发布

Schelling Peak

最新推荐文章于 2024-07-27 15:45:10 发布

阅读量72

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_44397471/article/details/127437317

版权

java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

Java数组

什么是数组？数组的声明创建；数组初始化内存分析；多维数组；Arrays类；稀疏数组

1. 数组概述

数组定义
- 相同类型数据的有序集合。
- 描述：相同类型的若干个数据，按照一定的先后次序排列组合而成。
- 其中，每一个数据称为一个数组元素，每个元素可以通过一个下标来访问它。数组下标从“0”开始

2. 数组声明

首先必须声明数组变量，才能在程序中使用数组，声明语法：
数组类型 [ ] 数组变量名称;
```
dataType[] arrayRefVar;
```

java中使用new 操作符来创建数组，语法：

dataType [ ] arrayRefVar = new dataType[arraySize];
//例：
int nums = new int[10];//开辟有十个int类型元素的数组空间

数组元素可以通过索引访问和赋值，索引从0开始。
获取数组长度：数组名.length

3. 引：java程序内存分析：堆、栈

或可查看大佬解读数据结构中堆、栈

栈内存：
1. 存放基本变量类型（包含这个基本类型的具体数值）
2. 引用对象的变量（包含这个引用在堆里面的具体地址）
- 栈由操作系统自动分配释放，用于存放函数的参数值、局部变量等，其操作方式类似于数据结构中的栈。参考如下代码：
```
 int b;				//栈
 char s[] = "abc"; 	//栈
 char *p2;			//栈
```
堆内存：
1. 存放new的对象和数组
2. 可以被所有线程共享，不会存放别的对象引用
- 堆由开发人员分配和释放，若开发人员不释放，可由java虚拟机自动垃圾回收器来管理。参考如下代码：
```
Person person = new Person();
int nums = new int[10];
```
方法区
1. 可以被所有线程共享
2. 包含了所有的class和static变量
  
  例创建数组时内存分析：

4. 数组初始化

静态初始创建+赋值
```
int [] a = {1,2,3};
```
动态初始化包含默认初始
```
int[]  a = new int[2];
a[0] = 1;
```
数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化，即元素是有默认值的。

5. 数组的四个基本特点

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

6. 数组的使用

for - each循环

JDK1.5，没有下标即可操作数组元素

  int[] array = {1,2,3,4,5};
      for (int i : array) {
          System.out.println(i);
      }

反转数组练习

public static int[] reverse(int[] array){
    int[] result = new int[array.length];
    for (int i = array.length-1,j=0; i>=0; i--,j++) {
        result[j] = array[i];
    }
    return result;
}

7.多维数组

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

二维数组

//静态初始化
int[][] array = {{1,2,},{3,4}};
//动态初始化
int[][] array = new int[2][3];//两行三列的数组

8.Array 类自带数组工具类了解

        int[] array = {1,2,3,4,5};
        System.out.println(Arrays.toString(array));//打印数组元素
        Arrays.sort(array);//数组排序 升序
        System.out.println(Arrays.toString(array));

9.冒泡排序经典

两层循环嵌套，外层（是比较的轮数）获取元素，内层（是比较的次数）比较替换。
嵌套循环时间复杂度O（n2）

        int[] array = {2,8,1,4,7};
        int sum=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]){
                    sum =array[j+1];
                    array[j+1]= array[j];
                    array[j]= sum;
                }
            }
        }
        for (int i : array) {
            System.out.print(i);
        }

冒泡算法优化：减少不必要的比较

int[] array = {2,8,1,4,7};
      int sum=0;
      for(int i=0;i<array.length-1;i++){
          boolean flag = false;//这一轮没有发送过交换，说明数组已经有序了
          for(int j=0;j<array.length-1-i;j++){
              if(array[j]>array[j+1]){
                  sum =array[j+1];
                  array[j+1]= array[j];
                  array[j]= sum;
                  flag=true;
              }
          }
          if (!flag){
              break;
          }
      }

10.稀疏数组

稀疏数组组成原理：
- 记录数组一共有几行几列，有多少不同值。
- 把具有不同值的元素及其所在的行列记录在一个小规模数组中，从而缩小程序的规模
- 如图例：

实操：转换还原

//创建一个二维数组 6*6
      int[][] array1 = new int[6][6];
      array1[1][3] = 1;
      array1[1][4] = 2;
      array1[2][3] = 1;//赋值
      for (int[] ints : array1) {
          for (int anInt : ints) {
              System.out.print(anInt + "\t");
          }
          System.out.println();
      }
      //转换为稀疏数组
      System.out.println("======");
      //1.获取原数组有效元素个数
      int sum = 0;
      for (int[] ints : array1) {
          for (int anInt : ints) {//遍历二维数组
              if (anInt != 0) {
                  sum++;
              }
          }
      }
      //2.创建稀疏数组
      int[][] array2 = new int[sum + 1][3];
      array2[0][0] = array1.length;
      array2[0][1] = array1[0].length;//每一行的length就是二维数组的列数
      array2[0][2] = sum;
      //3.遍历原数组，将非0值放入稀疏数组
      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[] ints : array2) {
          System.out.println(ints[0] + "\t" + ints[1] + "\t" + ints[2] + "\t");
      }
      //稀疏数组还原
      System.out.println("还原");
      int[][] array3 =new int[array2[0][0]][array2[0][1]];
      //还原值
      for (int i = 1; i < array2.length; i++) {//array2第0行没有存放数据，第1行开始才是数据
          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();
      }