数组(一维数组和二维数组的初始化及遍历)

最新推荐文章于 2024-10-11 20:35:18 发布
最新推荐文章于 2024-10-11 20:35:18 发布
阅读量629 收藏 2
点赞数 4
分类专栏： 服务端-JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/listeningdu/article/details/127942566
版权

一维数组

数组声明

数组的作用：用来存储相同类型的数据
                //以int类型数据为案例：数组用来存储int类型数据
                1.声明(定义数组)
                int[] arr; //定义一个int类型的数组，名字叫arr
                int arr2[];
                如果数组只声明，没有后续操作，那么这个数组相当于没定义
                int[] arr3 = null;//空 辨别：数组赋值为null和什么都没有赋值  不一样的效果 
                
                2.创建
                arr = new int[4];//给数组开辟了一个长度为4的空间
                编译期声明和创建会被合为一句话: int[] arr = new int[4];
                

数组初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

1.静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

eg:
int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};
注意：
1.new int[3]{12,23,45};-->错误
2.int[] arr ;
   arr = {12,23,45};  --->错误

2.动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。

eg:
int[] arr ;
arr = new int[3]
arr[0] = 12;
arr[1] = 23;
arr[2] = 45;
3.默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int[] arr = new int[3];   ---> 数组有默认的初始化值

数组遍历

方式1：普通for循环---》正向遍历

方式2：增强for循环

方式3：利用普通for循环： 逆向遍历

代码如下:

  //将数组中的每个元素进行查看--》数组的遍历：
                //方式1：普通for循环---》正向遍历：
                for(int i=0;i<=9;i++){
                        System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
                }
                
                //方式2：增强for循环:
                //对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
                int count = 0;
                for(int num:scores){
                        count++;
                        //每次都将num在控制台输出
                        System.out.println("第"+count+"个学生的成绩为："+num);
                }
                
                /*
                增强for循环：
                优点：代码简单
                缺点：单纯的增强for循环不能涉及跟索引相关的操作
                */
                
                //方式3：利用普通for循环： 逆向遍历：
                for(int i=9;i>=0;i--){
                        System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
                }
                
        }
}

数组复制

当数组进行复制时,会将数组元素复制到新数组之中

 

 原理:

 代码如下:

import java.util.Arrays;
public class TestArray14{
        public static void main(String[] args){
                //给一个源数组：
                int[] srcArr = {11,22,33,44,55,66,77,88};
                //给一个目标数组：
                int[] destArr = new int[10];
                
                //复制：
                System.arraycopy(srcArr,1,destArr,3,3);
                //遍历查看目标数组：
                System.out.println(Arrays.toString(destArr));
        }
        
}

运行结果:

数组最值问题

 eg:求数组中的最大值

  public static int getMaxNum(int[] arr){
                //先找一个数上擂台，假定认为这个数最大：
                int maxNum = arr[0];
                for(int i=0;i<arr.length;i++){
                        if(arr[i]>maxNum){
                                maxNum = arr[i];
                        }
                }
                return maxNum;
                
        }

数组中参数传递:

方法的实参传递给形参的时候一定要注意：一切都是值传递：
如果是基本数据类型，那么传递的就是字面值
如果是引用数据类型，那么传递的就是地址值

数组查询问题

public class TestArray06{
    public static void main(String[] args){
                //查询指定元素的位置--》找出元素对应的索引 
                //给定一个数组：
                int[] arr = {12,34,56,7,3,56};
                //           0  1  2  3 4  5
                
                //功能：查询元素888对应的索引：
                //调用方法：
                int index = getIndex(arr,999);
                //后续对index的值进行判断：
                if(index!=-1){
                        System.out.println("元素对应的索引："+index);
                }else{//index==-1
                        System.out.println("查无次数！");
                }
        }
        
        /*
        定义一个方法：查询数组中指定的元素对应的索引：
        不确定因素：哪个数组，哪个指定元素  （形参）
        返回值：索引
        
        */
        public static int getIndex(int[] arr,int ele){
                int index = -1; //这个初始值只要不是数组的索引即可
                for(int i=0;i<arr.length;i++){
                        if(arr[i]==ele){
                                index = i;//只要找到了元素，那么index就变成为i
                                break;//只要找到这个元素，循环就停止
                        }
                }
                return index;
        }
}

在指定位置增加元素

import java.util.Scanner;
public class TestArray07{
    public static void main(String[] args){
                //功能：给定一个数组,在数组下标为2的位置上添加一个元素91
                
                //1.给定一个数组：
                int[] arr = {12,34,56,7,3,10,55,66,77,88,999,89};
                //           0  1   2 3 4 5
                //2.输出增加元素前的数组：
                /*
                System.out.print("增加元素前的数组：");
                for(int i=0;i<arr.length;i++){
                        if(i!=arr.length-1){
                                System.out.print(arr[i]+",");
                        }else{//i==arr.length-1 最后一个元素不用加,
                                System.out.print(arr[i]);
                        }
                }
                */
                
                //从键盘接收数据：
                Scanner sc = new Scanner(System.in);
                System.out.println("请录入你要添加元素的指定下标：");
                int index = sc.nextInt();
                System.out.println("请录入你要添加的元素：");
                int ele = sc.nextInt();
                
                //3.增加元素
                //调用方法：
                insertEle(arr,index,ele);
                
                
                
                //4.输出增加元素后的数组：
                System.out.print("\n增加元素后的数组：");
                for(int i=0;i<arr.length;i++){
                        if(i!=arr.length-1){
                                System.out.print(arr[i]+",");
                        }else{//i==arr.length-1 最后一个元素不用加,
                                System.out.print(arr[i]);
                        }
                }
                
        }	
        
        /*
        提取一个添加元素的方法：
        在数组的指定位置上添加一个指定的元素。
        在哪个数组的哪个位置添加哪个元素！
        不确定因素：形参：哪个数组，哪个位置，哪个元素
        返回值：无
        
        */
        public static void insertEle(int[] arr,int index,int ele){
                for(int i=arr.length-1;i>=(index+1);i--){
                        arr[i] = arr[i-1];
                }
                arr[index] = ele;
        }
}

在指定位置删除元素

import java.util.Arrays;
public class TestArray09{
    public static void main(String[] args){
                //功能：给定一个数组,删除元素3：
                
                //1.给定一个数组：
                int[] arr = {12,34,56,7,3,10,34,45,56,7,666};
                 
                //2.输出删除前的数组：
                System.out.println("删除元素前的数组："+Arrays.toString(arr));
                
                
                //找到要删除的元素对应的索引即可：
                int index = -1 ;
                for(int i=0;i<arr.length;i++){
                        if(arr[i]==1200){
                                index = i;
                                break;
                        }
                }
                
                //3.删除
                
                if(index!=-1){
                        for(int i=index;i<=arr.length-2;i++){
                                arr[i] = arr[i+1];
                        }
                        arr[arr.length-1] = 0;
                }else{//index==-1
                        System.out.println("根本没有你要删除的元素！");
                }
                
                
                //4.输出删除后的数组：
                System.out.println("删除元素后的数组："+Arrays.toString(arr));
        }
}

Arrays工具类

为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。

import java.util.Arrays;
public class TestArray13{
        public static void main(String[] args){
                //给定一个数组：
                int[] arr = {1,3,7,2,4,8};
                //toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
                System.out.println(Arrays.toString(arr));
                
                //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
                //这个方法的使用前提：一定要查看的是一个有序的数组：
                //sort：排序 -->升序
                Arrays.sort(arr);
                System.out.println(Arrays.toString(arr));
                System.out.println(Arrays.binarySearch(arr,4));
                
                int[] arr2 = {1,3,7,2,4,8};
                //copyOf:完成数组的复制：
                int[] newArr = Arrays.copyOf(arr2,4);
                System.out.println(Arrays.toString(newArr));
                
                //copyOfRange:区间复制：
                int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
                System.out.println(Arrays.toString(newArr2));
                
                //equals:比较两个数组的值是否一样：
                int[] arr3 = {1,3,7,2,4,8};
                int[] arr4 = {1,3,7,2,4,8};
                System.out.println(Arrays.equals(arr3,arr4));//true
                System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false
                
                //fill：数组的填充：
                int[] arr5 = {1,3,7,2,4,8};
                Arrays.fill(arr5,10);
                System.out.println(Arrays.toString(arr5));
        }
}

二维数组

基本定义

public class TestArray15{
        public static void main(String[] args){
                //定义一个二维数组：
                int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
                
                int[] a1 = {1,2,3};
                arr[0] = a1;
                
                arr[1] = new int[]{4,5,6,7};
                
                arr[2] = new int[]{9,10};
        }
}

数组初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

eg:
int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:
int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组
arr[0] = new int[]{1,2};
arr[1] = new int[]{3,4,5,6};
arr[2] = new int[]{34,45,56};

eg:
int[][] arr = new int[3][2]; 
public class TestArray16{
        public static void main(String[] args){
                int[][] arr = new int[3][2];
                //本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组：

                arr[1] = new int[]{1,2,3,4};

                //数组遍历：
                for(int[] a:arr){
                        for(int num:a){
                                        System.out.print(num+"\t");
                        }
                        System.out.println();
                }

        }
}

静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组遍历

四种遍历方式

public class TestArray15{
        public static void main(String[] args){
                //定义一个二维数组：
                int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
                
                int[] a1 = {1,2,3};
                arr[0] = a1;
                
                arr[1] = new int[]{4,5,6,7};
                
                arr[2] = new int[]{9,10};
                
                //读取6这个元素：
                //System.out.println(arr[1][2]);
                
                //对二维数组遍历：
                //方式1：外层普通for循环+内层普通for循环：
                for(int i=0;i<arr.length;i++){
                        for(int j=0;j<arr[i].length;j++){
                                System.out.print(arr[i][j]+"\t");
                        }
                        System.out.println();
                }
                
                //方式2：外层普通for循环+内层增强for循环：
                for(int i=0;i<arr.length;i++){
                        for(int num:arr[i]){
                                System.out.print(num+"\t");
                        }
                        System.out.println();
                }
                
                //方式3：外层增强for循环+内层增强for循环：
                for(int[] a:arr){
                        for(int num:a){
                                System.out.print(num+"\t");
                        }
                        System.out.println();
                }
                
                //方式4：外层增强for循环+内层普通for循环：
                for(int[] a:arr){
                        for(int i=0;i<a.length;i++){
                                System.out.print(a[i]+"\t");
                        }
                        System.out.println();
                }
        }
}


 

虫儿飞..
关注
专栏目录
C语言基础--04.数组
Perservere的博客
09-06 337
目录 1.一维数组的创建和初始化 1.1 数组的创建 1.2 数组的初始化 1.3 一维数组的使用 1.4 一维数组在内存中的存储 2.二维数组的创建和初始化 2.1 二维数组的创建 2.2 二维数组的初始化 2.3 二维数组的使用 2.4 二维数组在内存中的存储 3.数组越界 4.数组作为函数参数 4.1 冒泡排序函数的错误设计 4.2 数组名是什么？ 4.3 冒泡排序函数的正确设计 1.一维数组的创建和初始化 1.1 数组的创建 数组是一组相同类型元素的集合。
一维数组、二位数组、多维数组、数组的数组的简洁初始化方式，以及数组的常用属性...
balian1021的博客
03-21 287
1、初始化方式： int[] i1={1,2,3,4};一维数组 int[,] i2={{1,2,3,4,5,6},{1,2,3}};二维数组...多维数组以此类推 int[] [] i3={new[]{1,2,3},new[]{1,2,3,4,5}};数组的数组 2、常用属性 a、获取某一位的值,例如我想获得i1的第三位的数字2： Console.WriteLine(...
Java中的二维数组
最新发布
weixin_73230994的博客
10-11 307
类型 数组名[][] = {{值1,值2...},{值1,值2...},{值1,值2...},{值1,值2...}}
一维/二维数组的几种初始化方法
zpf1813763637的博客
08-03 5924
一维数组的初始化方法 方式一：静态初始化 数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成，不能分开两个语句写 举例： 定义存储1，2，3，4，5整数的数组容器 int[] arr = {1,2,3,4,5};//正确 int[] arr; arr = {1,2,3,4,5};//错误 方式二：静态初始化 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...}; 或 数据类型[] 数组名; 数组名 = new 数据.
二维数组的初始化与遍历
你今天真好看呀
12-23 949
1.一维数组的初始化： 静态初始化： int[] a = {1,2,3,4}; 动态初始化： String books = new String[3]; books[0] = "活着"; books[1] = "追风筝的人"; books[2] = "茶花女"; 2. 二维数组的初始化： 二维数组实际上就是一个一维数组，他的每个元素都是一个一维数组。 可以画一张表格，一维数组的话，表格只有一行，二...
java一维数组和二维数组初始化方式
sunming0129的博客
03-22 3079
java一维数组的初始化方式和二维数组的初始化方式都包括动态初始化和静态初始化，四种（两种动态初始化方式和两种静态初始化方式）。    一维数组初始化：                   动态初始化：数据类型[] 变量名 = new  数据类型[数组长度];                                      1.  int[] arr = new int[3];     ...
Java中一维二维数组的静态和动态初始化
08-29
Java中一维二维数组的静态和动态初始化 Java中的数组是一种基本的数据结构，它可以存储多个相同类型的数据，包括一维数组和二维数组。今天，我们将讨论Java中一维数组和二维数组的静态和动态初始化。 一维数组的...
js二维数组定义和初始化的三种方法总结
10-26
接下来，我们将详细了解和总结三种在JavaScript中定义和初始化二维数组的方法。 首先，方法一是一种直接定义并初始化二维数组的方式。这种方式适用于二维数组的维度事先已知，并且维度较小的情况。例如，如果需要一...
Swift中定义二维数组的方法及遍历方法示例
09-03
遍历二维数组通常涉及两层循环，分别处理外层的一维数组和内层的元素。以下是一个例子： ```swift for var i = 0; i ; i++ { for var j = 0; j [i].count; j++ { println(array1[i][j]) } } ``` 这个代码片段通过...
c#基础之数组与接口使用示例(遍历数组 二维数组)
12-31
一、初始化数组： 代码如下:string[] s1 = {“aaa”,”bbb”,”ccc”} //直接赋值string[] s2 = new string[5] {“aaa”,”bbb”,”ccc”}; //赋值加指定长度string[] s3 = new string[]{“aaa”,”bbb”,”ccc”...
JAVA——二维数组遍历二维数组的三种方法
weixin_61638178的博客
07-13 6109
java二维数组遍历的三种方法
java二维数组的初始化
热门推荐
jingtian678的博客
11-02 1万+
正确的写法是： String [][]a= { {"1","2","3"}, {"4","5","6"} }; 在讲一点数组的知识： 26，一维数组的形式：(1), int a[]; a = new int[5]; 等同于　int a[] = new int[5]; (2), int[] a; a = new int[5]; 等同于 int[] a =
java中二维数组的初始化及其遍历方式
qq_53909398的博客
11-18 520
直接上代码 package Absttact; /*a[二维数组中的一维数组下标][ 一维数组的下标] *二维数组 它是特殊的一维数组 */ public class Doubleshuzu { public static void main(String [] agrs) { /* * 创建初始化数组 int [] a= new int [5]; int [] a1= {1,2,3}; */ //二维数组 int [] [] src= {{1
java二维数组初始化值_Java二维数组初始化的方法
weixin_39976081的博客
02-16 8055
对于一个新使用的工具，我们会进行初步的初始化工具，目的是为了加上一些使用的配置。在学过了一维数组后，那么二维数组是加了一层维度的一维数组。在初始化方面，二维数组有三种方法，相信很多人只是掌握了其中的一种。下面本篇就Java二维数组简单介绍，然后就三种初始化方法带来详解。1.二维数组说明数组是一个容器，用来存储数据的。现在数组中存储的不再是int，double..的类型了，而是存储的数组。数组中的元...
java中二维数组的静态初始化和动态初始化
qq_66104156的博客
05-11 351
java中二维数组的静态初始化和动态初始化
JAVA二维数组两种初始化方法以及四种遍历方法
jb18602754485的博客
05-01 4353
JAVA二维数组两种初始化方法以及四种遍历方法 public class Arrays { public static void main(String[] args) { //动态初始化 int[][] arr = new int[5][]; System.out.println("==========================================="); /* for循环遍历 此时
增强for循环在一维数组和二维数组中的运用
WY_yao的博客
03-27 393
增强for循环在一维数组和二维数组中的运用 public class forPlus { public static void main(String[] args) { //一维数组中的应用 int[] array = {2, 5, 8, 9, 7}; for (int i : array) { System.out.print(i+"\t"); } System.out.println("
Java小技巧：巧用函数方法实现二维数组遍历
m0_71777195的博客
08-08 497
对于数组遍历，基本上每个开发者都写过，遍历本身没什么好说的，但是当我们在遍历的过程中，有一些复杂的业务逻辑时，将会发现代码的层级会逐渐加深如一个简单的case，将一个二维数组中的偶数找出来，保存到一个列表中二维数组遍历，每个元素判断下是否为偶数，很容易就可以写出来，如 上面这个实现没啥问题，但是这个代码的深度很容易就有三层了；当上面这个if中如果再有其他的判定条件，那么这个代码层级很容易增加了；二维数组还好，如果是三维数组，一个遍历就是三层；再加点逻辑，四层、五层不也是分分钟的事情么那么问题来了，代码层
【总结】一维数组、二维数组的声明和初始化
qq_45555403的博客
03-01 1038
【总结】一维数组、二维数组的声明和初始化 1.一维数组的声明和初始化： 　1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行 　1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行 　 　　　　　　　　　　数组一旦初始化完成，其长度就确定了。 示范代码： int num;//声明 num = 10;//初始化 int id = 1001;//声明 +初始化 int[] ids;//声明 //1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行 ids = new int[]{100
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值