数组的相关基础知识点总结

最新推荐文章于 2023-05-13 14:43:29 发布
最新推荐文章于 2023-05-13 14:43:29 发布
阅读量552 收藏 3
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zyf15156243165/article/details/126649269
版权

1.数组介绍

    目录:
            数组介绍
            数组的定义和静态初始化
            数组的元素访问
            数组遍历
            数组动态初始化
            数组内存图(第二阶段讲)
            数组常见问题
            数组常见操作


数组:数组指的是一种容器,可以用来存储同种数据类型的多个值
    数组容器在存储数据的时候,需要结合隐式转换考虑.
    例如: int类型的数组容器(byte short int)
    例如: double类型的数组容器(byte short int long float double)
    建议:容器的的类型,和存储的数据类型保持一致

2.数组的定义和静态初始化

数组的定义和静态初始化
数组的定义:
          格式1: 数据类型[] 数组名          格式2:数据类型   数组名[]
              eg: int [] array               eg: int array []


数组的初始化:
  1.静态初始化
  2.动态初始化

  数组的静态初始化:
          初始化:就是在内存中,为数组容器开辟空间,并将数据存入容器的过程

          完整格式:数据类型[]数组名 = new 数组类型[]{元素1,元素2,元素3...}
          简化格式:数据类型[]数组名 = {元素1,元素2,元素3...}

          eg : int[]array = new int[]{11,12,13};              (数组一旦创建完毕后,其长度就固定了,是3,不能发生变化1)
               int[]array = {11,12,13};

          eg: double[]array = new int[]{11.1,22.2,33.3};
              double[]array = {11.1,22.2,33.3};

public class Summary1 {
    public static void main(String[] args) {
        //需求1:定义数组存储5个学生的年龄
        int[] arr1 = new int[]{11,12,13,14,15};
        int[] arr2 ={11,12,13,14,15};
        //需求2:定义数组存储3个学生的姓名
        String[] arr3 = new String[]{"zhangsan","lisi","wangwu"};
        String[] arr4 = {"zhangsan","lisi","wangwu"};
        //需求3:定义数组存储4个学生的身高
        double[] arr5 = {17.3,17.4,17.5};
        double[] arr6 = {17.3,17.4,17.5};
        System.out.println(arr6);//[D@75412c2f

        //数组的地址值(表示数组在内存中的位置)
        //扩展:
        //解释一下地址值的特殊含义[D@75412c2f
        //[:表示当前一个数组
        //D : 表示当前数组里面的元素都是double类型的
        //@ : 表示一个间隔符号(固定格式)
        //75412c2f : 才是数组真正的地址.(十六进制)
        //平时我们习惯性的把这个整体叫做数组的地址值.
    }
}
数组的地址值(表示数组在内存中的位置)
扩展:
解释一下地址值的特殊含义[D@75412c2f
[:表示当前一个数组
D : 表示当前数组里面的元素都是double类型的
@ : 表示一个间隔符号(固定格式)
75412c2f : 才是数组真正的地址.(十六进制)
平时我们习惯性的把这个整体叫做数组的地址值.

3.数组元素访问

数组元素访问
  格式 : 数组名[索引];
      索引:也叫做下标,角标.(它也表示为数组容器里面每个小格子的编号)
public class Summary2 {
    public static void main(String[] args) {
        //利用索引对数组中的元素进行访问
        //1.获取数组中的元素
        //      格式 : 数据名[索引];


        int[] arr = {1,2,3,4,5};
        //获取数据中的第一个元素
        //其实就是0索引上对应的元素
        int number = arr[0];
        System.out.println(number);//1

        //获取数组中1索引上对应的数据,并打印出来
        System.out.println(arr[1]);//2


        //2.把数据存储到数组当中
        //  格式 :        数组名[索引] = 具体数据/变量;
        //  细节 : 一旦覆盖后,原来的数据就不存在了
        arr[0] = 100;
        System.out.println(arr[0]);//100

    }
}

4.数组遍历

数组遍历(将数组中所有的内容取出来,取出来之后可以(打印 求和 判断 ...))
  注意: 遍历指的是取出数据的过程,不要局限的理解为,遍历就是打印
public class Summary3 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1,2,3,4,5};
        //获取数组里面所有的元素
        //格式:数据名[索引]
        /*System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);*/


        //利用循环改进代码(如果数组很长,不可以一行行写)
        //开始条件 : 0
        //结束条件 : 数组长度 - 1(最大索引)
        /*for (int i = 0; i < 5; i++) {
            // i : 0 1 2 3 4
            System.out.println(arr[i]);
        }*/


        //在java中,关于数组的一个长度属性,length
        //调用方式: 数组名 : length
        /*System.out.println(arr.length);*/
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }


        //扩展
        //自动的快速生成数组的遍历方式
        //idea提供
        //数组名.fori
    }
}

相关练习1

//遍历数组并求和

public class Summary3Test1 {
    public static void main(String[] args) {
        //定义一个数组,存储1,2,3,4,5遍历数组得到每一个元素,求数组里面所有数据之和

        //分析
        //1.定义一个数组,并添加数据1,2,3,4,5
        int[] arr = {1,2,3,4,5};
        //求和变量
        int sum = 0;
        //2.遍历数组得到数组中的每一个数据,累加求和
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            //i 依次表示数组里面每一个索引
            //arr[i] 依次表示数组里面每一个元素

            sum = sum + arr[i];
        }
        System.out.println(sum);
    }
}

相关练习2

//统计个数


public class Summary3Test2 {
    public static void main(String[] args) {
        //定义一个数组,1,2,3,4,5,6,7,8,9,10
        //遍历数组得到每一个元素,统计数组里面一共有多少个能被3整除的数字

        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 3 == 0){
                count++;
            }
        }
        System.out.println("数组中能被3整除的数字有" + count + "个");
    }
}

相关练习3

//数据变化


public class Summary3Test3 {
    public static void main(String[] args) {
        /*定义一个数组,存储1,2,3,4,5,6,7,8,9,10
        遍历数组得到每一个数据
        要求:
        1.如果是奇数,则将当前数字扩大两倍
        2.如果是偶数,则将打钱数字变成二分之一
         */

        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 2 == 0){
                arr[i] = arr[i] / 2;
            }else{
                arr[i] = arr[i] * 2;
            }
            //System.out.println(arr[i]);
        }

        //遍历数组
        //一个循环只做一件事情.
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

5.数组的动态初始化

数组的动态初始化
  int[] arr = {1,2,3,4,5};    用静态解决
  int[] arr = {???};          用动态解决

动态初始化:初始化时只指定数组的长度,由系统为数组分配初始值

格式:  数据类型[] 数组名 = new 数据类型[数组长度];
eg :  int[] arr = new int[3];
public class Summary4 {
    public static void main(String[] args) {
        /*需求:定义一个数组,用来存班级中50个学生姓名
        姓名未知,等学生报到后,再进行添加
         */

        //格式:
        //数据类型[] 数组名 = new 数据类型{数组长度};
        //在创建的时候,由我们自己指定数组的长度,由虚拟机给出默认的初始化值


        String[] arr = new String[50];
        //添加学生
        arr[0] = "zhangsan";
        arr[1] = "lisi";
        //获取
        System.out.println(arr[0]);//zhangsan
        System.out.println(arr[1]);//lisi
        System.out.println(arr[2]);//打印出来的默认化初始值为null


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

        int[] arr2 = new int[3];
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

数组动态初始化和静态初始化的区别:
      动态初始化 : 手动指定数组的 长度 ,由系统给出默认初始化值
             (只明确元素的个数,不明确具体数值,推荐使用动态初始化)
              eg : 使用数组容器来存储键盘录入的五个整数
                  int[] arr = {?????};
                  int[] arr = new int[5];


      静态初始化 : 手动指定数组的 元素 ,系统会根据元素的个数,计算出数组的长度
              (需求中已经明确了要操作的具体数值,直接静态初始化即可)
              eg : 将全班学生成绩存入数组中 11 22 33
                  int[] arr = {11,22,33}

6.数组常见问题
      当访问了数组中不存在的索引,就会引发索引越界异常

public class Summary6 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1,2,3,4,5};
        //长度:5
        //最小索引:0
        //最大索引:4 (数组长度-1)
        System.out.println(arr[10]);


        //小结:
        //索引越界异常
        //原因:访问了不存在的索引
        //避免:索引的范围
        //最小索引:0
        //最大索引:4 (数组长度-1)
    }
}


   7.数组常见操作:
       1.求最值
       2.求和
       3.交换数据
       4.打乱数据

//最值
public class Summary7 {
    public static void main(String[] args) {
        //需求:定义数组求最大值  33 5 22 44 55

        //扩展问题:
        //1.根据求最大值的思路,自己改写一下就最小值
        //2.为什么max要记录为arr[0],不能为默认值0?
        //不能写0
        //max的初始化值一定要是数组中的值
        //3.循环中开始条件一定是0吗?
        //循环的开始条件如果为0,那么第一次循环的时候是自己跟自己比一下,对结果没有任何影响,但效率偏低
        //为了提高效率,减少一次循环的次数,循环开始条件可以写1


        //1.定义数组用来储存五个值
        int[] arr = {33,5,22,44,55};
        //2.定义一个max变量用来储存最大吃
        //临时认为0索引的值是最大的
        int max = arr[0];
        //3.循环获得数组中的每一个元数
        //拿每一个元素跟max进行比较
        for (int i = 1; i < arr.length; i++) {
            //i 索引  arr[i]  数组中的元素
            if (arr[i] > max){
                max = arr[i];
            }
        }
        System.out.println(max);//55

    }
}

相关练习4

//求和

import java.util.Random;


public class Summary7Test1 {
    public static void main(String[] args) {
        /*需求:生成10个1~100之间的随机数存入数组
            1)求出所有数据之和
            2)求出所有数据的平均值
            3)统计有多少个数据比平均值小
         */

        //分析:
        //1.定义数组
        int[] arr = new int[10];
        //2.把随机数存入到数组中
        Random r = new Random();

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

        //1)求所有数据之和
        //定义求和变量
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            //循环得到每一个元素
            //并把元素累加到sum当中
            sum = sum + arr[i];
        }
        System.out.println(sum);

        //2)求出所有数据的平均值
        int avg = sum / 10;
        System.out.println("所有的数据的平均值为"+ avg);

        //3)统计有多少个数据比平均值小
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < avg){
                count++;
            }
        }
        System.out.println("统计有" + count + "个数据比平均值小");


        //遍历数组,验证答案
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }


    }
}

相关练习5

//交换数组中的数据
public class Summary7Test2 {
    public static void main(String[] args) {
        /*需求:定义一个数组,存入1,2,3,4,5.交换收尾对应的索引元素
        交换前 : 1,2,3,4,5
        交换后 : 5,4,3,2,1
         */

        //1.定义数组存储数据
        int[] arr = {1,2,3,4,5};
        //2.利用循环去交换数据
        for (int i = 0,j = (arr.length - 1);i < j;i++,j--){
            //交换变量i和变量j指向元素
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        //当循环结束时,那么数组中的数据就实现了头尾交换
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }



        /*int[] arr = {1,2,3,4,5};
        int temp1 = arr[0];
        arr[0] = arr[4];
        arr[4] = temp1;
        int temp2 = arr[1];
        arr[1] = arr[3];
        arr[3] = temp2;

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
*/
    }
}

相关练习6

public class Summary7Test3 {
    public static void main(String[] args) {
        //需求:定义两个变量,交换两个变量记录的值
        int a = 10;
        int b = 20;

       /* //把变量b的值赋值给了a,那么a原来的值就覆盖了
        a = b;  //a = 20;b = 20
        //把变量a的值赋值给了b
        b = a;  //a = 20;b = 20

        System.out.println(a);
        System.out.println(b);*/

        //定义一个第三方变量
        int temp = a;
        a = b;
        b = temp;
        System.out.println(a);//20
        System.out.println(b);//10
    }
}

相关练习7

public class Summary7Test4 {
    public static void main(String[] args) {
        //需求:定义一个数组,将数组中0索引和最大索引的值进行交换

        //1.定义一个数组
        int[] arr = {1,2,3,4,5};
        //2.将数组中0索引和最大索引的值进行交换
        //也是可以利用第三方变量进行交换
        int temp = arr[0];
        arr[0] = arr[4];
        arr[4] = temp;

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " "); //52341  空格隔开
        }
    }
}

相关练习8

//打乱数组中的数据

import java.util.Random;

public class Summary7Test5 {
    public static void main(String[] args) {
        //需求:定义一个数组,存入1-5,要求打乱数组中所有数据的顺序.
        //难点:
        //如何获取数组中的随机索引
      /*  int[] arr = {1,2,3,4,5};
        //索引范围: 0 1 2 3 4
        Random r = new Random();
        int randomindex = r.nextInt(arr.length);
        System.out.println(randomindex);*/


        //1.定义数组1~5
        int[] arr = {1,2,3,4,5};
        //2.循环遍历数组,从0索引开始打乱数据的顺序
        Random r = new Random();
        for (int i = 0; i < 5; i++) {
            //生成一个随机数组
            int randomindex = r.nextInt(arr.length);
            //拿着随机索引指示的元素,跟i指向的元素进行交换
            int temp = arr[i];
            arr[i] = arr[randomindex];
            arr[randomindex] = temp;
        }

        //当循环结束后,那么数组中所有的数据已经打乱顺序了
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }


    }
}

三重刘德华（男人中的极品）
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java基础知识点总结.docx
04-03
Java学习更是如此，知识点总结目录如下： 目录 一、 Java概述 3 二、 Java语法基础 5 数据类型 5 运算符号 14 语句 15 函数 15 方法重载（Overloadjing）与重写（Overriding） 16 数组 17 总结 18 三、 常见关键字 ...
数组的基本知识
m0_63783532的博客
10-31 3607
数组：按照一定个数排列起来的，具有相同类型的数据元素的集合。一维数组：若线性表中的数据元素为非结构的简单元素，则称为一维数组。一维数组的逻辑结构：线性结构。定长的线性表。声明格式：数据类型 变量名称[长度] int a[5];二维数组：若一维数组中的元素又是一维数组结构，则称为二维数组。二维数组的逻辑结构（可以看成非线性结构也可以看成线性结构）：1.非线性结构：每一个数据元素既在一个行表中，又在一个列表中。2.线性结构：该线性表的每个数据元素也是一个定长的线性表。
数组的相关知识
weixin_927326的博客
02-09 1605
数组的概念、定义格式、动态初始化、静态初始化、数组的遍历、获取数组最值、数组逆序、查找数组元素、二维数组的语句定义格式、二维数组的遍历等相关知识及例题
数组知识总结
qq_63431486的博客
12-11 735
数组知识总结
数组常用的函数
m0_74331185的博客
10-18 2261
数组常用函数js
Java数组类型
HHYZBC的博客
04-26 4759
数组的概述 数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。 数组的长度一旦确定，就不能修改。 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。 数组的分类： 按照维度：一维数组、二维数组、三维数组、… 按照元素的数据类
Java面试高频知识点总结
12-21
Java基础 – NIO的实现原理 NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。传统 IO 基于字节流和字符流进行操作，而 NIO 基于 Channel 和 Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区...
PHP七种数据类型知识点总结
12-19
想要入门PHP，首先要学会搭建环境，其次是学习基础语法。... 数组, 对象, 资源。 PHP的数据类型示例如下： <?php /*字符串（String）： 指单引号或双引号包住的一串字符*/ echo "12rqwr#@%"; echo 'rq#@wr12%';
JavaScript 语言基础知识点总结（思维导图）
12-12
JavaScript 数组 JavaScript 函数基础 Javascript 运算符 JavaScript 流程控制 JavaScript 正则表达式 JavaScript 字符串函数 JavaScript 数据类型 JavaScript 变量 Window 对象 DOM 基本操作    由于上面的...
C语言知识点总结（3）
07-21
今天讲解C语言知识点总结（3），大家拿好笔记本，赶紧来记下吧。
数组知识点
m0_57388581的博客
02-05 959
励志模块 你未来的路还很长别自卑别将就 一 、一维数组的创建和初始化 1.1数组的创建 数组是一组相同类型元素的集合。 数组的创建方式： 代码展示： int arr[5]; char ch[5]; double arr1[10]; int arr[5]; char ch[5];这些都可以，但是不能用int aar[n]；因为[ ]内必须是常量表达式。 （C99标准之前是不支持变量的，只能是常量。 C99标准中增加了变长数组的概念，允许数组的大小出现变量，但是要求编译器必...
第二阶段笔记 数组
m0_45229352的博客
03-20 281
第二阶段笔记 数组
数组知识点总结
weixin_72563696的博客
05-13 787
如： int a[5]；={?
数组知识点汇总
weixin_42072280的博客
10-30 1146
目录 一、一维数组 1、​​​​​​​数组的概念 2、数组的使用方法 2.1 数组的定义 2.2 数组元素的引用 3、数组元素赋初值 ​​​​​​​4、使用数组处理数据的特点 5、一维数组例题 二、二维数组 ​​​​​​​1、二维数组 2、二维数组的内存映像图 ​​​​​​​3、二维数组赋初值 ...
数组常用知识点整理
JustinNeil的博客
04-15 386
数组常用知识点整理数组概念的引入数组的定义数组的内存分析注意事项数组的应用数组的声明数组中的常见错误二维数组数组常用方法数组遍历数组求值（最大值，最小值，和）数组的倒置数组的排序数组的基本查找数组的工具类Arrays 数组概念的引入 当我们需要处理多组同类型数据时，使用数组可以缩短和简化程序，因为可以利用索引值设计一个循环，高效处理多种情况。 数组的定义 所谓数组，是有序的元素序列。 若将有限个类...
有关数组的知识点总结
qq_43240347的博客
12-22 251
知识点总结： 1、数组分一位数组，二维数组以及多位数组。 定义方式；数组类型  变量名［］中括号中尾为数租的大小。形如int a［110］、int b［110］［110］；其实质和变量的定义基本类似。                    注意：［］中在定义一个数组时，其里面必须是一个具体的数，不可以是变量，即使这个变量被初始化了也不可以，另外，为防止出现数组越界的            ...
数组的基础知识
m0_70552412的博客
06-16 245
【既然想要学习数组，我们要了解以下基础的知识点和例子】数组的作用可以把一组数据集合放在单个变量下创建数组有两种方法：分别为利用new来创建数组和利用数组字面量来创建数组，而这种字面量方式也是我们以后用的最多的一种方式 具体看例子1例1：数组的字面是用方括号[ ]来表示的声明并赋值称为数组的初始化数组中可以存放任意类型的数据，例如：字符串 数字 布尔值等具体看例子2例2： 在例2中可以看出数组里面的数据一定要用逗号分离数组里面的数据如 1，2，3， 我们称之为数组元素【我们简单了解一点点数组的基本知识点后，就
数组基础知识
m0_74331160的博客
10-17 168
基本for循环、for-in循环、for-of循环、forEach循环、map循环 冒泡排序
计算机二级c语言知识点总结
最新发布
08-31
计算机二级C语言知识点主要包括语法基础、数据类型、运算符、控制语句、函数、数组、字符串、结构体、指针等内容。 首先是语法基础，包括标识符的命名规则、注释的使用方法、变量的定义和声明等。掌握这些基础知识...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值