Day10数组

已于 2022-04-09 19:37:05 修改
阅读量125 收藏
点赞数
分类专栏： java基础 文章标签： java
于 2021-09-22 21:07:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liaily/article/details/120423040
版权

1. 数组的定义

  • 数组是相同类型数据的有序集合
  • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
  • 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们
  • 声明并创建一个数组后，其会在内存中有一个存储空间，其数据类型"int[]“，数组名"arr”，数组指针"001"会存储在栈内存中，内存中的地址"001"，数组中的索引和数据会存储在堆内存中，其数组指针会指向数组内存中的地址。
    在这里插入图片描述

2. 数组声明创建

  • 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
int[] array;	//首选的方法
int array[];	//效果相同，但不是首选方法
  • java语言使用new操作符来创建数组，语法如下：
int[] array = new int[3];	//使用new时相当于在内存中为数组申请了空间
  • 数组的元素是通过索引访问的，数组索引从0开始。
  • 获取数组长度：
arrays.length

package com.liu.array;

/**
 * @author 23862
 */
public class ArrayDemo01 {
    //变量的类型     变量的名字   =   变量的值；
    //数组类型
    public static void main(String[] args) {
        int[] nums;     //1.声明一个数组

        nums = new int[10];     //2.创建一个数组

        //可将上面两步合为一步,声明和创建一起做
        int[] nums2 = new int[10];

        //3.给数组元素赋值
        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[8]);//9,数组中无值时默认输出0*/
        //计算所有元素的和
        int sum = 0;
        //获取数组长度：   arrays.length
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println("总和为："+sum);
    }
}

3. 三种初始化和内存分析

3.1 三种初始化

  • 静态初始化：初始化指定每个数组元素的初始值，有系统决定数组长度

    //标准格式
int[] arr = new int[]{1,2,3};
//简化格式
int[] arr = {1,2,3};

  • 动态初始化：初始化指定数组长度，由系统决定数组元素初始值

    int[] a = new int[2];
a[0] = 1;
a[1] = 2;

  • 数组的默认初始化

    数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式格式化。

package com.liu.array;

/**
 * @author 23862
 */
public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化:创建 + 赋值
        int[] a = {1,2,3,4,5,6,7,8};//可输入任意个值，定义后就不可改变
        System.out.println(a[0]);

        //动态初始化:(包含默认初始化)声明 + 创建
        int[] b = new int[10];
        b[0] = 10;

        System.out.println(b[0]);//10
        System.out.println(b[1]);//0  int类型数组中未被初始化的值默认为0
    }
}

3.2 Java内存分析

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

定义一个数组：

int[] arr = new int[3];

其在Java内存中的存储位置为：001是该数组在内存中的地址值，该地址值只会在new后改变，改变数组中存储的数据的值不会影响数组的地址值。

  • Java内存：

    在这里插入图片描述

    • 堆内存：

      • 存放new出来的内容（实体，对象）
      • 可以被所有的线程共享，不会存放别的对象引用
      • 每个new出来的东西都有一个地址值，使用完毕会在垃圾回收器空闲时被回收

    • 栈内存：

      • 存放基本变量类型（会包含这个基本类型的具体数值）
      • 引用对象的变量（会存放这个引用在堆里面的具体地址）
      • 存储局部变量（定义在方法中的变量），使用完毕立即消失

    • 方法区：

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

3.3多个数组指向相同内存图

编写执行一段代码：

int[] arr = new int[3];//动态初始化一个数组arr
arr[0] = 100;	//手动赋值
arr[1] = 200;
arr[2] = 300;
System.out.println(arr);//输出数组arr在内存中的地址值，假设为001
System.out.println(arr[0]);//100
System.out.println(arr[1]);//200
System.out.println(arr[2]);//300

int[] arr2 = arr;//修改第二个数组的指针指向第一个数组的存储位置001
arr[0] = 111;	//手动赋值
arr[1] = 222;
arr[2] = 333;
System.out.println(arr);//输出数组arr在内存中的地址值，为001
System.out.println(arr[0]);//输出值为111
System.out.println(arr2);//输出数组arr2在内存中的地址值，为001
System.out.println(arr2[0]);//输出值为111

最终两个数组在内存中的存储情况为下图：

在这里插入图片描述

4.数组中的两个常见问题

数组的四个基本特点：

  • 其长度是确定的。数组一旦被创建，它的大小就是不可改变的。

  • 其元素必须是相同类型，不允许出现混合类型。

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

  • 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身还是在堆中的。

4.1 数组索引越界（下标越界）问题

  • 下标的合法空间：[0,length-1],如果访问不在索引内的索引位置就会报错；

    public class ArrayDemo02 {
    public static void main(String[] args){
        int[] a = new int[2];
        //取a[2]时数组越界
        System.out.println(a[2]);
    }
}

  • ArrayIndexOutOfBoundsException:数组下标越界异常！

  • 小结：

    • 数组是相同数据类型（数据类型可以为任意类型）的有序集合

    • 数组也是对象。数组元素相当于对象的成员变量

    • 数组长度是确定的，不可变的。如果越界，则报：ArrayIndexOutOfBoundsException异常

4.2 空指针异常

  • 数组都有一个指针指向其在内存中的地址，当该指针不再指向堆内存数据时就会出现该异常

  • NullPoninterException：空指针异常！

    int[] arr = new int[3];//动态初始化数组arr
System.out.println(arr[1]);//0
arr = null;	//将数组的指针修改为null
System.out.println(arr[1]);//报空指针异常

    在这里插入图片描述

5. 数组的使用

  • 普通的For循环

  • For-Each循环（增强for循环）

  • 数组作方法入参

  • 数组作返回值

5.1 基本的用法

package com.liu.array;

/**
 * @author 23862
 */
public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //打印全部的数组元素
        for (int i = 0; i < arrays.length ; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("=================");
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length ; i++) {
            sum += arrays[i];
        }
        System.out.println("sum="+sum);
        System.out.println("=================");
        //查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (arrays[i]>max){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);
    }
}

5.2 较高级的用法

package com.liu.array;

/**
 * @author 23862
 */
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

/*        //增强型for循环，没有下标
        for (int array : arrays) {
            System.out.println(array);//可直接遍历输出数组中的每个元素
        }*/
        //printArray(arrays);

        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

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

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

6. 多维数组

  • 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
  • 二维数组
int a[][] = new int [2][5];
  • 解析：以上二维数组a可以看成一个两行五列的数组。
package com.liu.array;

/**
 * @author 23862
 */
public class ArrayDemo05 {
    public static void main(String[] args) {
        //[4][2]
        /*
        1,2     array[0]
        2,3     array[1]
        3,4     array[2]
        4,5     array[3]
        */
        //二维数组
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};

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

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

7. Arrays类

  • Arrays类是数组的工具类java.util.Arrays。
  • 数组对象本身没有方法可供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本操作。
  • Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”适用对象来调用（是“不用”不是“不能”）。
  • Arrays类具有以下常用功能：
    • 给数组赋值：通过fill方法。
    • 对数组排序：通过sort方法，按升序。
    • 比较数组：通过equals方法比较数组中元素值是否相等。
    • 查找数组元素：通过binarySearch方法能对排序好的数组进行二次查找法操作。
package com.liu.array;

import java.util.Arrays;

/**
 * @author 23862
 */
public class ArrayDemo06 {
    public static void main(String[] args) {

        int[] a = {1,2,3,4,5656,565,555,666};

        //System.out.println(a);//hashcode:[I@1540e19d
        //打印数组元素Arrays.toString
        //System.out.println(Arrays.toString(a));
        //printArray(a);

        //对数组进行排序(升序排序)
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //数组填充
        //Arrays.fill(a,0);//将数组a的元素全变为0
        Arrays.fill(a,2,4,0);//将数组a中a[2]~a[4](大于等于2且小于4)元素变为0
        System.out.println(Arrays.toString(a));
    }

    //手写一个打印数组的工具方法
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if(i==0){
                System.out.print("[");
            }else if (i==a.length-1){
                System.out.println(a[i]+"]");
            }else {
                System.out.print(a[i] + ", ");
            }
        }
    }
}

8. 冒泡排序

  • 冒泡排序的代码是相当简单的，两层循环，外层冒泡轮数，内层依次比较。
package com.liu.array;

import java.util.Arrays;

/**
 * @author 23862
 */
public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {1,8,3,4,5,7,6,2};

        //调用完我们自己的排序方法以后，返回一个排序后的数组
        int[] sort = sort(a);

        System.out.println(Arrays.toString(sort));
    }
    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就该交换他们的位置
    //2.每一次比较，都会产生出一个最大，或者最小的数字；
    //3.下一轮则可以少一次排序！
    //4.依次循环，直到结束！
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;

        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {
            //通过false标识位减少没有意义的比较
            boolean flag = false;
            //内层循环，比价判断两个数，如果第一个数比第二个数大就交换位置
            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;
    }
}

9. 稀疏数组

  • 需求：编写五子棋游戏中，有存盘退出和继续上盘功能

  • 在这里插入图片描述

  • 分析：因为该二维数组的很多值是默认值0，因此记录了很多无意义数据。

  • 解决：使用稀疏数组

package com.liu.array;

/**
 * @author 23862
 */
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 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("===========================");
        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");
            }
            System.out.println();
        }
    }
}
Liaily
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自定义数组类
思不凉
07-06 2309
在学习c++的过程中，我们经常使用到数组，那怎么去定义一个类去实现数组的功能呢？ 我们先列除一些经常对数组进行的一些操作， 1、 创建一个指定容量的数组 2、 用已有的数组初始化另一个数组 3、 用已有的数组给另一个数组赋值 4、 给数组添加元素/给数组元素赋值 5、 获取数组指定元素的值 6、 输入一定数量的值，将值赋给数组 7、 输出数组 …… 还有很多，本次只实现以上功能
数组类 java_Java学习---数组的定义和类的使用
weixin_36382265的博客
02-20 429
一、学习目的通过今天的学习来掌握数组的定义方式和基本使用，感受与C语言数组中的异同，以及初步认识类与对象的概念，如何创建一个对象，类里面如何定义变量和方法和理解创建对象的内存表现。二、数组的定义相关1. 数组的两种定义方式(静态和动态)//引用类型：除char short int float long double byte以外都是引用类型//数组一但被定义 大小就确定了 无法更改//静态int...
数组的再次学习，类定义数组
weixin_42383952的博客
08-05 782
一、数组核心概念1.数组是什么？数组是内存中用来存储数据的一段连续固定长度空间，有长度、存储数据容量、下标等属性。2.数组优点a、数组能存储大量数据，我们可以按照索引遍历数组中的元素。b、数组是一个简单的线性序列，我们可以按照索引对数组中的元素进行增、删、查、取等操作。c、由于我们可以通过下标对数组元素进行一次性操作，所以数组的时间复杂度为O1。3.数组缺点a、数组的长度固定，其大小一经确定就不能改变。b、数组相对于链表，其插入元素、增删元素、查找元素慢。c、数组不好管理。...
java自定义一个数组类（封装多种方法）
weixin_51373750的博客
02-26 3496
一、自定义数组类的动机 java给定的数组为静态的，我们是无法对齐进行灵活的操作，比如指定位置添加元素，删除元素，判断是否非空等，于是我们便需要利用“面向对象”的设计模式，自定义一个数组类，将这些我们可能需要的方法功能封装进去，使得数组可以灵活进行增删改查判空等操作，即“动态数组”。
C++ 定义一个数组类，实现数组的一些常用操作
m0_65400143的博客
09-15 1483
【代码】C++ 定义一个数组类，实现数组的一些常用操作。
Java基础复习day03数组
12-11
Java基础复习day03数组 Java数组是一种数据类型，引用类型，用于存放一组数据的数据结构。数组的定义、创建、访问、长度属性、遍历、常用Arrays类、二维数组、方法递归调用经典案例、变量源码教程等。 一、数组的...
day4数组.xmind
12-03
day4
day07 数组.md
04-05
基于Java的入门课程教学
day05【数组】1
08-04
数组概念和访问 数组是存储数据长度固定的容器，保证多个数据的数据类型要一致。在 Java 中，数组是最基本的数据结构之一，广泛应用于数据存储和操作。数组可以存储不同类型的数据，例如整数、浮点数、字符串等。 ...
定义一个数组类
06-12
定义一个数组类： 属性包括：数组容量、实际元素数量 方法包括：初始化、打印所有元素、末尾插入元素、末尾删除元素
java中用数组为一个类定义多个对象
11-17
java中用数组为一个类定义多个对象，并对其进行实例化
定义类数组
11-11 1965
在java中，可以类为基本对象来定义一个数组 ，也就是直接以一个class作为一个类型，同时里面还有属性 编写学生类，包含姓名，学号，成绩三个属性 题目要求： 1.为学生类添加构造函数给每个成员属性赋值，使用this关键字 2.为学生添加toString（）方法显示所有属性 3.在测试类中定义学生数组，长度为4。分别给数组每个元素赋值，然后循环调用...
定义一个数组操作类（Array），里面定义了一个整型数组，由外部传入数组的大小，可以实现数据的保存以及输出
qq_44758926的博客
07-02 1712
标题定义一个数组操作类（Array），里面定义了一个整型数组，由外部传入数组的大小，可以实现数据的保存以及输出 即：所有的大小由程序指定，并在此基础上实现以下的两个子类： • 排序类：可以对数组进行排序的显示 • 反转类：可以将数组的内容反转显示 基础类 class Array{ private int []data; private int foot; // 作为保存的脚标 public Array(int len){// 实例化本类对象时必须设置数组大小 if
字定义数组类
chen_zan_yu_的博客
03-29 365
MyArray.h #pragma once #include<iostream> using namespace std; class MyArray { public: MyArray(); MyArray(int len); MyArray(const MyArray &another); ~MyArray(); void setDate(int in...
枚举工具类
最新发布
qq_43049583的博客
08-04 112
java枚举工具类
c语言数组书写day语句
11-24
以下是C语言数组的声明和初始化语句示例： ```c int arr1[5]; // 声明一个包含5个整数的数组 char arr2[5] = {'a', 'b', 'c', 'd', 'e'}; // 声明并初始化一个包含5个字符的数组 double arr3[] = {3.14, 4.2, 4.5, 6.3, 7.4}; // 声明并初始化一个包含5个双精度浮点数的数组，可以省略数组长度 ``` 以下是C语言数组的遍历语句示例： ```c int i; for (i = 0; i < 5; i++) { printf("%d\n", arr1[i]); // 输出arr1数组中第i个元素的值 } ``` 或者使用while循环： ```c int i = 0; while (i < 5) { printf("%d\n", arr1[i]); // 输出arr1数组中第i个元素的值 i++; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值