从零开始学Java-数组

Fred_W
140 阅读10分钟

前言

前一篇文章中，我们讲解了java的循环结构，怎么样有没有多练习呢？是不是很有乐趣呢？我们接下来慢慢的逐渐加深点难度来学习下面的知识点吧！今天我们就来学习数组吧！

目录

  • 数组的介绍
  • 数组的定义和静态初始化
  • 数组元素访问
  • 数组遍历
  • 数组动态初始化
  • 数组常见问题
  • 数组常见操作

我们先来介绍一下数组吧！

数组的介绍

  • 什么是数组？

    数组指的是一种容器，可用来存储同种数据类型的多个值。它能够以连续的内存块存储数据，并提供了快速随机访问元素的能力。数组的元素可以通过下标访问，下标从0开始计数。

  • 数组的特点

    数组具有固定长度，一旦创建后长度不可变。

    数组中的元素必须属于同一类型。

    数组的索引从0开始，依次递增。

  • 数组的优点

    快速访问：数组通过索引直接访问元素，速度高效。

  • 数组的缺点

    长度固定：数组在创建后长度不可变，无法动态调整

数组的定义

  • 数组的静态初始化

    什么是初始化呢？其实就是在内存中为数组容器开辟空间大小，并将数据存入容器中的过程。

  • 数组定义格式：

    完整格式：数据类型 [] 数组名 = new 数据类型[]{元素1元素2,元素3}
实例：int[] array = new int[]{11,22,33};

简写格式：数据类型[] 数组名 = {元素1，元素2，元素3};
实例：int[] array = {11,22,33};

  • 我们来看一下数组的定义吧：

// 需求1：定义数组存储5个学生的年龄
int[] arr1 = new int[]{18,19,20,21,22};     // 完整格式
int[] arr2 = {18,19,20,21,22};              // 简写格式
// 需求2：定义数组存储5个学生的姓名
String[] arr3 = new String[]{"张三","李四","小明","小红","小李"};     // 完整格式
String[] arr4 = {"张三","李四","小明","小红","小李"};                 // 简写格式
// 需求3：定义数组存储5个学生的身高
double[] srr5 = new double[]{165.5,166.5,168.5,170.5,175.5};        // 完整格式
double[] srr6 = {165.5,166.5,168.5,170.5,175.5};

在这里我们需要注意的点是根据不同的数据类型要选择对应的数据类型就可以啦！

下面我们来学习访问数组里面的元素吧！

数组元素访问

int[] arr1 = {18,19,20,21,22}; 
System.out.println(arr1);

数组里面的元素怎么访问呢？有的人就会说了，不是直接打印就可以了吗，我们来运行看一下： image.png 可以看到他打印出来的是：[I@2d98a335，这个是什么呢？我们来解释一下： [I@2d98a335

  • [：表示当前是应该数组。
  • I：表示当前的数组元素都是int类型的。
  • @：表示应该间隔符号。（固定格式）。
  • 2d98a335：这才是数组的真正地址值。（十六进制）

那我们要怎么访问元素呢？下面我们来看一下数组元素访问的格式：

格式：数组名[索引] // 数组下标是从0开始的。
索引也叫下标，索引是从0开始，逐个+1增长，连续不间断

下面我们来看一下怎么样访问元素吧：

// 需求1：定义数组存储5个学生的年龄
int[] arr1 = new int[]{18,19,20,21,22};     // 完整格式
// 1.获取数组里面的元素
// 格式：数组名[索引]
// 获取数组的第一个元素，索引0对应的是第一个元素
int number = arr1[0];
System.out.println(number);    // 18
// 打印数组中索引为1的对应数据
System.out.println(arr1[1]);   // 19

有的人就会问了，为什么只能打印一个呢？我如果想全部打印出来是不是要写很多行代码呀？其实不是的，我们接下来学习数组的遍历吧！

数组的遍历

数组的遍历：将数组的全部元素获取出来，取出来后可以打印、求和、判断等操作。

  • 利用循环遍历出来
// 数组遍历
int[] arr = {1,2,3,4,5};
// 1.获取数组里面的全部元素
for (int i = 0; i < arr.lenght; i++) {
    System.out.println(arr[i]);
}
因为数组下标从0开始，所以开始条件为0，结束条件等于长度减1。

既然我们遍历出来了，那我们接下来看个小练习吧！

  • 练习1

定义一个数组，存储1，2，3，4，5。遍历数组得到每一个元素，将元素里面所有数据求和

我们先来分析一下：

1.定义一个数组，并添加1，2，3，4，5的数组元素。

2.遍历数组得到每一个数据，累加求和。

我们来看一下具体实现代码吧：

// 定义一个数组，存储1，2，3，4，5。
// 遍历数组得到每一个元素，将元素里面所有数据求和
int[] arr = {1,2,3,4,5};
// 定义一个sum用来求和
int sum = 0;
// 1.获取数组里面的全部元素
for (int i = 0; i < arr.length; i++) {
    // i依次表示数组里面的每一个索引
    // arr[i]表示数组里面的每一个元素
    // 依次循环把遍历的元素加到sum值里面
    sum += arr[i];
}
// 循环结束打印sum的值
System.out.println(sum);
  • 练习2

定义一个数组，存储1，2，3，4，5，6，7，8，9，10。遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字

我们先来分析一下：

1.定义一个数组，存储1，2，3，4，5，6，7，8，9，10。

2.遍历数组得到每一个元素。

3.判断当前元素是否能被3整除。

我们来看一下具体实现代码吧：

// 定义一个数组，存储1，2，3，4，5，6，7，8，9，10
// 遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字
int[] arr = {1,2,3,4,5,6,7,8,9,10};
// 定义一个变量用来统计符合能被3整除的个数
int count = 0;
// 遍历数组得到每一个元素
for (int i = 0; i < arr.length; i++) {
    // 判断当前元素是否能被3整除，如果是那统计变量就需要增+1
    if(arr[i] % 3 == 0){
        count++;
    }
}
System.out.println("数组中能被3整除的数字有" + count + "个");

以上就是数组的静态初始化，我们接下来学习一下数组的动态初始化吧！

数组的动态初始化

动态初始化：初始化时只指定数组长度， 由系统为数组分配初始值。

动态初始化数组格式：数据类型[] 数组名 = new 数据类型[数组长度]

格式：int[] arr = new int[10];

在创建的时候，由我们自己指定数组的长度，由虚拟机给出默认的初始值。

我们来说一下动态初始化的默认值：

数组默认初始化的规律
整数类型：默认初始化值0；
小数类型：默认初始化0.0；
字符类型：默认初始化值'\u0000'空格
布尔类型： 默认初始化值false
引用数据类型：默认初始化值 null

数组动态初始化和静态初始化的区别

  • 静态初始化：手动指定数组的元素，系统会根据元素个数，计算出数组的长度。

    使用场景：需求中已经明确了要操作的具体数据，直接可以使用静态初始化。

  • 动态初始化：手动指定数组的长度，由系统给出默认值。

    使用场景：只明确元素个数，不明确具体数值，推荐使用动态初始化。

数组的常见问题

  • 当访问了数组中不存在的索引，就会发生索引越界异常。

    例如：

     int[] arr = {1,2,3,4,5};
 System.out.println(arr[5]); // 报错

    因为数组长度为5，数组的开始索引为0，最大索引为：数组长度-1。超过了长度所以会报错。

好了，数组的静态和动态初始化已经讲完啦，下面我们来看几道练习题吧！

数组的常见问题

  • 1.获取数组中的最大值

    需求：用静态数组存放5个数字，获取到最大的数并输出。

    第一步：定义一个数组

    // 定义数组用来存放5个数
int[] arr = {10,20,80,40,50};

    第二步：定义一个max变量用来存放最大值。

    // 定义应该变量max用来存放最大值，默认初始0索引为最大值
int max = arr[0];

    第三步：循环获得每一个元素

    for (int i = 0; i < arr.length; i++) {
}

    第四步：通过下标循环比较数组中的最大值

    // 拿每一个元素进行比较，如果索引下标大于max的就把他存进max里面
if(arr[i] > max){
    max = arr[i];
}

    第五步：输出

    // 循环结束后打印出max最大值
System.out.println(max);

    这个时候我们运行看一下： image.png 可以看到也是把最大值给输出来了，下面我们接着来看吧：

  • 2.生成10个1到100的随机数。

    求出所有数据的和，平均值，低于平均值的个数。

    第一步：定义动态数组

    // 1.定一个长度为10的动态数组
int[] arr =new int[10];

    第二步：生成随机数存到数组

    Random r = new Random();
for (int i = 0; i < arr.length; i++) {
    // 每循环一次，就会生成一个新的随机数。
    int number = r.nextInt(100) + 1;
    // 把生成的随机数添加到数组当中
    arr[i] += number;
}

    第三步：遍历数组并求和

    // 定义一个sum用来求数组的和
int sum = 0;

// 数组的和=sum+数组的元素
sum += arr[i];

    第四步：求平均数

    // 求平均数
// 定义一个avg用来求数组的平均值
int avg = 0;
// 数组的平均分=数组的和/数组的长度。
avg = sum / arr.length;

    第五步：求低于平均数的个数

    // 求低于平均数个数
// 定义一个count用来统计低于平均分的个数
int count = 0;
for (int i = 0; i < arr.length; i++) {
    // 用for依次循环低于平均分的就把count次数
    if(arr[i] < avg){
        count++;
    }
}

    最后我们来运行看一下吧： image.png 可以看到成功生成了10个随机数并计算出了数组中的和以及平均分和低于平均分的个数。

    下面我们来看最常用的交换吧！

  • 3.交换数组中的数据。

    需求：定义两个变量交换两个变量记录的值.交换前：12345，交换后54321

    第一步：定义数组

    // 定义一个数组
int[] arr1 = {1,2,3,4,5};

    第二步：利用循环去交换

    // 利用循环去交换
for (int i = 0,j = arr1.length - 1;i < j; i++,j--){
}

    第三步：交换

     // 定义temp变量用来进行交换
 // 交换变量i和变量j指向的元素
 int temp = arr1[i];
 arr1[i] = arr1[j];
 arr1[j] = temp;

    最后我们来运行看一下吧：
    image.png 怎么样，结果以上几个练习是不是感觉很有趣呢，接下来我们来学一个打乱数组的数据顺序吧！

  • 4.打乱数组中的数据。

    需求：定义一个数组，存入1-5，要求打乱数组中所有的顺序。

    第一步：定义数组

    //定义数组，存入1-5；
int[] arr = {1,2,3,4,5};

    第二步：生成随机数

    // 定义生成随机索引，长度为数组的长度
Random r = new Random();
int number = r.nextInt(arr.length);

    第三步：拿着随机索引跟i元素进行交换

    // 拿着随机索引跟i进行交换
int temp = arr[i];
arr[i] = arr[number];
arr[number] = temp;

    image.png 下面我们在运行看一下

    image.png 这个时候数组的元素是不是被随机打乱了呀，好啦数组就讲到这里啦，有什么不懂的可以在评论区评论哟，我们下期再见！

==最后非常感谢您的阅读，也希望能得到您的反馈  ==

avatar
文章
阅读
粉丝