Java数组(如果想知道Java中有关数组的知识点,那么只看这一篇就足够了!)

简介: Java数组(如果想知道Java中有关数组的知识点,那么只看这一篇就足够了!)

1.数组的定义与创建

       从前言中我们可以知道数组可以看成是相同类型元素的一个集合,在内存中是一段连续的空间。那么数组是如何定义的呢?

       (1)数组的定义

数组的定义如下:

T[] 数组名 = new T[N] ;

其中:

       T:表示数组中存放元素的类型。

       T[ ]:表示数组的类型。

       N:表示数组的长度。

看了上边数组的定义之后还是不太懂到底数组是如何定义的,那么可以看一下下面的案例进一步理解。

int[] array1 = new int[10]; // 一个可以容纳10个int类型元素的数组
 
double[] array2 = new double[5]; // 一个可以容纳5个double类型元素的数组
 
String[] array3 = new double[3]; // 一个可以容纳3个字符串元素的数组

这样我们就大致了解了数组的定义形式了,那么数组又该如何去进行创建呢?

       (2)数组的创建及初始化

对于数组的创建及初始化大致可以分为两种:动态初始化 和 静态初始化

先来看一下动态创建及初始化:

       动态创建及初始化:在创建数组时,直接指定数组中元素的个数。

int[] array = new int[10] ;

细心的读者可以发现,这种初始化和上文数组定义时举出的案例十分相似,是的,在之前的数组定义时举出的案例就是三个动态创建及初始化。(这里在展示一次)

int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
 
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
 
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组

看完动态创建及初始化后,在来看一下静态创建及初始化:

       静态创建及初始化:在创建数组时不直接指定数据元素个数,而直接将具体的数据内容进行指定。

T[] 数组名称 = {data1, data2, data3, ..., datan} ;

这里举出几个静态创建及初始化的案例助你进一步理解。(如下)

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
 
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
 
String[] array3 = new String[]{"hell", "Java", "!!!"};

当然,对于静态创建及初始化java中提供了一种缩写形式,即可以将等号后面的new T[ ]省略掉,所以上边案例就可以改写为:

int[] array1 = {0,1,2,3,4,5,6,7,8,9};
 
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
 
String[] array3 = {"hell", "Java", "!!!"};

注意:

1.  静态初始化虽然没有指定数组的长度,编译器在编译时会根据{}中元素个数来确定数组的长度。
2.  静态初始化时, {}中数据类型必须与[]前数据类型一致。
3.  静态初始化可以简写,省去后面的new T[]。

这样我们就大致的了解了数组的动态创建及初始化 和 静态创建及初始化

补充:

       (1)数组的创建及初始化的分离

       对于数组的创建及初始化,我们可以先进行创建,在初始化,将创建和初始化分开,例如:

动态初始化:

//创建和初始化分开
int[] array;
array = new int[10];
        
//创建和初始化合在一起
int[] array = new int[10];

静态初始化:

//创建和初始化分开
int[] array;
array = new int[]{1, 2, 3, 4, 5};
                
//创建和初始化合在一起
int[] array = new int[]{1, 2, 3, 4, 5};

但是要注意:当我们将创建和初始化分开写的时候,就不可以写静态初始化的简写形式了!

       (2)数组不进行初始化时会有默认值

如果没有对数组进行初始化,数组中元素有其默认值,不同类型的数组默认值如下:

类型 默认值
byte 0
short 0
int 0
long 0
float 0.0f
double 0.0
char /u0000
boolean false

这样我们就大致的了解了数组的定义与创建了。

2.数组的遍历

       我们知道数组在内存中是连续的,那么我们如何去遍历数组中的数据呢?大致有三种方式。

       (1)使用for循环

大致代码如下:

//使用for循环
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }

     

       (2)使用增强for循环

大致代码如下:

//使用增强for循环
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        for(int number : array){
            System.out.print(number+" ");
        }

在增强for循环的内部int number 为从数组中每次取出的数据,而array及所要遍历的数组。

       (3)使用Array.toString方法

大致代码如下:

//导入包
import java.util.Arrays;
 
//使用Array.toString方法
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println(Arrays.toString(array));

这样我们就了解了java中数组如何进行遍历了。

3.数组中常用的API

       说在前面:对于Java中数组的常用API,其方法都在java.util.Arrays包下,所以使用时要进行导包:

import java.util.Arrays;

在 IntelliJ IDEA 编译器中,其会帮助我们自动进行导包。

那么让我们先来看一下有哪些常用的数组API:

我们一个一个进行讲解:

       (1)binarySearch

binarySearch方法的作用:binarySearch方法是用来在数组中查找指定数据的,其返回值为想要查找的数据对应的索引值。

例如:

import java.util.Arrays;
 
public class java2024_5_9 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        //在数组中查找数字5数据的索引值
        int index = Arrays.binarySearch(array, 5);
        System.out.println(index);
    }
}

当然,以上情况是可以在数组中找到找到对应的数据的索引的(数字5在数组中),那么如果数据不在数组中呢?(如下)

import java.util.Arrays;
 
public class java {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7};
        
        //在数组中查找数字10对应的索引
        int index = Arrays.binarySearch(array, 10);
        System.out.println(index);
    }
}

我们可以发现其返回值为负数,这就代表了数字10不在对应的数组中!

这样我们就大致了解了binarySearch方法的使用了。

       (2)copyOf

copyOf方法的作用:用于拷贝数组中的内容的。(可以拷贝全部,也可以拷贝一部分)

例如:

import java.util.Arrays;
 
public class java {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
        //拷贝数组array
        int[] ret = Arrays.copyOf(array, array.length);
        //遍历数组
        for (int i = 0; i < ret.length; i++) {
            System.out.print(ret[i] + " ");
        }
    }
}

当然,我们也可以只拷贝从开头的一部分:

import java.util.Arrays;
 
public class java {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
        //拷贝数组array,但是只拷贝5个数字
        int[] ret = Arrays.copyOf(array, 5);
        //遍历数组
        for (int i = 0; i < ret.length; i++) {
            System.out.print(ret[i] + " ");
        }
    }
}

这样我们就大致了解了copyOf方法的使用了。

       (3)copyOfRange

copyOfRange方法的作用:用于拷贝数组中的内容的。(可以拷贝全部,也可以拷贝一部分)。

我们会发现copyOfRange方法和copyOf方法都是拷贝数组的,那么它们有什么区别呢?

       区别——copyOfRange可以拷贝任何一段数组,而copyOf只能从头开始拷贝。

例如:

import java.util.Arrays;
 
public class java {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
        //拷贝数组array中索引从3到5的数据
        int[] ret = Arrays.copyOfRange(array, 3,6);
        //遍历数组
        for (int i = 0; i < ret.length; i++) {
            System.out.print(ret[i] + " ");
        }
    }
}

注意:拷贝索引值包括前面的,但是不包括后面的!

这样我们就大致了解了copyOfRange方法的使用了。

       (4)equals

equals方法的作用:用于比较两个数组中的数据内容是否相等。

例如:

import java.util.Arrays;
 
public class java {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
        int[] array2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
        int[] array3 = {1, 2, 3, 4, 5, 6, 7, 8};
        //比较array1和array2
        System.out.println(Arrays.equals(array1,array2));
        //比较array1和array3
        System.out.println(Arrays.equals(array1,array3));
    }
}

这样我们就大致了解了equals方法的使用了。

       (5)fill

fill方法的作用:用于将数组中的所有数据都填充为特定值。

例如:

import java.util.Arrays;
 
public class java {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
        //将数组中的所有数字填充为100
        Arrays.fill(array, 100);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

这样我们就大致了解了fill方法的使用了。

       

       (6)sort

sort方法的作用:用于排序数组。

例如:

import java.util.Arrays;
 
public class java {
    public static void main(String[] args) {
        int[] array = {1, 4, 3, 5, 8, 7, 6, 2, 9, 10};
 
        //对数组进行排序
        Arrays.sort(array);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

当然我们会发现其默认的排序方式为升序,那么如何将其排为降序呢?之后学习了比较器之后才可以进行降序,这里不进行讲解。

这样我们就大致了解了sort方法的使用了。

       (7)toString

toString方法的作用:用于将数组打印成字符串的形式。

例如:

import java.util.Arrays;
 
public class java {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
        System.out.println(Arrays.toString(array));
    }
}

这样我们就大致了解了toString方法的使用了。

4.二维数组

       (1)二维数组的定义

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组,定义二维数组的方式为:

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

用一个例子帮助你进一步理解:

//定义一个二维数组
int[][] arr = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}};

对于二维数组中的每一个一维数组,数组中的内容要使用{ }括起来,当然二维数组的用法和一维数组并没有明显差别, 因此我们不再赘述。

       (2)二维数组的遍历

对于二维数组的遍历,其也分为使用for循环、使用增强for循环和使用Array.deepToString方法。

接下来我们直接使用案例来分别看一下三中遍历方式:

       【1】使用for循环

例子:

public class java {
    public static void main(String[] args) {
        int[][] array = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
 
        //遍历二维数组
        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();
        }
    }
}

       【2】使用增强for循环

例子:

public class java {
    public static void main(String[] args) {
        int[][] array = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
 
        //遍历二维数组
        for (int[] ret : array) {
            for (int number : ret) {
                System.out.print(number + " ");
            }
            System.out.println();
        }
    }
}

       【3】使用Array.deepToString方法

例子:

public class java {
    public static void main(String[] args) {
        int[][] array = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
 
        //遍历二维数组
        System.out.println(Arrays.deepToString(array));
    }
}

这样我们就大致了解了二维数组的使用规则。

相关文章
|
5天前
|
存储 算法 安全
Java面试题:Java内存模型及相关知识点深度解析,Java虚拟机的内存结构及各部分作用,详解Java的垃圾回收机制,谈谈你对Java内存溢出(OutOfMemoryError)的理解?
Java面试题:Java内存模型及相关知识点深度解析,Java虚拟机的内存结构及各部分作用,详解Java的垃圾回收机制,谈谈你对Java内存溢出(OutOfMemoryError)的理解?
11 0
|
14天前
|
存储 Java 容器
Java数组的初始化方法
Java数组的初始化方法
|
13天前
|
存储 Java 索引
Java数组操作:基础与进阶指南
Java数组操作:基础与进阶指南
|
3天前
|
Java 大数据 API
Java语言的核心知识点与特性
Java 是一种广泛使用的编程语言,自 1995 年发布以来,它已经成为了企业级应用开发、移动应用开发、大数据处理和云计算等领域的主流技术。
10 0
|
5天前
|
存储 并行计算 安全
Java面试题:Java内存管理、多线程与并发框架的面试题解析与知识点梳理,深入Java内存模型与垃圾回收机制,Java多线程机制与线程安全,Java并发工具包与框架的应用
Java面试题:Java内存管理、多线程与并发框架的面试题解析与知识点梳理,深入Java内存模型与垃圾回收机制,Java多线程机制与线程安全,Java并发工具包与框架的应用
10 0
|
5天前
|
Java
Java面试题:Java内存模型与并发编程知识点,解释Java中“happens-before”的关系,分析Java中的内存一致性效应(Memory Consistency Effects)及其重要性
Java面试题:Java内存模型与并发编程知识点,解释Java中“happens-before”的关系,分析Java中的内存一致性效应(Memory Consistency Effects)及其重要性
8 0
|
6天前
|
Java Apache Maven
Java:commons-codec实现byte数组和16进制字符串转换
在上述代码中,`Hex.encodeHexString(bytes)`用于将byte数组转换为16进制字符串,`Hex.decodeHex(hexString)`用于将16进制字符串转换为byte数组。
10 0
|
7天前
|
Java Apache Maven
Java:commons-codec实现byte数组和16进制字符串转换
在上述代码中,`Hex.encodeHexString(bytes)`用于将byte数组转换为16进制字符串,`Hex.decodeHex(hexString)`用于将16进制字符串转换为byte数组。
14 0
|
14天前
|
Java 索引
解决Java中的数组越界异常的技术
解决Java中的数组越界异常的技术
|
14天前
|
Java
【Java】程序练习1(数组)
【Java】程序练习1(数组)