JavaSE第5篇：数组

已于 2022-12-21 11:46:11 修改
阅读量301 收藏
点赞数
分类专栏： Java基础 文章标签： java
于 2022-04-17 21:05:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29445811/article/details/124231300
版权

文章目录

一、数组简介

1、多个相同类型的数据按一定的顺序排列的集合就是数组。其实数组就是一个容器

2、数组名、元素、 下标、 数组长度

3、数组是有序排列的

4、数组属于引用数据类型的变量、但是数组中的元素可以是任何数据类型(基本数据类型和引用数据类型)

5、数组的分类：

① 按维度：一维数组、二维数组(多维数组)

②按数组元素的类型：基本类型元素的数组、引用数据类型元素的数组

二、一维数组的使用

1、数组的声明和初始化

        int a; //变量的声明
        a = 1;//初始化
        int b = 1;//声明和初始化

        int array[]; //数组声明
        array = new int [2];  //初始化(数组是引用数据类型、必须是new关键字)
        //①静态初始化：数组的初始化和数组元素的赋值操作同时进行
        int n[] = new int[]{1,2,3};
        //②动态初始化：数组的初始化和数组的元素分开进行
        int n1[] = new int[3];

        //动态初始化
        int array [] = new int[5];
        //静态初始化
        int array1[] = new int[]{1,2};

数组一旦初始化其长度是确定的array.length

数组长度一旦确定、长度是不可能修改的

总结：数组一旦初始化完成、其长度是确定的

2、调用数组指定位置的元素
通过索引的方式调用、索引从0开始到数组的长度减1结束

        //动态初始化
        int array[] = new int[5];
        log.info(String.valueOf("长度：" + array.length));
        array[0]=1;
        
	     //获取字符串元素
        String s [] =new String[]{"12"};
        String s1 = s[0];
        char c = s1.charAt(1);
        System.out.println(c);

3、获取数组的长度

        String s [] =new String[]{"12"};
        int cd =s.length;

4、遍历数组的元素

        String s [] =new String[]{"12"};
        for (int i = 0; i <s.length ; i++) {
            System.out.println(s[i]);
        }

5、数组元素默认的初始化值
数组元素是整型 byte int short long 默认初始化值是0
数组元素是浮点型 float double 是0.0
数组元素是char类型 默认是0 这个0是ASCII码 或者是'\u0000' unicode码 而不是'0'
数组元素是boolean型 false
数组元素是引用数据类型时默认是null

6、数组的内存解析
简单的内存结构
nei存
一维数组内存解析

neicun

三、二维数组的使用

1、二维数组理解

我们可以看成一维数组array1作为另一个一维数组array2的元素存在的是二维数组(数组本身是引用数据类型)

2、二维数组使用
1、二维数组的声明和初始化
二维数组的元素就是一个数组

        //类型推断
        int a[] = {1, 2};
        //静态初始化
        int[][] array = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};

        //动态初始化
        int[][] array2 = new int[1][2];//行和列都行

        int[][] array3 = new int[1][];//行可以写 列可以去掉

2、二维数组调用数组指定位置的元素

        System.out.println(array[0][1]);
        String [][] array4 = new String[3][];
        array4[1] = new String[4];
        System.out.println(array4[1][0]);

在这里插入图片描述

3、二维数组获取数组的长度

        int[][] array = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        System.out.println(array.length);
        System.out.println(array[0].length);

4、二维数组遍历

        //静态初始化
        //1   2   3
        //4   5
        //6   7   8   
        int[][] array = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }

        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.println(anInt);
            }
        }

5、二维数组元素默认的初始化值
规定：二维数组分为 外层数组元素 内层数组元素

        int [][] array =new int[2][3];
        //外层元素：array[0] array[1]
        //内存元素：array[0][0],array[1][2]
        System.out.println( array[0]);//地址值 [I@783e6358
        System.out.println( array[0][0]);//0
        double [][] array2 =new double[2][];
        System.out.println( array2[0]);//null
        System.out.println( array2[0][0]);//java.lang.NullPointerException

对于初始化方式一

比如int [][] array = new int[2][3]
外层元素初始化值为地址值
内存元素初始化值与一维数组初始化情况相同(看内存元素数据类型)

对于初始化方式二

int [][] array = new int[2][]
外层元素初始化值为null
内存元素初始化值不能调用 报错空指针

6、二维数组数组的内存解析

er122
数据结构
1、数据与数据之间的逻辑关系: 集合 一对一、 一对多、多对多

2、数据的存储结构：
线性表：顺序表（数组）、链表、栈、队列

树形结构：二叉树

图形结构

算法

排序算法

搜索算法

四、数组的常见算法

1、数值型元素数组的操作-最大值、最小值、平均数、总和

    @Test
    public void maxArrays() {
        int[] array = {10,22,34};
        int max =0;
//        for (int i = 0; i < array.length; i++) {
//            array[i] =(int) ((Math.random() * (99-10+1)) + 10);
//        }
        for (int i = 0; i < array.length; i++) {
           if(max<array[i]){
               max=array[i];
           }
           
        }

        System.out.println(max);
    }



    @Test
    public void minArrays() {
        int[] array = {10, 22, 34};
        int min = array[0];
//        for (int i = 0; i < array.length; i++) {
//            array[i] =(int) ((Math.random() * (99-10+1)) + 10);
//        }
        for (int i = 0; i < array.length; i++) {
            if (min > array[i]) {
                min = array[i];
            }

        }
        System.out.println(min);
    }


    @Test
    public void sumArrays() {
        int[] array = {1, 2, 3};
        int sum = 0;
//        for (int i = 0; i < array.length; i++) {
//            array[i] =(int) ((Math.random() * (99-10+1)) + 10);
//        }
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println(sum);
    }

    @Test
    public void avgArrays() {
        int[] array = {1, 2, 3};
        int sum = 0;
//        for (int i = 0; i < array.length; i++) {
//            array[i] =(int) ((Math.random() * (99-10+1)) + 10);
//        }
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
       //平均数
        int avg = sum/array.length;
        System.out.println(avg);
    }

2、数组赋值、复制

 //数组赋值
    @Test
    public void arrays1() {
       
        int[] array1, array2;
        array1 = new int[]{2, 3, 4};
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i] + "\t");
        }

        array2 = array1;
        //修改array2中的偶元素，使其等于索引值
        for (int i = 0; i < array2.length; i++) {
            if (i % 2 == 0) {
                array2[i] = i;
            }
        }

        System.out.println();
        //打印array1
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
    }

	 //数组复制
    @Test
    public void arrays2() {
        //数组复制
        int[] array1, array2;
        array1 = new int[]{2, 3, 4};
        array2 = new int[array1.length];
        for (int i = 0; i < array2.length; i++) {
            array2[i] = array1[i];
        }
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
    }

思考array1和array2地址值相同、都指向了堆空间的唯一一个数组实体

复制（区别与数组变量的赋值: array1 =array）

    @Test
    public void copyArrays() {
        String[] array1 = {"a", "b"};
        //复制操作就是在堆内存中在创建一个数组、数组长度为复制的数组的length
        String[] array2 = new String[array1.length];
        for (int i = 0; i < array1.length; i++) {
            array2[i] = array1[i];
        }
    }

二维数组赋值使用
在这里插入图片描述

    @Test
    public void arrays2() {
     int array[][] = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
     int sum =0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                sum +=array[i][j];
            }
        }
        System.out.println(sum);
    }

在这里插入图片描述yanghui


    @Test
    public void arrays2() {
        int[][] yanghui = new int[10][];

        for (int x = 0; x < yanghui.length; x++) {
            //给数组的元素赋值
            yanghui[x] = new int[x + 1];
            //给首末元素赋值
            yanghui[x][0] = 1;
            yanghui[x][x] = 1;

            //给每行的非首末元素赋值
            if (x >1) {
                for (int y = 1; y < yanghui[x].length-1; y++) {
                    yanghui[x][y] = yanghui[x - 1][y - 1] + yanghui[x - 1][y];
                }
            }

        }

        //打印
        for (int i = 0; i < yanghui.length; i++) {

            for (int i1 = 0; i1 < yanghui[i].length; i1++) {
                System.out.print(yanghui[i][i1] + " ");
            }
            System.out.println();
        }
    }

1

    @Test
    public void arrays3() {
        int[] array = new int[6];
        for (int i = 0; i < array.length; i++) {
            array[i] = (int) ((Math.random() * 30) + 1);
            for (int j = 0; j < i; j++) {
                if (array[i] == array[j]) {
                    i--;
                    break;
                }
            }
        }
        //遍历
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

回形算法
22
22

3、反转、查找（线性查找、二分法查找）

反转：就是两个变量进行交换

    @Test
    public void arrays3() {
//        int a =1;
//        int b =2;
//        int tem =a;
//        a =b;
//        b =tem;
//        System.out.println(a);
//        System.out.println(b);
        String[] array = new String[]{"AA", "BB", "CC", "DD"};
//        for (int i = 0; i < array.length / 2; i++) {
//            String temp = array[i];
//            array[i] = array[array.length - i - 1];
//            array[array.length - i - 1] = temp;
//        }

        for (int i = 0, j = array.length - 1; i < j; i++, j--) {
            String temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

线性查找

        String[] array = new String[]{"AA", "BB", "CC", "DD"};

        String f = "BB";
        for (int i = 0; i < array.length; i++) {
            if(f.equals(array[i])){
                System.out.println(array[i]);
                break;
            }
        }

二分法查找
前期必须有序

    @Test
    public void arraysFen() {
        //二分法查找叫折半查找
        int a = -7;
        int array[] = {23, 33, 12, 3, -7, 55, 89, 0, 13, 11};
        boolean flag = true;
        int head = 0;//头部索引
        int end = array.length - 1;//尾部索引
        int mid = (head + end) / 2;//中间索引
        while (head < end) {
            if (a == array[mid]) {
                System.out.println("找到了指定元素，位置为：" + mid);
                flag =false;
                break;
            } else if (array[mid] > a) {
                end = mid - 1;
            } else {//array[mid]<a
                head = mid + 1;
            }
        }

        if(flag){
            System.out.println("没有找到");
        }
    }

4、排序

时间复杂度 空间复杂度 稳定性

内部排序在内存中完成

外部排序借助磁盘完成

paixu

1、冒泡排序
思想：比较相邻的两个元素、第一个比第二个大、就交换他们两个

    @Test
    public void maopao() {
        int array[] = {44, 33, 12, 3, -7, 55, 89, 0, 13, 11};
        //array.length-1 外层长度减一 最后一个元素不需要比较 也可以比较不用减一
        for (int i = 0; i < array.length-1; i++) {
            //array.length-1-i
            // 内层长度：就是数组长度相邻比较后的次数就是长度减一
            // 减i:就是每比一次少个元素进行减i
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    int temp =array[j];
                    array[j] =array[j+1];
                    array[j+1]=temp;

                }

            }
        }

        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"\t");
        }
    }

2、快速排序
kuaisu

五 、Arrays工具类

六、数组的常见异常

1、数组越界 java.lang.ArrayIndexOutOfBoundsException

2、空指针

总结

明了LM
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
05_javase复习总结之数组
04-23
### 05_javase复习总结之数组 #### 数组定义和基本用法 在Java中，数组是一种基本的数据结构，用于存储固定大小的同类型元素集合。它提供了高效的访问和管理这些元素的方式。 ##### 数组声明与初始化 1. **声明...
JavaSE 基础 数组.pdf
07-23
第五种是在声明时提供初始值，但只适用于数组长度已知的情况，如`int[] arr = new int[3]{30, 97, 65}`。 在操作数组时，常见操作包括访问元素、遍历数组（通常使用for循环）、复制数组（System.arraycopy()或...
JavaSE第六章：数组
m0_74087660的博客
10-16 158
JavaSE第六章数组以及数组的相关操作，如拷贝、扩容、缩减、排序、查找(二分、顺序)，以及经典题目，如、杨辉三角、有序数组插入元素仍有序等一些例题
JavaSE（二）：数组
最新发布
m0_70830675的博客
03-18 1070
一、数组的基本概念及作用数组：是一组相同数据类型元素的集合,是一个容器①数组可以存储基本数据类型，也可以存储引用数据类型②数组创建时必须指定长度,且长度不可变③数组中每个元素空间是连续的声明数组格式：数据类型 [] 数组名字 例如：int [] a;数据类型 数组的名字 [] 例如： int a [];● 注意： 在Java语言中两种声明方法没有任何区别，但是建议大家用第一种， 避免混淆a的数据类型。二、数组的创建●数组的声明的两种方式：数据类型 [] 数组名字。
008-JavaSE基础巩固练习：数组综合练习
yelitoudu的博客
10-27 815
JavaSE基础巩固练习：数组综合练习 1、遍历数组并求和 2、统计个数 3、变化数据 4、求最值 5、求和并统计个数 6、交换数据 7、打乱数据
重学JavaSE 第5章 : 数组概念、数组内存分析、数组常见算法、Arrays工具类、数组中常见异常
Guizy
07-31 909
重温Java 数组概念、数组内存分析、数组常见算法、Arrays工具类、数组中常见异常
JavaSE: Lesson7: 数组
哔哔小鸡
08-17 112
JavaSE: Lesson7: 数组 1.数组 1.1什么是数组【理解】 ​ 数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。 1.2数组定义格式【记忆】 1.2.1第一种 ​ 数据类型[] 数组名 ​ 示例： int[] arr; double[] arr; char[] arr; 1.2.2第二种 ​ 数据类型 数组名[] ​ 示例： int arr[]; double arr[]; char arr[]; 1.3数组动态初始化【应用】 1.3.1什么是动
JavaSE语法之五：数组的定义与使用（超详解！！！）
T2283380276的博客
12-07 1210
数组是用来存储一组相同类型的数据的，在内存中是一段连续的空间。
Javase（day07：数组的常用操作）
zsjss15的博客
03-03 436
1、查找数组元素下标 /* 获取元素59在数组{5, 12, 90, 18, 77, 76, 45, 28, 59, 72}中的索引。 1、只查找第一次出现时的下标 2、如果不存在，返回-1*/public class FindElement { public static void main(String[] args) { int[] arr = {5, 12, 90, 18, 77, 76, 45, 28, 59, 72}; int num = 59;..
javase笔记 day05：数组排序+多维数组
CODE_MrLEE的博客
08-12 280
2019/07/05 08:26 【数组】： 引用数据类型（地址） for-each不适用于数组遍历，因为没有索引 【数组浅复制】： 需要创建新的存储区域，并依次确定每隔元素的值 【元素交换位置】： 1.利用第三个变量交换数值，简单的方法。 int x =5,y=10; //定义两个变量 int temp = x;　　　　//定义第三临时变量temp并提取x值 x = y;　　　　　...
JavaSE：第五章：数组
weixin_44519496的博客
09-14 74
史上最全的知识体系脑图，覆盖所有知识点，所有细节，注意事项。 数组：包含一维数组，二维数组，Arrays的常用算法，Arrays工具类的使用，可变形参，常见异常，理解main方法的语法。 更多请见：http://www.mark-to-win.com/tutorial/51143.html ...
JavaSE程序设计课件：L02-Object-oriented programming - 1.pdf
06-18
- 初始化数组：可以使用循环来初始化数组的所有元素，例如，对于一个整数数组，可以使用 `for` 循环将每个元素设为特定值。 - 打印数组：通过遍历数组并逐个打印元素，可以使用 `for-each` 循环简化这个过程。 - ...
JavaSE034Arrays类解析及数组疑难剖析.docx
09-30
在本文档"JavaSE034Arrays类解析及数组疑难剖析"中，主要讨论了以下几个核心知识点： 1. **二维数组与引用类型** 在Java中，数组是一个对象，它可以存储基本类型（如int, double等）或者引用类型的数据。当二维...
JavaSE第7篇：封装
qq_29445811的博客
12-17 1768
3.setter和getter方法加入属性控制语句,用于对属性的合法值进行判断。2.创建setter和getter方法用于属性的读写。修饰类只能用缺省default和public。2.隐藏类的实例细节,方便修改和实现。1.只能通过规定的方法来访问数据。1.属性私有化private。③ 构造器中赋值或初始化。封装性需要权限修饰符。
JavaSE第6篇：面向对象
qq_29445811的博客
12-22 624
面向对象简介
JavaSE第4篇：流程控制
qq_29445811的博客
04-10 421
文章目录一、流程控制是什么二、顺序结构三、分支结构1、if else2、switch case四、循环结构1、while2、do while3、for总结 一、流程控制是什么 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块 二、顺序结构 顺序结构：程序从上到下逐行的执行、中间没有任何判断和跳转 三、分支结构 分支结构:根据条件选择性的执行某段代码 1、if else if三种格式： if(条件表达式){ 执行代码块 } if(条件表达式){ 执行代码块1 }el
JavaSE第1篇： Java简介
qq_29445811的博客
03-09 266
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、Java核心概念二、基础核心 一、Java核心概念 JVM(Java virtval Machine): 虚拟机 JDK(Java Development Kit 开发工具包): JRE+Java开发工具 JRE(Java runtime Environment 运行时环境): JVM+类库 1995年java诞生,2009年oracle收购了sun公司. 使用JDK开发Java程序,交给.
JavaSE第2篇：数据类型
qq_29445811的博客
03-10 244
一、基本数据类型 数值型:整数型:(byte,short,int,long)浮点型:(float,double) 字符型:char 布尔型 boolean 二、引用数据类型 数组 类 接口 总结 Java语言是一种强类型语言(java存储数据都是有类型的)
Java SE面向对象编程：数组详解与实例
"JavaSE程序设计课程讲义：第02章面向对象编程 - 1.pdf" 在本章的JavaSE程序设计课件中，我们深入探讨了数组（Arrays）这一重要的数据结构。数组是计算机科学中一个基础且广泛使用的概念，它代表了一个相同类型数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值