4、数组array

最新推荐文章于 2022-11-23 20:08:20 发布
最新推荐文章于 2022-11-23 20:08:20 发布
阅读量193 收藏
点赞数
分类专栏： Java教程 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/deer2019530/article/details/127797648
版权

目录

1. 数组概述

  1. 定义：数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
    在这里插入图片描述
  2. 示例
String name1 = "张三"
String name2 = "李四"
…
…
String name9 = "王五"
String name10 = "赵六"
// 代码冗余
//使用数组改善
String[] names  = {"张三","李四",……"王五","赵六“};

2. 数组的定义

2.1 静态初始化数组

  1. 定义数组的时候直接给数组赋值
  2. 静态初始化数组 格式
  • 格式1
    数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3…}；
int[] arr1 = new int[]{12, 24, 36};
double[] arr2 = new double[]{12.1, 13.4, 15.6};
char[] arr3 = new char[]{'a', 'b', 'c'};
String[] arr4 = new String[]{"aa", "bb", "cc"};
  • 格式2
    数据类型[] 数组名 = {元素1，元素2，元素3…}；
 int[] arr5 = {12, 24, 36};
 double[] arr6 = {12.1, 13.4, 15.6};
 char[] arr7 = {'a', 'b', 'c'};
 String[] arr8 = {"aa", "bb", "cc"};
  1. 基本原理
    数组变量名：存储数组在内存中的地址，数组是引用类型
    int[] ages = {12, 24, 36}

在这里插入图片描述

int[] ages = {12, 24, 36};
System.out.println(ages); //[I@7c30a502
  1. 数组的访问
  • 索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
    在这里插入图片描述
  • 数组的访问 ：数组名称[索引]
    eg：取值ages[2]，赋值ages[2] = 100
  • 数组的长度属性：length
    eg：ages.length
  • 数组的最大索引数组名称.length - 1 （注意：元素个数 > 0）
    eg：ages.length - 1
 //数组的访问
 int[] ages = {12, 24, 36};
 System.out.println(ages); //[I@7c30a502

 //取值
 System.out.println(ages[2]);
 //赋值
 ages[2] = 100;
 System.out.println(ages[2]);
 //数组的长度属性
 System.out.println(ages.length);
 //数组的最大索引
 int index = ages.length - 1; //元素个数>0
  1. 注意事项
  • 数据类型[] 数组名 等价于 数据类型 数组名[]；
  • 什么类型的数组，存放什么类型的数据；
  • 静态数组一旦定义出来，程序执行的过程中，类型、长度就固定了；
        //注意事项
        //1 `数据类型[] 数组名` 等价于 `数据类型 数组名[]`；
        int[] ages = {12, 24, 36};
        int ages1[] = {12, 24, 36};
        //2 什么类型的数组，存放什么类型的数据；
        int[] ages2 = {12, 24, "a"};//报错
        //3 静态数组一旦定义出来，程序执行的过程中，**类型、长度**就固定了；
        System.out.println(ages[3]);//报错最大索引：2

2.2 动态初始化数组

  1. 动态初始化数组
    定义数组时，只确定数组的长度，由系统给出默认初始化值，之后再存入具体数据。
  2. 动态初始化数组 格式
    数据类型[] 数组名 = new 数据类型[长度]；
    eg：int[] arr = new int[3];
  3. 基本原理
    数组的元素值为默认值，如下图，默认值为：0
    在这里插入图片描述
 //初始化
 int[] arr = new int[3];
 for (int i = 0; i < 3; i++) {
     System.out.println(arr[i]);  //系统默认的初始值：0 0 0
 }
 //赋值
 for (int i = 0; i < 3; i++) {
     arr[i] = i+1;
 }
 for (int i = 0; i < 3; i++) {
     System.out.println(arr[i]);  //赋值后：1 2 3
 }
  1. 静态 动态初始化数组区别
    • 已经知道存入元素值，静态初始化
    • 不知道存入什么元素，动态初始化
  2. 动态初始化数组的默认值
    在这里插入图片描述
//初始化默认值
 byte[] arrb = new byte[3];
 for (int i = 0; i < 3; i++) {
     System.out.println(arrb[i]);  //系统默认的初始值0 0 0
 }
 short[] arrs = new short[3];
 for (int i = 0; i < 3; i++) {
     System.out.println(arrs[i]);  //系统默认的初始值0 0 0
 }
 char[] arrc = new char[3];
 for (int i = 0; i < 3; i++) {
     System.out.println(arrc[i]);  //系统默认的初始值0 0 0
 }
 int[] arri = new int[3];
 for (int i = 0; i < 3; i++) {
     System.out.println(arri[i]);  //系统默认的初始值0 0 0
 }
 
 float[] arrf = new float[3];
 for (int i = 0; i < 3; i++) {
     System.out.println(arrf[i]);  //系统默认的初始值0.0 0.0 0.0
 }
 double[] arrd = new double[3];
 for (int i = 0; i < 3; i++) {
     System.out.println(arrd[i]);  //系统默认的初始值0.0 0.0 0.0
 }
 boolean[] arrb1 = new boolean[3];
 for (int i = 0; i < 3; i++) {
     System.out.println(arrb1[i]);  //系统默认的初始值false false false
 }
 //String引用类型初始化
 String[] arrs1 = new String[3];
 for (int i = 0; i < 3; i++) {
     System.out.println(arrs1[i]);  //系统默认的初始值null null null
 }

3. 数组的遍历

3.1 遍历

一个一个数据的访问，将数组中的每个元素分别获取出来。
遍历也是数组操作中的基石。

int[] ages = {12, 4, 5, 5, 6, 9, 78};
for (int i = 0; i < ages.length; i++) {
    System.out.println(ages[i]);
}

3.2 技巧

数组遍历快捷键：数组名.fori eg:ages.fori
内部循环体：数组名[i].souf eg:ages[i].souf
在这里插入图片描述

4. 案例

4.1 求和

需求：5个人分别有16，26，36，6，100元，请计算共有多少元？

//求钱数
int[] money = {16, 26, 36, 6, 100};
int sum = 0;
for (int i = 0; i < money.length; i++) {
    sum += money[i];
}
System.out.println(sum);//184

4.2 求最值

需求：求出一组数据的最大值，{15, 9000, 100, 200, 950, -5}

int[] arr1 = {15, 9000, 100, 200, 950, -5};
// 1.定义变量，保存数组0索引上的元素
int max = arr1[0];

// 2.遍历数组，获取出数组中的每个元素
for (int i = 1; i < arr1.length; i++) {
	// 3.将遍历到的元素和保存数组0索引上值的变量进行比较
    if (max < arr1[i]){
		// 4.如果数组元素的值大于了变量的值，变量记录住新的值
        max = arr1[i];
    }
}
// 5. 数组循环遍历结束，变量保存的就是数组中的最大值 
System.out.println("the max data:" + max); //9000

4.3 猜数字

需求：游戏后台随机生成1- 20之间的5个数(可重复)，然后让大家来猜数字：未猜中提示："未命中” ，并继续猜测；猜中提示： “运气不错，猜中了”，并输出该数据第一次出现的索引位置，最后把数组中的5个数据都输出看以下，然后结束本游戏。

//猜数字
 Random rd = new Random();
 Scanner sc = new Scanner(System.in);
 //1. 动态初始化数组
 int[] arr =new int[5];
 //2. 为动态数组赋值
 for (int i = 0; i < arr.length; i++) {
     arr[i] = rd.nextInt(20)+1;
 }
 System.out.println("猜数字:1~20!");
 //3. 通过死循环进行猜测
 OUT:
 while(true){
     int num = sc.nextInt();
     // 4. 遍历数组每个元素进行对比，相同则给出提示
     for (int i = 0; i < arr.length; i++) {
         if (num == arr[i]){
             System.out.println("运气不错，猜中了," + i);
             break OUT; //结束死循环，使用OUT跳出：for+while
         }
     }
     // 5.遍历数组每个元素进行对比都不符合，没有跳出循环，再次猜测
     System.out.println("未命中");
 }
 // 6. 输出全部数据
 for (int i = 0; i < arr.length; i++) {
     System.out.println(arr[i]);
 }

4.4 随即排名

需求，对数组5个元素，打乱顺序后输出。

 // 1. 初始化静态数组
 int[] arr = {12, 57, 93, 45, 6};
 // 2.使用random获取随机索引值
 Random rd = new Random();
 int index;  //临时变量-索引
 int t;  //临时变量（中间变量）
 for (int i = 0; i < arr.length; i++) {
     //3. 遍历交换索引
     index= rd.nextInt(5);
     t = arr[i];
     arr[i] = arr[index];
     arr[index] = t;
 }
 //4. 输出
 for (int i = 0; i < arr.length; i++) {
     System.out.println(arr[i]); ///57 45 12 93 6

4.5 冒泡排序

  1. 数组排序：对数组中的元素，进行升序/降序的操作
  2. 数组排序方法：冒泡排序、选择排序、快速排序、插入排序
  3. 数组查找方法：二分查找、分块查找、哈希查找
  4. 冒泡排序思想：从头开始两两比较，把较大的元素与较小的元素进行交换；每轮把当前最大的一个元素存入到数组当前的末尾。
    比较轮数：length-1 每轮两两比较次数：length - 1 - i
    在这里插入图片描述
// 1. 定义一个数组
  int[] arr = {15, 78, 46, 23, 31, 36, 51};
  // 2. 定义一个循环控制比较轮数
  for (int i = 0; i < arr.length - 1; i++) {
      // i == 1, 比较 3 次 == 4-1
      // i == 2, 比较 2 次 == 4-2
      // i == 3, 比较 1 次 == 4-3
      // 3. 每轮比较次数
      for (int j = 0; j < arr.length - i - 1; j++) {
          if (arr[j] > arr[j+1]){
              int temp = arr[j];
              arr[j] = arr[j+1];
              arr[j+1] = temp;
          }
      }
  }
  for (int i = 0; i < arr.length; i++) {
      System.out.println(arr[i]); //23 31 36 46 51 78
  }

5. 内存图

5.1 内存分配介绍

  • 栈 堆 方法区 本地方法栈 寄存器
  • 内存分配示例
    在这里插入图片描述
int a = 12;
System.out.println(a); //12

int[] arr = {11, 22, 33};
System.out.println(arr); //[I@4c873330

arr[0] = 44;
arr[1] = 44;
arr[2] = 66;
System.out.println(arr[0]); //44
System.out.println(arr[1]); //55 
System.out.println(arr[2]); //66
  • 两个变量指向同一个数组

在这里插入图片描述

// 两个变量指向同一个数组
int[] arr1 = {11, 22, 33};
int[] arr2 = arr1;  //arr1（数组arr1指向的地址）  赋值给  arr2（数组arr2指向的地址）

System.out.println(arr1); //[I@7c30a502
System.out.println(arr2); //[I@7c30a502

arr1[0] = 44;
arr2[1] = 77;
System.out.println(arr1[0]); //44
System.out.println(arr1[1]); //77
System.out.println(arr1[2]); //22
System.out.println(arr2[0]); //44
System.out.println(arr2[1]); //77
System.out.println(arr2[2]); //22

6. 数组使用的常见问题

  1. 索引越界异常
    · 如果访问的元素位置超过最大索引length-1，执行时会出现ArrayIndexOutOfBoundsException
    · 解决：修改为正确的索引范围
        int[] a = {1, 2, 3};
        System.out.println(a[3]);
        //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3 at stu.javase.day4.ErrorDemo.main(ErrorDemo.java:6)
  1. 空指针异常
    · 如果数组变量没有保存数组的内存地址，而是null，就不能再操作数组了。在访问数组信息时会抛出 NullPointerException，
    · 解决：给数组变量一个真正的堆内存空间引用
int[] arr = new int[3];
//把null赋值给数组
arr = null;
System.out.println(arr[0]);
Exception in thread "main" java.lang.NullPointerException at stu.javase.day4.ErrorDemo.main(ErrorDemo.java:13)

7. Debug工具使用

  1. DEBUG工具基本使用步骤
    ① 在需要控制的代码行左侧，点击一下， 形成断点
    ② 选择使用Debug方式启动程序,启动后程序会在断点暂停
    ③ 控制代码一行一行的往下执行
    在这里插入图片描述
  2. 跳过，执行下一个断点
    ① 再点一个断点
    ② 跳到断点处
    在这里插入图片描述
怪兽iii
关注
专栏目录
java-基础 数组Array
weixin_63309052的博客
10-30 187
创建数组 声明数组 int[] 数组名= new int[数组长度(有多少个数)]; int[] nums; nums = new int[数组长度]; int[] nums= {1, 2, 3, 4}; 给数组赋值 int[0] = 值; 数组里的第一个数就序号为0； 计算整个数组的和 for循环： int sum = 0; for(int i = 0; i < 数组名.length; i++){ sum = sum + 数组名[i]; } 计算机结构 声明数组——栈 数组、赋值..
IntArray和Array＜Int＞
rdywithyou的博客
07-13 1046
一开始不熟悉Kotlin数据结构的时候想着用二维数组来存矩阵，发现同时存在IntArray和Array<Int> ，这两者有什么区别。 fun main() { val array1 = intArrayOf(1, 2, 3) val array2 = arrayOf<Int>(1, 2, 3) } 这里扒了两者字节码，说明了区别存在于JAVA装箱 后者使用了装箱，会影响效率。IntArray比**Array**效率更高。 ...
【STL】C++ STL之array详解
热门推荐
行码棋
02-14 1万+
c++ STL之array详解
为什么不直接使用 Array<Int> 而是 IntArray ？
Kotlin中文社区
01-09 6377
基本类型居然有特殊待遇其实我们用数组的场景不太多。有一天在做demo的时候，我突然意识到有Array<Int>和 IntArray 这两种完全不同的存在，...
array
不积极分子
08-29 135
array 静态数组，数组个数一经确认不可修改。 初始化 array<int,10>a;垃圾值 array<int,10>a{};全部为0 array<int, 10>a{ 1, 2, 3 };不能这样赋值 error get array 容器还提供了 get<n> 模板函数，它是一个辅助函数，能够获取到容器的第 n 个元素 用法 get<常量>（变量名） array<string, 5> words{ "one","two"
TIA博途中数组Array【】的基本使用方法详解.docx
10-08
### TIA博途中数组Array【】的基本使用方法详解 #### 一、数组Array【】概述 在TIA博途（Totally Integrated Automation Portal）中，数组(Array)是一种重要的数据结构，它由固定数量且相同数据类型的元素组成。...
vbscript基础篇 - vbs数组Array的定义与使用方法
08-27
vbscript基础篇 - vbs数组Array的定义与使用方法 VBScript中的数组是一种非常重要的数据类型，它允许开发者存储和操作多个值。下面将详细介绍VBScript中的数组的定义和使用方法。 数组的定义 在VBScript中，数组...
Javascript数组Array方法解读
01-19
接上一篇《Javascript数组Array基础介绍》，这一篇详细介绍Array的所有方法。 所有数组的方法都定义在Array.prototype上,而Array.prototype本身也是一个数组。 array.concat() 浅复制一份当前数组，并把接收到的...
PHP数组array类常见操作示例
10-15
本篇文档将深入介绍PHP数组array类的常见操作，包括合并数组、计算数组差集以及获取数组键名等，通过实例来帮助理解各函数的使用方法和注意事项。 合并数组是数组操作中非常常见的一种需求，PHP通过`array_merge`...
Javascript基础教程之数组 array
01-19
如果想使用变量存储一组值，就需要使用数组(array)。 数组是由多个名称相同的树值构成的集合，集合中每个数组都是数组的元素（element），可以使用变量team存储团队里每个成员的名字。 在JavaScript中，数组使用...
C++ array
柯拉的博客
04-21 304
#include <iostream> #include <array> using namespace std; void fun(array<int,4>a) { for (auto v : a) { cout << v << endl; } } int main() { //...
Array数组
最新发布
m0_55047422的博客
11-23 305
Array数组
array详解
m0_59666413的博客
11-09 4527
array详细介绍
Java知多少（14）数组
weixin_34365417的博客
03-24 173
如果希望保存一组有相同类型的数据，可以使用数组。 数组的定义和内存分配 Java 中定义数组的语法有两种： 1 type arrayName[]; 2 type[] arrayName; type 为Java中的任意数据类型，包括基本类型和组合类型，arrayName为数组名，必须是一个合法的标识符，[ ] 指明该变量是一个数组类型变量。例如： 1 int demo...
动态数组Array
weixin_60413769的博客
03-14 324
Array.h #ifndef ARRAY_H #define ARRAY_H #include<cassert> template<class T> class Array{ private: T * list;//T类型的指针，用于存放动态分配的数组首地址 int size; public: Array(int sz=50);//构造函数 Array(const Array<T>&a);//复制构造函数
《C++沉思录》第12章简单数组Array类
qq_25048473的博客
12-20 154
#ifndef _ARRAY_H__ #define _ARRAY_H__ ///设计Array类 void f() { int* p; { Array<int> x(20); p = &x[10]; } } /* * 存在2个缺陷： * 第一个：Array<T>::operator[]返回一个T&,所以根本无法阻止用户取得它返回的对象的地址，在上面的例子中，Array对象x超出了作用域，而p还指向它的...
数组(Array)
XYZ1110i的博客
03-19 1731
1：一维数组 数组(array)： 是一种用于存储多个相同数据类型的存储模型(可以理解为容器)。 1.2 数组定义和静态初始化 数组有两种定义格式： 格式1：数据类型[] 变量名; 范例： int[] arr; 定义了一个int类型的数组，数组名是arr 格式2：数据类型 变量名[]; 范例： int arr[]; 定义了一个int类型的变量，变量名是arr数组 推荐用格式1 数据的初始化 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度 格式：数据类型[] 变量名
数组(array)概述
gtcp2305的博客
08-19 583
数组 array 数组在内存中的存储方式是连续、不间断的，访问数组中的元素需要按索引值访问。 对于数据类型T和常整数N，声明一个数组的格式如下： T A[N]; 该声明有两个效果：1、在内存中分配一段L*N字节，连续的区域，其中L是数据类型T的大小；2、引进一个符号A，可以用作指向数组起始位置的指针。这个指针的值（数组首地址）假设为xA，那么数组元素i(0A+i*L。 X86-64的
Array数组java练习
Eliaukgit的博客
10-24 825
德行善举是惟一不败的投资。
深入理解JavaScript数组Array方法
"本文主要解析JavaScript中的数组Array方法，包括concat、join和push等核心方法的使用和原理。" 在JavaScript中，数组Array是经常使用的数据结构，它提供了丰富的内置方法来帮助我们处理和操作数组。这篇教程将深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值