Java教程

Java 数组

通常，数组是具有连续内存位置的相似类型元素的集合。

Java数组是一个对象，其中包含相似数据类型的元素。此外，数组的元素存储在连续的存储位置中。这是一个数据结构，我们在其中存储相似的元素。我们只能在Java数组中存储一组固定的元素。

Java中的数组是基于索引的，数组的第一个元素存储在第0个索引，第2个元素存储在第一个索引，以此类推。

与C/C ++不同，我们可以使用length成员获取数组的长度。在C/C ++中，我们需要使用sizeof运算符。

在Java中，数组是动态生成的类的对象。 Java数组继承了Object类，并实现了Serializable以及Cloneable接口。我们可以将原始值或对象存储在Java数组中。像C/C ++一样，我们也可以在Java中创建单维或多维数组。

此外，Java提供了C/C ++中不可用的匿名数组功能。

优势

代码优化: 它使代码得以优化，我们可以高效地检索或排序数据。 随机访问: 我们可以获得位于索引位置的任何数据。

缺点

大小限制: : 我们只能在数组中存储元素的固定大小。它不会在运行时增加其大小。为了解决这个问题，在Java中使用了收集框架，该框架会自动增长。

java中的数组类型

有两种类型的数组。

单维数组多维数组

Java中的单维数组

声明Java中的数组的语法

dataType[] arr;
(or)dataType []arr;
(or)dataType arr[];

用Java实例化数组

arrayRefVar=new datatype[size];

Java数组的示例

让我们看一下Java数组的简单示例，在该示例中，我们将声明，实例化，初始化和遍历数组。

//Java Program to illustrate how to declare, instantiate, initialize
//and traverse the Java array.
class Testarray{
    public static void main(String args[]){
        int a[]=new int[5];
        //declaration and instantiationa[0]=10;
        //initializationa[1]=20;
        a[2]=70;
        a[3]=40;
        a[4]=50;
        //traversing arrayfor(int i=0;i<a.length;i++)
        //length is the property of arraySystem.out.println(a[i]);
    }
}

输出:

1020704050

Java数组的声明，实例化和初始化

我们可以通过以下方式一起声明，实例化和初始化Java数组:

int a[]={33,3,4,5};
//declaration, instantiation and initialization

让我们看一下打印此数组的简单示例。

//Java Program to illustrate the use of declaration, instantiation
//and initialization of Java array in a single line
class Testarray1{
    public static void main(String args[]){
        int a[]={33,3,4,5};
        //declaration, instantiation and initialization
        //printing arrayfor(int i=0;i<a.length;i++)
        //length is the property of arraySystem.out.println(a[i]);
    }
}

输出:

33345

用于Java数组的For-each循环

我们还可以使用 for-each循环来打印Java数组。 Java for-each循环逐一打印数组元素。它在变量中包含一个数组元素，然后执行循环的主体。

for-each循环的语法如下:

for(data_type variable:array){
//body of the loop
}

让我们看一下使用for-each循环打印Java数组元素的示例。

//Java Program to print the array elements using for-each loop
class Testarray1{
    public static void main(String args[]){
        int arr[]={33,3,4,5};
        //printing array using for-each loop
        for(int i:arr)System.out.println(i);
    }
}

输出:

33345

在Java中将数组传递给方法

我们可以将Java数组传递给方法，以便我们可以在任何数组上重用相同的逻辑。

让我们看一个简单的示例，以使用一种方法来获取最小数量的数组。

//Java Program to demonstrate the way of passing an array
//to method.
class Testarray2{
    //creating a method which receives an array as a parameter
    static void min(int arr[]){
        int min=arr[0];
        for(int i=1;i<arr.length;i++) if(min>arr[i]) min=arr[i];
        System.out.println(min);
    }
    public static void main(String args[]){
        int a[]={33,3,4,5};
        //declaring and initializing an arraymin(a);
    //passing array to method}
}

输出:

Java中的匿名数组

Java支持匿名数组的功能，因此您无需在将数组传递给方法时声明数组。

//Java Program to demonstrate the way of passing an anonymous array
//to method.
public class TestAnonymousArray{
    //creating a method which receives an array as a parameterstatic void     printArray(int arr[]){
        for(int i=0;i<arr.length;i++)System.out.println(arr[i]);
    }
    public static void main(String args[]){
        printArray(new int[]{10,22,44,66});
    //passing anonymous array to method}
}

输出:

10224466

从方法中返回数组

我们还可以在Java中从方法中返回数组。

//Java Program to return an array from the method
class TestReturnArray{
    //creating method which returns an arraystatic int[] get(){
        return new int[]{
        10,30,50,90,60}
        ;
    }
    public static void main(String args[]){
        //calling method which returns an arrayint arr[]=get();
        //printing the values of an array
        for(int i=0;i<arr.length;i++)
            System.out.println(arr[i]);
    }
}

输出:

1030509060

ArrayIndexOutOfBoundsException

如果遍历数组时数组的长度为负数(等于数组大小或大于数组大小)，则Java虚拟机(JVM)抛出ArrayIndexOutOfBoundsException

//Java Program to demonstrate the case of
//ArrayIndexOutOfBoundsException in a Java Array.
public class TestArrayException{
    public static void main(String args[]){
        int arr[]={50,60,70,80};
        for(int i=0;i<=arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

输出:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4 at TestArrayException.main(TestArrayException.java:5)50607080

Java中的多维数组

在这种情况下，数据存储在基于行和列的索引中(也称为矩阵形式)。

使用Java声明多维数组的语法

dataType[][] arrayRefVar;
(or)dataType [][]arrayRefVar;
(or)dataType arrayRefVar[][];
(or)dataType []arrayRefVar[];

在Java中实例化多维数组的示例

int[][] arr=new int[3][3];
//3 row and 3 column

在Java中初始化多维数组的示例

arr[0][0]=1;
arr[0][1]=2;
arr[0][2]=3;
arr[1][0]=4;
arr[1][1]=5;
arr[1][2]=6;
arr[2][0]=7;
arr[2][1]=8;
arr[2][2]=9;

多维Java数组的示例

让我们看一下声明，实例化，初始化和打印2Dimensional数组的简单示例。

//Java Program to illustrate the use of multidimensional array
class Testarray3{
    public static void main(String args[]){
        //declaring and initializing 2D arrayint arr[][]={
            {1,2,3},{2,4,5},{4,4,5}};
        //printing 2D array
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

输出:

1 2 32 4 54 4 5

Java中的锯齿状数组

如果我们在2D数组中创建奇数列，则称为锯齿状数组。换句话说，它是具有不同列数的数组的数组。

class TestJaggedArray{
    public static void main(String[] args){
        //declaring a 2D array with odd columns
        int arr[][] = new int[3][];
        arr[0] = new int[3];
        arr[1] = new int[4];
        arr[2] = new int[2];
        //initializing a jagged array
        int count = 0;
        for (int i=0; i<arr.length; i++)
            for(int j=0; j<arr[i].length; j++)
                arr[i][j] = count++;

        //printing the data of a jagged array
        for (int i=0; i<arr.length; i++){
            for (int j=0; j<arr[i].length; j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();//new line
        }
    }
}

输出:

0 1 2 3 4 5 6 7 8

Java数组的类名是什么？

在Java中，数组是一个对象。对于数组对象，将创建一个代理类，该代理类的名称可以通过对象上的getClass()。getName()方法获得。

//Java Program to get the
class name of array in Java
class Testarray4{
    public static void main(String args[]){
        //declaration and initialization of arrayint arr[]={
        4,4,5}
        ;
        //getting the class name of Java arrayclass c=arr.getClass();
        String name=c.getName();
        //printing the class name of Java array System.out.println(name);
    }
}

输出:

复制Java数组

我们可以通过System类的arraycopy()方法将一个数组复制到另一个数组。

语法arraycopy方法

public static void arraycopy(Object src, int srcPos,Object dest, int destPos, int length)

在Java中复制数组的示例

//Java Program to copy a source array into a destination array in Java
class TestArrayCopyDemo {
    public static void main(String[] args) {
        //declaring a source array char[] copyFrom = {
        'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'a', 't', 'e', 'd' }
        ;
        //declaring a destination array char[] copyTo = new char[7];
        //copying array using System.arraycopy() method System.arraycopy(copyFrom, 2, copyTo, 0, 7);
        //printing the destination array System.out.println(String.valueOf(copyTo));
    }
}

输出:

caffein

使用Java克隆数组

由于Java数组实现了Cloneable接口，因此我们可以创建Java数组的克隆。如果我们创建一维数组的克隆，它将创建Java数组的深层副本。这意味着它将复制实际值。但是，如果我们创建多维数组的克隆，它将创建Java数组的浅表副本，这意味着它将复制引用。

//Java Program to clone the array
class Testarray1{
    public static void main(String args[]){
        int arr[]={
        33,3,4,5}
        ;
        System.out.println("Printing original array:");
        for(int i:arr)System.out.println(i);
        System.out.println("Printing clone of the array:");
        int carr[]=arr.clone();
        for(int i:carr)System.out.println(i);
        System.out.println("Are both equal?");
        System.out.println(arr==carr);
    }
}

输出:

Printing original array:33345Printing clone of the array:33345Are both equal?false

在Java中添加2个矩阵

让我们看一个简单的示例，该示例将两个矩阵相加。

//Java Program to demonstrate the addition of two matrices in Java
class Testarray5{
    public static void main(String args[]){
        //creating two matricesint a[][]={
            {
            1,3,4}
            ,{
            3,4,5}
        }
        ;
        int b[][]={
            {
            1,3,4}
            ,{
            3,4,5}
        }
        ;
        //creating another matrix to store the sum of two matricesint c[][]=new int[2][3];
        //adding and printing addition of 2 matricesfor(int i=0;i<2;i++){
            for(int j=0;j<3;j++){
                c[i][j]=a[i][j]+b[i][j];
                System.out.print(c[i][j]+" ");
            }
            System.out.println();
        //new line}
    }
}

输出:

2 6 86 8 10

Java中2个矩阵的乘法

在矩阵乘法的情况下，第一个矩阵的单行元素乘以第二个矩阵的所有列，可以通过下面给出的图像来理解。

让我们来看一个简单的这个例子将两个3行3列的矩阵相乘。

//Java Program to multiply two matrices
public class MatrixMultiplicationExample{
    public static void main(String args[]){
        int a[][]={{1,1,1},{2,2,2},{3,3,3}};
        int b[][]={{1,1,1},{2,2,2},{3,3,3}};
        int c[][]=new int[3][3];
        //3 rows and 3 columns
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                c[i][j]=0;
                for(int k=0;k<3;k++) {
                    c[i][j]+=a[i][k]*b[k][j];
                }
                System.out.print(c[i][j]+" ");
            }
            System.out.println();
        }
    }
}

输出:

6 6 6
12 12 12
18 18 18