Java-数组-04

一、数组

1.1、数组的定义

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

1.2、数组声明和创建

声明数组变量的语法：

int[] a; // 首选的方法
或
int a[]; // 效果相同，但不是首选方法

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

int[] a = new int[10];  // 需要定义此数组存放多少数据。

数组的元素是通过索引访问的，数组索引从 0 开始。
获取数组长度：
```
数组名.length
```
数组赋值
```
数组名[下标] = 元素;
```
数组的三种初始化
- 静态初始化
```
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};
```
- 动态初始化
```
int[] a = new int[2];
a[0] = 1;
a[1] = 2;
```
- 数组的默认初始化
  - 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
数组的四个基本特点
- 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属引用类型，数组保存的原始类型和其他对象类型都存放在堆中。
数组边界
- 下标的合法区间：[0,length-1]，如果越界就会报错。
- ArrayIndexOutOfBoundsException：数组下标越界异常

1.3、数组拷贝

clone

int[] a = {1,2,3,4};
int[] b = a.clone();
System.out.println(b[2]);

System.arraycopy

1.3、内存分析

Java 内存
- 堆：
  - 存放 new 的对象和数组
  - 堆用于存储创建好的对象和数组。
  - jvm 只有一个堆，被所有线程共享。
  - 堆是不连续的内存空间，分配灵活，速度慢。
- 栈：
  - 存放基本变量类型（会包含这个基本类型的具体数值）
  - 引用对象的变量（会存放这个引用在堆里面的具体地址）
  - 局部变量：方法的参数，或者方法内部的变量。
  - 作用域：一旦超过作用域 { }，立即从栈内存当中消失。
  - 特点：
    - 栈是方法执行内存的模型，每个方法调用都会创建一个 栈内存 用来存储局部变量、操作数、方法出口等。
    - jvm 会为每个线程创建一个栈。
    - 栈线程私有，不能实现线程的共享。
    - 栈存储特征是 “先进后出，后进先出”。
    - 栈是个连续的内存空间，速度快。
- 方法区：
  - jvm 只有一个方法区，被所有线程共享。
  - 用来存放程序中永远不变或唯一的内容。
  - 包含了所有的 class 和 static 变量
- 本地方法栈（NativeMethodStack）：与操作系统相关。
- 寄存器（PCRegister）：与 PC 相关。

1.4、数组的使用

for 循环：

例题：

// 普通 for 循环
int[] a = {1,2,3,4,5,6,7,8,9};
for (int i = 0; i < a.length;i++){
    System.out.println(a[i]);
}
// 增强 for 循环
for(int b : a){
    System.out.println(b);
}

方法使用数组

例题：

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

    // 传递数组的实参
    printArray(arrays);

    // 调用数组返回值
    int[] b = arry(arrays);
    printArray(b);
}
    // 数组作为参数传递
public static  void printArray(int[] arrays){
    for (int i=0;i<arrays.length;i++){
        System.out.print(arrays[i]+ " ");
    }
}
    // 返回数组返回值
public static int[] arry(int[] arrays){
    int[] result = new int[arrays.length];
    for(int i = 0,j = arrays.length-1;i<arrays.length;i++,j--){
        result[j] = arrays[i];
    }
    return result;
}

1.5、二维数组

二维数组和嵌套 for 循环意思差不多。
二维数组
```
int[][] a = new int[2][5];
```

例题：

int[][] a = {{1,2},{3,4},{5,6}};
for (int i = 0;i<a.length;i++){
    for (int j = 0;j<a[i].length;j++){
        System.out.println(a[i][j]);
    }
}

1.6、Arrays 类

数组的工具类：java.util.Arrays
Arrays 类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名进行调用，而 “不用” 使用对象来调用

1.7、冒泡排序

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

语法：

public static void main(String[] args) {
    int[] arr = {1,2,56,56,51,11,65,48,6,15,5,8,1,2316,21,891};
    int[] a = sort(arr);
    System.out.println(Arrays.toString(a));

}
public static int[] sort(int[] array){
    // 临时变量
    int temp = 0;
    // 把检查是否排好序的那次循环关闭
    boolean flag = false;
    // 外层循环，判断我们这个要走多少次
    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[j+1] = temp;
                flag = true;
            }
        }
        if (flag == false){
            break;
        }
    }
    return array;
}

1.8、稀疏数组

当一个数组中大部分元素为 0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值。
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

例题：

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;

    // 输出原始数据
    for(int[] i : array1){
        for (int j: i){
            System.out.print(j + "\t");
        }
        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 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");
    }

    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. 打印输出

    // 输出还原数据
    for(int[] i : array3){
        for (int j: i){
            System.out.print(j + "\t");
        }
        System.out.println();
    }
}

posted @ 2021-02-20 09:19 魍阅读(38) 评论(0) 收藏举报

刷新页面返回顶部

Java-数组-04

一、数组

1.1、数组的定义

1.2、数组声明和创建

1.3、数组拷贝

1.3、内存分析

1.4、数组的使用

1.5、二维数组

1.6、Arrays 类

1.7、冒泡排序

1.8、稀疏数组

公告