【JavaSE】_4.数组

已于 2023-07-13 15:35:20 修改
阅读量106 收藏
点赞数
分类专栏： JavaSE 文章标签： java idea
于 2023-03-20 20:23:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63299495/article/details/129636909
版权

目录

1. 数组的基本用法

1.1 数组的创建

1.2 数组的使用

1.2.1 获取元素与访问元素

 1.2.2 遍历数组

2.数组作为方法的参数

2.1 JVM内存分布

2.2 基本用法

 2.3 空引用null

3. 数组作为方法的返回值

 4. 数组练习

4.1 编写方法将数组以字符串形式输出

4.2 找数组中的最大元素

4.3 求数组中元素的平均值

4.4 数组指定元素的查找

4.5 检查数组的有序性

4.6 数组排序（冒泡排序） 

 4.7 数组逆序

4.8 数组数字排列

4.9 数组的拷贝 

5. 二维数组

1. 数组的基本用法

1.1 数组的创建

 //1
int[] arr1 = {1,2,3,4,5};    //[]中不能含有数字
//创建长度为5的arr1数组并初始化其5个元素依次为12345
//2
int[] arr2 = new int[3];     //创建数组arr2，长度为3，元素均为0；
 //3
int[] arr3 = new int[]{1,2,3,4,5};   
//创建长度为5的arr3数组并初始化其5个元素依次为12345
//1与3的创建结果相同
//4 不建议下述写法：
int arr4[] = {1,2,3,4,5};

1.2 数组的使用

1.2.1 获取元素与访问元素

public static void main(String[] args) {
    int[]arr1 = {1,2,3,4,5,6};
    System.out.println("The length of the array is "+arr1.length);
    System.out.println("The element with index[4] is "+arr1[4]);
    arr1[4]=50;
    System.out.println("The element with index[4] now is "+arr1[4]);
}

输出结果为：

注：Java的数组访问下标不可以是负数：

试运行：

int[]arr1 = {1,2,3,4,5,6};
System.out.println("The element with index [-1] is "+arr1[-1]);

报错如下： 

 1.2.2 遍历数组

int[] arr1={1,2,3,4,5,6};

//方法一：for循环遍历数组
for(int i=0;i<arr1.length;i++){
    System.out.print(arr1[i]+" ");
}
System.out.println();

//方法二：for-each(增强for循环）遍历数组
for(int x:arr1){
    System.out.print(x+" ");
}
System.out.println();
        
//方法三：借助java操作数组的工具类Arrays：将参数的数组以字符串形式输出
String str = Arrays.toString(arr1);
System.out.println(str);

输出结果为：

注：for循环与for-each循环的区别在于，for循环是可以得到下标的，for-each是得不到下标的；

for-each会更多地使用到集合中；

2.数组作为方法的参数

2.1 JVM内存分布

注：引用不一定存储在栈上，一个变量存储的位置取决于其性质。

局部变量就会存储在栈上，实例成员变量不一定在栈上。

2.2 基本用法

代码示例1：

运行代码如下：

public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6};
        print(array);
    }
public static void print(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

输出结果如下：

逻辑如下：

代码示例2：

运行代码如下：

public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(array));
        func1(array);
        System.out.println(Arrays.toString(array));
        func2(array);
        System.out.println(Arrays.toString(array));
    }
public static void func1(int[] array){
        array = new int[] {11,2,13,4,51,61};
    }
public static void func2(int[] array){
        array[0]=899;
    }

输出结果为：

  

fun1函数的调用执行逻辑如下：

 2.3 空引用null

（1）常见引用使用含义：

        int[] array1={1,2,3,4,5};
        int[] array2=array1;
        //array2这个引用也指向了array1这个引用指向的对象

        int[] array3=null;
        //array3这个引用不指向任何对象

        int[] array4 = new int[]{5,6,7,8,9};
        array4 = new int[10];
        //一个引用不能同时指向多个对象,一个引用只能保存一个对象的地址
        //array4最终只保存了new int[10]的地址

 （2）引用是指向对象的、存储对象地址的变量，故而当：

 int[] arr2 = null; //代表引用arr2不指向任何对象
System.out.println(arr2.length);

时，会报错如下： 

（3）应用示例：使用数组交换两个变量的值：

public static void main(String[] args) {
        //使用方法交换两个变量的值
        int a=10;
        int b=20;
        int[] array={10,20};
        System.out.println("Before Swap:a="+array[0]+",b="+array[1]);
        Swap(array);
        System.out.println("Before Swap:a="+array[0]+",b="+array[1]);
    }
    public static void Swap(int[] arr){
        int tmp=arr[0];
        arr[0]=arr[1];
        arr[1]=tmp;
    }

输出结果如下：

  

3. 数组作为方法的返回值

代码示例：使用方法将数组的每个元素都*2：

public static void main(String[] args) {
        //使用方法将数组的每个元素都*2
        int[] array={1,2,3,4,5};
        System.out.println("Original array:"+Arrays.toString(array));
        MulDouble1(array);
        System.out.println("Function MulDouble1:"+Arrays.toString(array));
        //创建引用变量接收以数组为返回值的方法的返回值
        int[] ret = MulDouble2(array);
        System.out.println("Function MulDouble2:"+Arrays.toString(ret));
    }
      //使用数组作为方法返回值
public static int[] MulDouble2(int[] arr){
        int[] ret=new int[arr.length];
        for(int i=0;i<arr.length;i++){
            ret[i]=arr[i]*2;
        }
        return ret;
    }
public static void MulDouble1(int[] arr){
        for(int i=0;i<arr.length;i++){
            arr[i] = arr[i]*2;
        }
    }

输出结果为：

 注：上述代码的MulDouble1 函数虽然实现了将数组每个元素都*2功能，但也改变了元素组的内容，而MulDouble2 方法并没有改变数组的内容；

 4. 数组练习

4.1 编写方法将数组以字符串形式输出

 public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        System.out.println(my_toString(array));
    }
    public static String my_toString(int[] arr){
        if(arr==null){
            return null;
        }
        String str="[";
        for(int i=0;i<arr.length;i++){
            str+=arr[i];
            if(i!=arr.length-1){
               str+=",";
            }
        }
        str+="]";
        return str;
    }

输出结果为：

4.2 找数组中的最大元素

public static void main(String[] args) {
        int[] array={12,8,1,2,10};
        System.out.println("The max element is "+maxElm(array));
    }
    public static int maxElm(int[] arr){
        if(arr==null){
            return -1;
        }
        if(arr.length==0){
            return 0;
        }
        int max=arr[0];
        for(int i=0;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        return max;
    }

输出结果为：

4.3 求数组中元素的平均值

public static void main(String[] args) {
        int[] array={1,2,3,4,5,6};
        System.out.println("The average num is "+ ave(array));
    }
    public static double ave(int[] arr){
        int sum=0;
        for(int x:arr){
            sum+=x;
        }
        double ave =(double) sum/arr.length;
        return ave;
    }

 输出结果为：

4.4 数组指定元素的查找

（1）无序数组的顺序查找：

public static void main(String[] args) {
        int[] array={1,9,4,2,15,1};
        Scanner scanner = new Scanner(System.in);
        int key = scanner.nextInt();
        System.out.println("The index of element "+key+" is "+elmFind(array,key));
    }
    public static int elmFind(int[] arr,int key ){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                return i;
            }
        }
        return -1;   //数组的下标不可能为负数，返回-1即表示查找失败
    }

输出结果为：

 （2）有序数组的二分查找：

public static void main(String[] args) {
        int[] array={1,2,3,4,5,6};
        Scanner scanner = new Scanner(System.in);
        int key = scanner.nextInt();
        System.out.println("The index of element "+key+" is "+elmFind(array,key));
    }
    public static int binarySearch(int[] arr,int key){
        int left=0,right=arr.length-1;
        while(left<=right) {
            int mid = (left + right) / 2;
            if (key < arr[mid]) {
                right = mid - 1;
            } else if (key > arr[mid]) {
                left = mid + 1;
            }
            else{
                return mid;
            }
        }
        return -1;
    }

输出结果为：

注：操作数组工具Arrays中其实已经实现了二分查找方法，可以进行直接调用：

运行下文代码： 

public static void main(String[] args) {
        int[] array={1,2,3,4,5,6};
        Scanner scanner = new Scanner(System.in);
        int key = scanner.nextInt();
        System.out.println("The index of element "+key+" is "+Arrays.binarySearch(array,key));
    }

 输出结果为：

4.5 检查数组的有序性

public static void main(String[] args) {
        //检查数组的有序性（升序为例）
        int[] array1 ={12,13,14,15,16};
        int[] array2 ={12,15,17,16,13};
        System.out.println("array1 is sorted ?"+isSorted(array1));
        System.out.println("array2 is sorted ?"+isSorted(array2));
    }
    public static boolean isSorted(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            if(arr[i]>arr[i+1]){
                return false;
            }
        }
        return true;
    }

 输出结果为：

4.6 数组排序（冒泡排序） 

public static void main(String[] args) {
        int[] array={11,2,3,14,15};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
public static void bubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            boolean flag = false;
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
    }

输出结果为：

 4.7 数组逆序

public static void main(String[] args) {
        //数组逆序
        int[] array={1,2,3,4,5};
        reverse(array);
        System.out.println(Arrays.toString(array));
        String str = reverse2(array);
        System.out.println(str);
    }
    public static void reverse(int[]arr){
        int i=0;
        int j=arr.length-1;
        while(i<j){
            int tmp=arr[i];
            arr[i]=arr[j];
            arr[j]=tmp;
            i++;
            j--;
        }
    }
    public static String reverse2(int[] arr){
        String str="[";
        for(int i=arr.length-1;i>=0;i--){
            str+=arr[i];
            if(i!=0) {
                str += ", ";
            }
        }
        str+="]";
        return str;
    }

输出结果为：

4.8 数组数字排列

public static void main(String[] args) {
        //数组数字排列：将偶数放在数组前半部分、奇数放在数组后半部分
        int[] array={1,2,3,4,5,6};
        transform(array);
        System.out.println("transform: "+Arrays.toString(array));
        int[] array2=transform2(array);
        System.out.println("transform2: "+Arrays.toString(array2));
    }
    public static void transform(int[] arr){
        int i=0;
        int j=arr.length-1;
        while(i<j){
            //i遇到奇数停止++，j遇到偶数停止--
            while(i<j&&arr[i]%2==0){
                i++;
            }//arr[i]一定是偶数
            while(i<j&&arr[j]%2!=0){
                j--;
            }//arr[j]一定是奇数
            int tmp=arr[i];
            arr[i]=arr[j];
            arr[j]=tmp;
        }
    }
    public static int[] transform2(int[] arr){
       int[] arr2=new int[arr.length];
       int i=0;
       int j=arr.length-1;
       for(i=0;i<arr.length-1;i++){
           if(arr[i]%2==0){
               arr2[i]=arr[i];
           }
       }
       for(j=arr.length-1;j>=0;j--){
           if(arr[j]%2!=0){
               arr2[j]=arr[j];
           }
       }
        return arr2;
    }

输出结果为：

4.9 数组的拷贝 

 public static void main(String[] args) {
        int[] array={1,2,3,4,5,6};
        int[] copy1=copy1(array);
        System.out.println("Original array:  "+Arrays.toString(array));
        //copy1 为自定义拷贝方法
        System.out.println("copy1 array:     "+Arrays.toString(copy1));
        //copy 为java自带工具方法：
        //参数为待拷贝数组与拷贝长度（一般为数组本身长度或其整数倍数）
        int[] copy = Arrays.copyOf(array,array.length);
        System.out.println("copy array:      "+Arrays.toString(copy));
        //java自带的部分拷贝方法（左闭右开）
        int[] copy2=Arrays.copyOfRange(array,1,3);
        System.out.println("copy2 array:     "+Arrays.toString(copy2));
        //另外一种部分拷贝方法：System.arraycopy方法
        int[] copy3= new int[array.length];
        System.arraycopy(array,0,copy3,0,array.length);
        System.out.println("copy3 array:     "+Arrays.toString(copy3));
        //数组调用产生副本clone方法
        int[] copy4=array.clone();
        System.out.println("copy4 array:     "+ Arrays.toString(copy4));
    }
public static int[] copy1(int[] arr){
        int[] arr2=new int[arr.length];
        for(int i=0;i<arr.length;i++){
            arr2[i]=arr[i];
        }
        return arr2;
    }

 输出结果为：

5. 二维数组

二维数组本质上也是一维数组，只不过每个元素又是一个一维数组；

（1）二维数组的定义：

        int[][] array1 = {{1,2,3},{4,5,6}};   //[][] 中不能填充数据
        int[][] array2 = new int[][]{{1,2,3},{4,5,6}};
        int[][] array3 = new int[2][3];
        //java规定必须手动规范行和列元素

（2）二维数组的遍历打印：

 public static void main(String[] args) {
        int[][] array={{1,2,3},{4,5,6}};
        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();
        }
        System.out.println("--------");
        for(int[] arr:array){
            for(int x:arr){
                System.out.print(x+" ");
            }
            System.out.println();
        }
        System.out.println("--------");
        System.out.println(Arrays.deepToString(array));
    }

输出结果为：

注：（1）特殊二维数组的遍历：

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

运行上文代码，报错如下：

 因为java的二维数组可以省略列定义，故而当定义二维数组array2=int[ 2 ] [  ] 时，实际上array2数组是一个两个元素均为null的数组，此时调取array2.length或array2[i].length时，就会出现空指针错误；

（2）定义不规则数组：

int[][] array2=new int[2][];
//定义不规则数组
array2[0]=new int[3];
array2[1]=new int[2];
_周游
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE_集合.pdf
02-02
### JavaSE_集合.pdf 关键知识点详解 #### 一、集合与数组的区别 - **固定与动态**: 数组的长度是固定的，一旦声明后就不能改变；而集合的大小可以动态扩展，更适合处理不确定数量的数据。 - **数据类型**: 数组...
(5)javaSE_数组.xmind
08-21
主要是关于数组的xmind思维导图梳理的图解，更好的理解数组的应用
【002 数组】数组下标可以为负数吗?
kashine的博客
01-29 887
可以，因为下标只是给出了一个与当前地址的偏移量而已，只要根据这个偏移量能定位得到目标地址即可。
指针-从入门到放弃系列（数组篇）
Charon的博客
01-30 383
C指针核心 1. 指针和数组 1.1 数组名的使用 #include<stdio.h> int main() { int array[5] = { 10, 20, 30, 40, 50 }; printf("数组的大小为：%d",sizeof(array));//array占有20字节 return 0; } 以上程序输出结果为：20，可以我们知道，数组名我们可以当作指向数组的首元素的指针，但是数组名和指针还是有区别的，因为一个指针的大小为四个字节（32位操作系统）。
数组使用负数下标
Learning Deep Learning
08-23 9108
在刷题的过程中，很多时候都用到区间[- maxn, maxn]。但我们知道常规的数组的下标都是从0开始的并没有负数，这时候，要么开一个二维数组，要么就是开一个[0, 2 * maxn]的数组。 下面的方法就可以解决负数作为下标的问题。代码部分# include <bits/stdc++.h> using namespace std; const int maxn = 1e6; ///先声明数组 i
当数组下标是负数
xifengcode
01-28 3177
假设整数位置的二维坐标点上都有一个温度，横坐标的范围是-3..2共6个点，纵坐标的范围是-4..3共8个点，因此，二维坐标点共48个，小宝定义了二维数组int data[6][8]; 用data[0][0]存储坐标点(-3,-4)的温度，用data[0][1]存储坐标点(-3,-3)的温度，用data[0][2]存储坐标点(-3,-2)的温度，......，用data[5][7]存储坐标点(2,
数组下标为负数的问题（C语言）
热门推荐
zihonggege的博客
08-20 2万+
早上看到了这样一道C语言指针题 result：4 和 空 int arr[5] 对这个数组 来说： arr[-1]是合法的，他指向a[0]的前一个元素。 但是不建议这样书写，因为a[-1]的地址是不确定的， 可能会影响到系统运行。如果同上面一题一样加上指针，可以巧妙地解决某些问题。下面贴上代码段，帮助理解。 #include &lt;stdio.h&gt; int main(vo...
javaSE_java_core.docx
02-28
`List`接口允许元素重复且保持插入顺序，常见的实现有`ArrayList`（基于数组）和`LinkedList`（基于链表）。`Set`接口不允许元素重复且无特定顺序，`HashSet`是常用的实现，它利用散列算法确保元素的唯一性。`Map`...
JavaSE__数组及常用算法.ppt
03-19
JavaSE__数组及常用算法.ppt
JavaSE笔记_工具.zip
06-02
4. **多态性**：多态性使得不同的对象可以对同一消息作出不同的响应，提供了代码的通用性和可扩展性。Java中的多态性主要通过接口和抽象类来实现。 面向过程编程（Procedural Programming）则更侧重于功能和步骤的...
枚举工具类
qq_43049583的博客
08-04 120
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 174
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 569
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Servlet(2)
最新发布
xjdkxnhcoskxbco的博客
08-04 332
这个注解可以用来修饰一个Servlet类，可以简化配置，替代Web.xml中 的servlet配置。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 512
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 515
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 683
集合之Map
JavaSE深入学习：数组全面解析
"JavaSE进阶数组讲义涵盖了数组的基础概念、一维数组的声明与使用、二维数组的声明与使用、数组的排序、查找以及Arrays工具类的应用。本讲义详细介绍了数组作为引用数据类型的特点，包括其作为对象的属性、length...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值