java-数组

最新推荐文章于 2024-01-31 22:59:00 发布
最新推荐文章于 2024-01-31 22:59:00 发布
阅读量251 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37413300/article/details/109802224
版权
今日内容

  • 数组

  • 方法

    学习目标
    • 理解容器的概念
    • 掌握数组的第一种定义方式、第二种定义方式、第三种定义方式
    • 会使用数组的索引访问数组的元素
    • 了解数组的内存图分析
    • 了解空指针和越界异常
    • 掌握数组的遍历
    • 掌握数组最大值的获取
    • 了解数组反转的原理
    • 了解数组作为方法参数传递
    • 了解数组作为方法的返回值

数组定义和访问

容器的概念

​ 容器：将多个数据存储到一起，每个数据成为该容器的元素。

​ 生活中的容器：水杯、excel、教室。

数组概念

​ 数组概念：存储数据长度固定的容器，保证每一个数据的数据类型要一致。

数组的定义
方式一（动态初始化）

​ 格式：

数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[长度(正整数)];

​ 解析：

​ 数组存储的数据类型：决定该数组容器能够存储什么样的数据类型

​ []：表示数组

​ 数组名称：给定义数组起一个变量的名字，满足标识符的命名规则

​ new：关键字，创建数组使用的关键字。

​ 数组存储的数据类型：决定该数组容器能够存储什么样的数据类型

​ [长度]：数组的长度，表示数组中能够存储多少个元素

备注：数组一旦创建，长度不能发生改变。数组具备一个【定长特性】。

public class ArrayDemo01{
    public static void main(String[] args){
        //常见数组容器
        //格式：
        //数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[长度(正整数)];
        //成绩 可以用整数类型
        int[] scores = new int[41];//相当于在内存中存储了41个0   
        int[] scores;//定义声明
        scores = new int[41];//初始化
        //名字 可以用字符串类型
        String[] names = new String[41];
        //性别 可以使用布尔类型 Boolean
        boolean[] sexs = new boolean[41];
        //身高 可以使用浮点类型 double
        double[] heights = new double[41];
        //体重、年龄、地址、出生日期
        double[] weights = new double[41];
        int[] years = new int[41];
        String[] addr = new String[41];
        String[] bir = new String[41];
     
    }
}
方式二（静态初始化）

​ 格式：

数组的数据类型[] 数组名称 = new 数组存储的数据类型[]{元素1,元素2,元素3,。。。};

​

public class ArrayDemo02{
    public static void main(String[] args){
        //定义数组的第二种方式
        //格式：
        //数组的数据类型[] 数组名称 = new 数组存储的数据类型[]{元素1,元素2,元素3,。。。};
        int[] ages = new int[]{18,19,20,21,22};
        String[] bir = new String[]{"1990-7-1","1995-5-4","1998-7-1","1999-1-4","1992-2-2","1999-5-1"};
        //存储41个人的手机号,中午吃的饭，住宿房间号
        String[] tel = new String[]{"14256753633","15494876621","18796543215"};
        String[] food = new String[]{"鱼香肉丝","泡面","盖饭","米饭","外卖"};
        String[] roomnumber = new String[]{"110","120","111","211","210"};
    }
}
方式三（静态初始化）

​ 格式：

数组的数据类型[] 数组名称 = {元素1,元素2,元素3,。。。};

public class ArrayDemo03{
    public static void main{
        //使用数组定义的第三种格式
        //存储班上人的姓名，年龄，性别（char）
        String[] names = {"张三","王五","里斯","李四","金九"};
        int[] ages = {12,14,17,20,22};
        Char[] sexs = {'男','女'};
    }
}
数组的特点：
  • ​ 数组的长度在程序运行期间不可改变。在编译期间可以改变（语法允许）。
  • ​ 数组本身就是一种引用数据类型。里面存的元素可以是引用，基本类型。
  • ​ 数组定义时是引用数据类型，但是数组容器里面存储的元素可以是基本数据类型也可以是引用数据类型。
  • ​ 数组当中存储的多个数据，类型保持一致。
数组的初始化：在内存当中创建了一个数组，并且向数组容器中赋默认值

默认值：

​ int整数–>0

​ float浮点数–>0.0

​ char字符–>’\u0000’(显现是一个空格)

​ boolean布尔–>false

​ 引用类型–>null

两种常见的初始化动作：

  • ​ 静态初始化（指定内容）：在创建数组的时候，不指定数组的长度（存储元素的个数），而是直接制定具体的【内容】
  • ​ 动态初始化（指定长度）：在创建数组的时候，直接指定数组的长度（存储元素的个数）

备注：静态初始化虽然没有直接指定长度，但是程序会推算得到该数组的长度。

建议：

​ 如果不确定数组当中存储的内容时，用动态初始化；反之内容已经确定，使用静态初始化。

​ 大多数情况建议使用动态初始化。

数组的访问

索引：角标、下标

​ 每一个存储到数组当中的元素，都会自动的分配一个编号，从【0】开始，这个系统自动分配的编号成为数组的索引（index）。可以通过索引访问数组当中的元素。

​ 格式：

数组名称[索引]
数组的长度属性

​ 每一个数组都有长度，而且是固定的，Java会自动赋给数组一个属性，可以获取到数组的长度属性。格式：

	数组名称.length

​ 属性length代表的就是数组的长度，int类型。数组的最大索引值为【数组名.length-1】。

/*

*/
public class ArrayUseDemo04{
    public static void main(String args){
        //通过数组的索引访问数组中的元素
        int[] arr = {10,20,30,40,50}
        //访问数组中的第一个元素
        //格式：数组名称[索引]
        //arr[0]
        System.out.println(arr[0]);//10
        //arr[arr.length-1] 通过数组的最大索引值访问数组的最大索引值/最后一个元素
        System.out.println(arr[arr.length-1]);//50
        //获取数组的第三个元素 arr[2]
        System.out.println(arr[2]);//30
        //获取数组的第二个元素 arr[1]
        System.out.println(arr[1]);//20
        //获取数组的第四个元素 arr[3]
        System.out.println(arr[3]);//40
        
        int[] arr02;//定义一个int类型的数组...那相当于变量没有进行初始化，没有赋值不可以使用。是个null
        arr02[1] = 20;
    }
}
索引访问数组当中的元素操作
  • ​ 修改索引对应位置上的值：数组名[索引] = 数值
  • ​ 变量 = 数组名称[索引]，从数组当中取出一个数值赋值给一个变量。
public class ArrayUseDemo05{
    public static void main(String[] args){
        //动态初始化一个int数组
        int[] arr = new int[10];
        //访问到数组当中的第五个元素，把第五个元素赋值为10
        //格式：数组名[索引] = 数值
        arr[4] = 10;
        //访问到数组当中最后一个元素，并赋值为100
        arr[arr.length-1] = 100;
        //访问数组当中的第七个元素，并赋值为50；第三个赋值为25，第八个赋值为-30
        arr[6] = 50;
        arr[2] = 25;
        arr[7] = -30;
        
        //把刚刚修改的数组元素分行展示在控制台中
        System.out.println(arr[4]);
        System.out.println(arr[arr.length-1]);
        System.out.println(arr[6]);
        System.out.println(arr[2]);
        System.out.println(arr[7]);
        //循环输出数组内的所有值
        for(i=0;i<arr.length;i++){
            System.out.println("数组中第" + i +"的值为" + arr[i]);
        }
        
        //定义一个int类型的变量
        int num;
        //把数组中第五个元素复制给num;
        num = arr[4];
        System.out.println("num的值为" + arr[4]);
        //此时如果直接打印数组名称，得到？数组对应的：内存地址哈希值。
        System.out.println(arr);//[I@15db9742]
        
    }
}


/*
整数表示：
		十进制：0 1 2 3 4 5 6 7 8 9
		二进制：0 1
		十六进制：0 1 2 3 4 5 6 7 8 9 a b c d e f
*/

· 数组原理内存图解

内存：

​ 内存是计算机中一个很重要的原件，是临时的存储区域。（永久的存储区域是硬盘），作用是当程序运行过程中，我们编写的代码文件存储在硬盘中，硬盘当中的程序文件不会运行，需要把硬盘里的程序文件存放到内存当中，当程序运行完毕后程序会清空内存。

Java虚拟机当中的内存划分

​ 为了提高运行效率，就对内存空间进行不同区域的划分，每一片区域都有特定的处理数据方式和内存管理方式。

JVM内存划分

区域名称作用
寄存器给cpu使用，和我们开发没有关系
本地方法栈JVM使用操作系统功能时用到，和我们开发无关
方法区存储可以运行的.class文件（【常量池】，【静态域】）（类，变量，基本数据类型，）
方法栈 (stack)方法运行时使用的内存，比如main方法运行，进入方法栈中才能运行
堆内存 (heap)存储对象或者数组，new出来的对象，都统统存储在堆内存当中
数组在内存当中的存储

​ 一个数组的内存存储

public static void main(String[] args){
    int[] arr = new int[3];
    System.out.println(arr);//内存地址哈希值
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NQLgvIbS-1605751169323)(C:\Users\Administrator\Pictures\ArrayUseDemo.PNG)]

​ 程序执行流程：

  1. ​ main方法进入方法栈中执行
  2. ​ 创建数组。JVM会在堆内存中开辟空间，存储数组
  3. ​ 数组在内存当中会有自己的内存地址，以16进制表示
  4. ​ 数组当中有三个元素，默认值为0
  5. ​ JVM将数组的内存地址赋值给引用类型变量arr
  6. ​ 变量arr保存的数组是在内存当中的地址，而不是一个具体的数值，因此称为引用类型

​ 两个数组的内存分析图解

public static void main(String[] args){
    int[] arr = new int[3];
    int[] arr2 = new int[2];
    System.out.println(arr);//内存地址哈希值
    System.out.println(arr2);//内存地址哈希值
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-omt1gb1X-1605751169326)(C:\Users\Administrator\Pictures\ArrayTwo.PNG)]

​ 两个变量指向同一个数组

public static void main(String[] args){
    //定义一个数组，动态初始化
	int[] arr = new int[3];// 0 0 0 
    //通过索引访问数组中的元素
    arr[0] = 10;
    arr[1] = 20;
    arr[3] = 30;
    //查看数组中的第二个元素
    System.out.println(arr[1]);//20
    //定义一个数组，i将上一个数组赋值该数组
    int[] arr2 = arr;
    arr2[1] = 50;
    //查看arr数组当中第二个元素
    System.out.println(arr[1]);//50
}

原理图解分析：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TN0T7TgZ-1605751169327)(C:\Users\Administrator\Pictures\ArayTwoUse.PNG)]

数组的常见操作：
数组的越界异常操作：(可通过编译。语法没问题)
public static void main(String[] args){
    //动态初始化一个数组
    int[] arr = new int[5];
    //访问索引值为5的数组元素   ArrayIndexOutOfBoundsException
    System.out.println(arr[5]);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QvWJWCl2-1605751169329)(C:\Users\Administrator\Pictures\ArrayIndexOutOfBoundsException.PNG)]

​ 数组索引是从0开始，最大索引值是arr.length-1 [0,arr.length-1]

​ 如果访问数组元素时，索引值不在该区间中，程序就会抛出数组索引越界异常。

​ 在开发中不要出现索引越界异常现象，因为它会导致程序异常中止。

数组空指针异常操作（可通过编译。语法没问题）
public static void main(String[] args){
    //动态初始化一个数组
    int[] arr = new int[3];
    arr = null;
    //查看arr数组的第三个元素  ArrayNullPointer
    System.out.println(arr[2]);
}

数组空指针异常，就是在程序运行过程中，有一个在内存当中有1个不存在的变量/值被引用到。

数组遍历【重点】

​ 数组遍历：将数组中的每一个元素分别获取出来，就是遍历。便利是我们操作数组的核心重点。

public static void main(String[] args){
    //静态初始化一个数组
    int[] arr = {1,2,3,4};
    //数组遍历
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    System.out.println(arr[3]);
    //for循环（while）  已知循环次数  i是索引
    for(int i=0;i <= arr.length-1 ; i++){//遍历容器的时候，初始化语句中的循环变量一般是索引值
        System.out.println(arr[i]);
    }
    
    
    //静态初始化一个数组，string类型
    //存储名字 小明 小花 小刘S
    //遍历该数组，访问该数组当中的每一个元素展示在控制台
    String[] arr2 = {"小花","小程","小明","小刘"};
    for(int i=0;i <= arr2.length-1 ; i++){
    System.out.println(arr2[i]);
    }
}

数组的索引从0开始，依次递增，递增到arr.length-1为止，引入循环结构

获取元素当中的最大值元素

​ 最大值：从数组的所有元素中找出最大值

​ 思路：

  1. ​ 定义一个最大值变量，保存数组当中的第一个元素（素组当中索引值为0的元素）
  2. ​ 遍历数组，获取数组当中的每一个元素
  3. ​ 将遍历到的元素和保存的最大值变量进行比较
  4. ​ 如果数组元素的值大于最大值变量，就把元素赋值给最大值变量
  5. ​ 数组循环结束，最导致变量保存的就是数组中最大值u元素
public static void main(String[] args){
    //静态初始化一个数组容器
	int[] arr = {3000,200,1000,10000,5000};
    //定义一个最大值变量，保存数组当中的第一个元素
    int max = arr[0];
    for(int i = 1; i <= arr.length-1; i++){
        //将遍历到的元素和保存的最大值变量进行比较
        if(arr[i] >max){
            //如果数组元素的值大于最大值变量，就把元素赋值给最大值变量
            max = arr[i];
        }
    }
    //数组循环结束，最导致变量保存的就是数组中最大值u元素
    System.out.println("数组的最大值是：" + max);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vEiPsEH3-1605751169332)(C:\Users\Administrator\Pictures\ArrCompare.PNG)]

作业

  1. 一维数组累加求和{12,34,12,20,40,60,80,-90,-40,-100,15};

  2. 数组元素倒叙{12,34,12,20,40,60,80,-90,-40,-100,15};

  3. 数组元素排序（从大到小）{12,34,12,20,40,60,80,-90,-40,-100,15};

  4. 定义三个int类型的变量并赋值，使用三元运算符或者if-else获取三个中最大值

  5. 从控制台输出下：

    ********
*******
******
*****
****
***
**
*

  6. 打印一个字符串数组{“张三”,“李四”,“王五”,“赵六”,“田七”,“周八”,“孙九”}输出到控制台[“张三”,“李四”,“王五”,“赵六”,“田七”,“周八”,“孙九”]

public class Text1112{
public static void main(String[] args){
    int[] arr = {12,34,12,20,40,60,80,-90,-40,-100,15};
    int sum = 0;
    for(int i = 0; i <arr.length; i++){
        sum += arr[i];
    }
    System.out.println(sum);//1
	System.out.println();
    
    int num = arr.length/2;
    for(int i = 0; i < num; i++){
        int change;
        change = arr[i];
        arr[i] = arr[arr.length-i-1];
        arr[arr.length-i-1] = change;
    }
    for(int i = 0; i <arr.length; i++){
        System.out.println(  arr[i]);//2
    }
    
    int min = arr[0];
    for(int i = 1; i <arr.length; i++){
        for(int j = 1; j < i; j++){
            if(min > arr[j]){
				min= arr[j]; 
        	}
        }  
    }
    System.out.println();
    for(int i = 0; i <arr.length; i++){
    System.out.println(arr[i]);//2
    }
	
    int max = arr[0];
    for(int i = 1; i <arr.length; i++){
        for(int j = i; j < arr.length; j++){
            if(max > arr[j]){
				max= arr[j]; 
        	}
        }  
    }
    System.out.println();
    for(int i = 0; i <arr.length; i++){
    System.out.println(arr[i]);//2
    }
	
	System.out.println();
	 for (int i = 0; i < arr.length; i++) {
            for (int j = i ; j < arr.length; j++) {
                
                if (arr[i] <arr[j]) {
                    
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);//3
        }
		
		System.out.println();
	 	for (int i = 0; i < arr.length; i++) {
            for (int j = arr.length ; j >0; j--) {
                
                if (arr[i] <arr[j]) {
                    
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);//3
        }
}}

public class Text02{
public static void main(String[] args){
    int a = 5;
    int b = 6;
    int c = 2;
    System.out.println(((a>b?a:b)>c)?(a>b?a:b):c);
    System.out.println();
    int temp;
    
    if(a > b){
        temp = a;
    }else temp = b;
    if(temp < c){
        temp = c;
    }
    System.out.println(temp);//4
}
}

public class Text03{
public static void main(String[] args){
    for(int i = 8; i > 0; i--){
        for(int j = i; j > 0; j--){
            System.out.print("*");
        }
        System.out.println();//5
    }
}}

public static void main(String[] args){
    String[] arr = {"张三","李四","王五","赵六","田七","周八","孙九"};
    System.out.println("[");
    for(i = 0; i < arr.length; i++){
        System.out.println( "_" + arr[i] + "_" + ",");
    }
    System.out.println("]");
}
qq_37413300
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数组的知识点总结
weixin_44536951的博客
11-15 1106
数组的定义和访问 容器的概念 容器:就是将多个数据存储到一起,每个数据称为该容器的元素 生活中的容器:水杯,Excel,教室. 数组的概念 数组概念:数组就是存储数据长度固定的容器,保证每个数据类型要一致. 数组的定义 方式一: 格式: 数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[长度(正整数)]; 解析: ​ 数组存储的数据类型：决定了该数组容器能够存储什么样的数据 ​ [] : 表示数组 ​
数组的相关知识
weixin_927326的博客
02-09 1628
数组的概念、定义格式、动态初始化、静态初始化、数组的遍历、获取数组最值、数组逆序、查找数组元素、二维数组的语句定义格式、二维数组的遍历等相关知识及例题
数组知识点（详解）
最新发布
2301_80543957的博客
01-31 1101
类型符 数组名[常量表达式];int a[10] 其中10代表数组的大小；a[2+1],a[2*3],a[5/2]这些也都是符合的.类型名 数组名[常量表达式（行）][常量表达式（列）]int a[3][4],a[2-1][2*2-1],b[1][3]=a[2][3]/3这些都是可以的在C语言中，是将字符串作为字符数组来处理的对字符：char c[10]={'a','b','c','d'}
数组知识总结
qq_63431486的博客
12-11 755
数组知识总结
数组基础知识
xjl13007043300的博客
11-17 580
学习资料来源： 【算法通关手册】：https://algo.itcharge.cn/ 【datawhale组队学习】https://github.com/datawhalechina/team-learning 大多是对这次组队学习的学习资料的学习笔记，非原创~ 1. 数组简介 1.1 数组定义 数组（Array）：一种线性表数据结构。它使用一组连续的内存空间，来存储一组具有相同类型的数据。是相同类型的数据元素构成的有序集合。 下面看一个整数数组的存储方式： 数组的每一个数据元素都占有一定的存储单元
Educoder题目：Java入门 - 数组进阶答案解析.md
11-01
Educoder题目：Java入门 - 数组进阶答案解析
Java - 数组面试题 - 个人整理
08-20
数组 - 需要参加面试的人
Java-数组实验.pdf
10-03
【Java 数组基础与文件操作】\n\nJava 数组是一种数据结构，它允许程序员存储固定数量的相同类型的数据。数组在 Java 中是基础且重要的概念，它提供了一种高效的方式来组织和处理数据。本实验旨在帮助你深入理解数组...
JAVA-数组进制转换
10-08
.java文件，对java基础的数组部分的进制类型转换部分的说明。
数组知识点(笔记学习)
weixin_44784393的博客
03-03 533
数组概念 注意: 引用数据类型的一种,要求存储同一种类型多个数据. 数组的长度是固定的,创建完数组,数组长度不能改变 定义数组 动态初始化
有关数组的知识点总结
qq_43240347的博客
12-22 258
知识点总结： 1、数组分一位数组，二维数组以及多位数组。 定义方式；数组类型  变量名［］中括号中尾为数租的大小。形如int a［110］、int b［110］［110］；其实质和变量的定义基本类似。                    注意：［］中在定义一个数组时，其里面必须是一个具体的数，不可以是变量，即使这个变量被初始化了也不可以，另外，为防止出现数组越界的            ...
数组知识点1
01程序媛
02-02 75
关于数组 1.数组是有序数据的集合 复杂数据类型有object array function... 2.空数组 var arr=[] 3.非空数组 var arr=[1,2,3,true] 4.创建数组的方式： （1）字面量创建方式：var arr=[1,2,3] （2）构造函数创建：var arr=new Array() ()里面一个值是长度，两个值是内容 5.查看数组的长度用到lengt...
数组常见知识点
qq_22152499的博客
04-07 227
数组 前言 数组如何实现随机访问? 答:数组是一种线性表数据结构。他用一组连续的内存空间，来存储一组具有相同类型的数据。其中最关键的点在于连续的内存空间和相同类型的数据。正是因为这两个关键点才拥有了随机访问的特性。 线性表和非线性表是什么? 答:线性表就是将数据排成像线一样的结构。每个线性表中最多只有向前和向后两个方向。链表、队列和栈都是线性表结构。 非线性表中的数据不是简单的前后关系，二叉树、堆...
C语言程序错题
banboos的博客
12-29 2275
1.当定义一个结构体变量时系统分配给它的内存是：______量的总和 B: 成员中占内存量最大者所需的容量的倍数 C: 结构中第一个成员所需内存量 D: 结构中最后一个成员所需内存量 标准答案：B 你的答案：A 2.结构体和共用体成员的应用都可能引用最低一级的成员。 正确答案：Y 你的答案：N 3.构体变量作参数时是地址传递。 标准答案：N 您的答案：Y 4.构体数组不可以在定义...
入门学习计算机第十一天—数组
xiaotangyu7dong的博客
04-11 187
入门学习计算机第十一天—数组 编译器：Microsoft Visual Studio 2010 前言 记录第十一天学习C语言的博客。 一、一维数组的创建和初始化 数组的创建 数组是一组相同类型元素的集合。数组的创建方式： type_t arr_name [const_n]; //type_t 是指数组的元素类型 //const_n 是一个常量表达式，用来指定数组大小 实例： int arr1[10]; int count = 10; int arr2[count];//是错误的 注：数组创建时，
计算机基础（12）数组
qq_53440340的博客
07-23 433
​​​​​​​1.1：一维数组 概念： 同一种类型数据的集合 一个长度固定的持有数据容器 是一种数据类型 数组内每一个数据叫做一个元素 值为数组的变量叫做引用 数组的出现意义： 将数据分组，进行分类后整体处理 将每一个元素从0编号(索引/角标等)，方便操作数据数 数组的使用： 数组名[索引]访问指定索引元素 格式： 格式一： 元素类型[] 数组名 = new 元素类型[元素个数(即数组的长度)]; 示例：int[] arr = new int[5]; 格式二： 元素类型[] 数组
数组知识点汇总
weixin_42072280的博客
10-30 1165
目录 一、一维数组 1、​​​​​​​数组的概念 2、数组的使用方法 2.1 数组的定义 2.2 数组元素的引用 3、数组元素赋初值 ​​​​​​​4、使用数组处理数据的特点 5、一维数组例题 二、二维数组 ​​​​​​​1、二维数组 2、二维数组的内存映像图 ​​​​​​​3、二维数组赋初值 ...
初学者必备的数组相关知识点
小白学视觉
09-18 127
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达作者：进击的合成尸导读作者是一名在读的大二学生，在我看来，是一个非常励志的小伙子，虽然他总觉得自己并不是读的名校，有点...
数组知识要点
在职Java工程师
02-19 450
1、数组 数组有四种格式： int array1 = { 1,2,3,4 } ; int array2 = new int [ 10 ] ; ...
头歌java入门 - 数组进阶
11-16
Java中的数组是一种可以存储多个相同类型的元素的数据结构。在Java中，数组的长度是固定的，一旦数组被创建，其长度就不能再改变。 在数组进阶的学习中，我们将学习如何使用数组进行更复杂的操作。 首先，我们可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值