Java数组的定义和使用

最新推荐文章于 2023-07-29 09:00:00 发布
最新推荐文章于 2023-07-29 09:00:00 发布
阅读量346 收藏
点赞数
分类专栏： Java基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aug_IK/article/details/112723755
版权

数组

数组：是一块连续的内存，存放相同的数据类型的集合

在java中，数组也叫作数组对象。

1.数组定义

int[] arr ={1,2,3};//静态初始化
int[] arr1=new int[10];//定义了数组，但未初始化，默认值为0
int[] arr2=new int[]{1,2,3};//动态初始化

  • 引用不一定在栈上（局部->栈上），对象一定在堆上。
  • 引用除了在定义时，在之后不能整体初始化。

2.数组的使用

1、数组打印：

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr ={1,2,3};
        int[] arr1=new int[10];
        int[] arr2=new int[]{1,2,3,4};
        //数组打印方式 1：
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        for (int x:arr2) {
            System.out.print(x+" ");
        }

        System.out.println();
        //打印方式3
        //将数组转化为字符串输出
        String str = Arrays.toString(arr);
        System.out.println(str);
    }
}
//运行结果：
1 2 3 
1 2 3 4 
[1, 2, 3]
  • 使用 arr.length 能够获取到数组的长度。 . 为成员访问操作符。
  • 打印方式 1 可以拿到下标，方式 2 不可以。
  • 方式3中的  Arrays  是一个工具类，专门用来操作数组的工具类。
  • 使用 [ ] 按下标取（或修改）数组元素，需要注意, 下标从 0 开始计数。
  • 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常。

2、下标越界：

int[] arr ={1,2,3};
System.out.println(arr[3]);

   可以看到数组的长度为3，下标为0~2，输出arr[3]，运行时会报错，数组下标访问异常。

3、认识 null：

  • null 在 Java 中表示 "空引用"
  • null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置.。因此不能对这个内存进行任何读写操 作. 一旦尝试读写, 就会抛出 NullPointerException。
  • arr = null, 代表arr不指向任何对象。

注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联.

4、空指针异常：

当arr=null时，再去访问arr[ ]或者求取长度arr.length 时会报错，空指针异常。

int[] arr ={1,2,3};
arr =null;
System.out.println(arr.length);//运行报错：空指针异常
System.out.println(arr[2]);//运行报错：空指针异常

当代码运行时出现如上的空指针异常的报错，可以去检查引用是否等于null。

5、对象回收

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

当引用arr=null时，原对象{1,2,3}被回收；

当对象未被任何引用 引用时，这个对象就会被垃圾回收器回收掉。

 

6、引用不能指向引用，如出现以下，代表 引用arr1 指向了 引用arr 指向的对象。

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

int[ ] arr1= arr;

7、一个引用只能指向一个对象。如出现以下，最终只指向最后一个对象,之前两个没被其他引用 引用时就会被垃圾回收器回收了。

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

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

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

3.数组作为方法的参数

单独写一个方法打印数组。

public static void print(int[] a){
        for (int i = 0; i <a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] arr={1,2,3};
        print(arr);
    }
//运行结果：1 2 3
  • 在这个代码中 int[] a 是函数的形参, int[ ] arr 是函数实参，如果需要获取到数组长度, 同样可以使用 a.length。
  • 引用a 与arr都指向同一个对象，不管通过哪个引用修改对象的值，另一个引用去访问的时候也会受到影响。（例：如写一个方法swap（）交换1,2。）
public class TestDemo {
    public static void swap(int[] a){
        int t=a[0];
        a[0]=a[1];
        a[1]=t;
    }
    public static void main(String[] args) {
        int[] arr= {1,2};
        System.out.println("交换前：arr[0]="+arr[0]+" arr[1]="+arr[1]);
        swap(arr);
        System.out.println("交换后：arr[0]="+arr[0]+" arr[1]="+arr[1]);
    }
}
//运行结果：
交换前：arr[0]=1 arr[1]=2
交换后：arr[0]=2 arr[1]=1

4.数组作为返回值

例1：return可直接返回数组

import java.util.Arrays;
public class TestDemo {
    public static int[] fun(){
        int[] arr={1,2,3};
        return arr;
        //return new int[]{1,2,3}
        //可替换上面两行，效果一致
        //不可直接return {1,2,3}
    }
    public static void main(String[] args) {
        int[] arr1=fun();
        String str=Arrays.toString(arr1);
        System.out.println(str);
    }
}
//运行结果：[1, 2, 3]

例2: 写一个方法, 将数组中的每个元素都 * 2

public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] arr1=transform(arr);
        printArray(arr1);
    }
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
    public static int[] transform(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 2;
        }
        return arr;
    }
}

//运行结果：2 4 6
  • 这个代码固然可行, 但是破坏了原有数组.arr，有时候我们不希望破坏原数组, 就需要在方法transform内部创建一个新的数组（ int[ ] ret = new int[arr.length] ）, 并由 方法返回出来。另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效。

如下：

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] arr1=transform(arr);
        printArray(arr1);
    }
    public static int[] transform(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 printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}
//运行结果：2 4 6

 

5.数组拷贝

方式1：循环拷贝

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,5,9,5,9,5,5,5};
        int[] arr1=new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr1[i]=arr[i];
        }
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("arr1:"+Arrays.toString(arr1));
    }
}

方式2：

Arrays.copyOf(原数组,拷贝长度)
import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,5,9,5,9,5,5,5};
        int[] arr1=Arrays.copyOf(arr,arr.length);
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("arr1:"+Arrays.toString(arr1));
    }
}
  • 可实现部分拷贝
Arrays.copyOfRange(原始数组，起始位置，结束为止)//左闭右开式
import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,5,9,5,9,5,5,5};
        int[] arr1=Arrays.copyOfRange(arr,2,5);//左闭右开式，包含左边不包含右边
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("arr1:"+Arrays.toString(arr1));
    }
}
//运行结果：
arr:[1, 2, 5, 9, 5, 9, 5, 5, 5]
arr1:[5, 9, 5]

方式3：比方式2快

System.arraycopy(原来的数组,原来数组的位置,目的地的数组,目的地数组位置,拷贝长度);
import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,5,9,5,9,5,5,5};
        int[] arr1=new int[arr.length];
        System.arraycopy(arr,0,arr1,0,arr.length);
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("arr1:"+Arrays.toString(arr1));
    }
}

方式4：

int[] arr1=arr.clone()
import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,5,9,5,9,5,5,5};
        int[] arr1=arr.clone();//产生当前引用的副本
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("arr1:"+Arrays.toString(arr1));
    }
}

这四种拷贝方式是深拷贝还是浅拷贝?

      简单类型：深拷贝；引用类型：浅拷贝

       拷贝后通过修改arr1（拷贝后的新数组）指向的对象，不会影响arr（原数组）所指向的对象，是深拷贝，反之。

6.二维数组

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

数据类型[ ][ ]    数组名称 = new  数据类型 [行数][列数] { 初始化数据 };

int[ ][ ]   arr={{1,2,},{3,4}};( [ ][ ]什么都不能写 ）

int[ ][ ]   arr1= new int[2][3];//默认为0

int[ ][ ]   arr2= new int[2][];//行不可以省略，列可以

int[ ][ ]   arr3= new int[ ][ ]{{1,2,},{3,4}};( [ ][ ]什么都不能写 ）

打印示例：（按需求选择）

打印1：

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[][] arr = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
        for (int row = 0; row < arr.length; row++) {
            for (int col = 0; col < arr[row].length; col++) {
                System.out.printf("%d\t", arr[row][col]);
            }
            System.out.println("");
        }

    }
}
//运行结果
1	2	3	4	
5	6	7	8	
9	10	11	12

打印2：

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[][] arr = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
        for(int[] arr1:arr){
            for (int x : arr1) {
                System.out.print(x+" ");
            }
            System.out.println();
        }
    }
}

打印3：

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[][] arr = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
        String ret = Arrays.deepToString(arr);
        System.out.println(ret);
    }
}
//运行结果：[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

 

 

 

Aug_IK
关注
专栏目录
java数组的定义和使用
weixin_46110257的博客
01-06 621
java数组的定义和使用 一、java 数组描述        数组是一组相同数据类型元素的集合。在Java中数组属于引用类型，即数组是一个对象。这里的数据类型不仅含八大基本数据类型，还包含引用数据类型，如数组里面可以存数组,数组里面可以存放字符串。 二、java 数组作用     &nb...
java定义数组范围_Java数组的定义和使用
weixin_42298876的博客
02-25 2560
为什么需要数组？问题：我们要计算30个学生的平均分如果没有数组，我们的代码是这样的int score1 = 32;int score2 = 56;int score3 = 78;//……此处省略26个变量int score30 = 88;double average = (score1 + score2 + …… + score30) / 30;缺陷很明显了吧？首先要定义的变量太多，假如我们需要存...
Java知多少（14）数组
weixin_34365417的博客
03-24 171
如果希望保存一组有相同类型的数据，可以使用数组。 数组的定义和内存分配 Java 中定义数组的语法有两种： 1 type arrayName[]; 2 type[] arrayName; type 为Java中的任意数据类型，包括基本类型和组合类型，arrayName为数组名，必须是一个合法的标识符，[ ] 指明该变量是一个数组类型变量。例如： 1 int demo...
Java之数组的定义与使用
weixin_74744611的博客
07-28 1966
1.数组中存放的元素类型相同2.数组的空间是连在一起的3.每个空间都有自己的编号，起始位置的编号为0，即数组的下标。
Java数组的定义与使用
weixin_53937197的博客
10-24 569
目录 1 数组的基本用法 1.1数组是什么 1.2创建数组 1.3数组的使用 2 数组作为方法的参数 2.1基本用法 2.2引用的理解 2.3认识null 2.4认识JVM内存区域划分 3数组作为方法的返回值 4 数组练习 4.1数组转字符串 4.2查找数组中的指定元素（二分查找） 1 数组的基本用法 1.1数组是什么 数组是用一段连续的空间来储存一些相同类型的数据。 数组中的每一个数据都有自己的唯一下标，这个下标也是访问这个元素的标识。下标是从0开始的 例如...
43.java数组定义1.zip
06-15
43.java数组定义1.zip43.java数组定义1.zip43.java数组定义1.zip43.java数组定义1.zip43.java数组定义1.zip43.java数组定义1.zip43.java数组定义1.zip43.java数组定义1.zip43.java数组定义1.zip43.java数组定义1.zip...
Java数组的定义、初始化、及二维数组用法分析
08-26
Java数组的定义、初始化、及二维数组用法分析 Java数组是Java编程语言中的一种基本数据结构，用于存储同类型的多个元素。以下是Java数组的定义、初始化、及二维数组用法分析。 一、Java数组的定义 Java数组是一种...
JAVA数组定义
m0_64095015的博客
12-19 530
一、一维数组的定义 type arrayName[]; 其中类型(type)可以为Java中任意的数据类型，包括简单类型组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。例如： int intArray[]; 声明了一个整型数组，数组中的每个元素为整型数据。与C、C++不同，Java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度，而且对于如上定义的一个数组是不能访问它的任何元素的。我们必须为它分配内存空间，这时要用到运算符new，其格
Java数组定义与遍历练习题
最新发布
08-07
1. **P1.java** - 这可能是关于基本数组定义的练习。在Java中，可以使用`int[] arrayName = new int[size]`来定义一个整数数组，其中`size`是数组的长度。例如，`int[] numbers = new int[5]`将创建一个包含5个整数...
Java-数组的定义和使用
qq_64668629的博客
07-29 1728
数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。注意：数组中存放的元素其类型相同，数组的空间是连在一起的每个空间有自己的编号，起始位置编号即数组的下标为0。
Java中数组的定义和使用
qq_62905847的博客
08-19 3461
简单讲解了数组的基本概念，数组的类型，以及简单应用（求数组中元素的平均值 、顺序查找、二分查找、冒泡排序、数组逆序等）
JAVA—数组的定义及使用
m0_68992029的博客
04-12 828
JAVA—数组的定义及使用 一、数组基本用法 1.1 什么是数组：数组的本质就是让我们能批量创造相同类型的变量。 例如：我们想要创建两个变量可以int a; int b; ​ 但是当我i们想要创建成千上万的变量就不行了，此时就需要数组来帮我们批量创建。 1.2 创建数组 基本语法: ​ //动态初始化 ​ 数据类型[] 数组名称 = new 数据类型 [] {初始化数据}； //静态初始化 ​ 数据类型 [] 数组名称 = {初始化数据}； 代码举例：int arr = new int[]{1,2,3
[Java]数组的定义与使用
sjhdaj的博客
03-15 277
在函数内部的修改，也会影响到函数外部实参的数值，这是因为我们把数组的地址拷贝过去，在此地址上修改数值的时候，也会影响实参的数值。在调用完方法后，形参x的修改并不会对实参num产生影响，因为我们只是把实参num的一份拷贝传给了形参，不管形参如何修改都不会对实参产生影响，这也是我们所说的浅拷贝。这时我们对数组进行引用调用，相当于在内存中多开辟了一块空间来存放新的方法数组arr2，但是此数组中存储的是arr1的地址。部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.
Java--数组的定义与使用
qq_56324572的博客
08-26 776
原因是此时的i只是从原数组那里得到了一个拷贝的值，修改了这个临时变量，并不会对原数组的内容产生影响---->要想在遍历数组的过程中修改原数组的内容，需要使用传统的for循环）来遍历数组。eg：i是一个临时变量，从当前arr数组中第一个元素开始遍历，每次从数组arr中取出一个元素，将该元素的值复制一份给i，知道整个arr数组遍历结束。不断比较项链两个元素的大小关系，若前一个元素大于后一元素，交换两者位置，每当进行一次循环，就将当前无序数组的最大值放在了数组的末尾，有序元素+1。...
java语言数组的定义及使用
qq_44326456的博客
02-14 2831
什么叫数组？ 数组是存储同一种数据类型多个元素的集合。也可以看成一个容器。 数组既可以存储基本数据类型，也可以存储引用数据类型，数组本身就是一个引用数据类型。 数组的使用 使用数组的两个步骤：声明数组，分配内存空间【内存分为：堆内存，栈内存，方法区】 1.声明数组（数据类型 数组名[]=null；/数据类型[] 数组名=null;） 2.分配内存给数组（数组名=new 数据类型[长度]；） 内存划...
数组的定义
weixin_42881314的博客
10-22 279
1.声明数组 声明形式一: //type arrayName[]; int a[]; 声明形式二: //type[] arrayName; int[] a; 二维数组的声明和一维数组类似,内存分配也是使用new关键字. 声明: //type arrayName[][]; int a[][] 初始化: //arrayName[][]=new type[行][列];//注意:行、列是方便理解加上...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值