在 Java 中創建對象數組

Question

我是 Java 新手，當時在 Java 中創建了一個對象數組。

例如，我有一個 A 類 -

A[] arr = new A[4];

但這只是創建指向A而不是 4 個對象的指針（引用）。 這樣對嗎？ 我看到當我嘗試訪問創建的對象中的函數/變量時，我得到了一個空指針異常。 為了能夠操作/訪問對象，我必須這樣做：

A[] arr = new A[4];
for (int i = 0; i < 4; i++) {
    arr[i] = new A();
}

這是正確的還是我做錯了什么？ 如果這是正確的，那真的很奇怪。

編輯：我覺得這很奇怪，因為在 C++ 中你只說 new A[4]並且它創建了四個對象。

Answer 1

這是對的。

A[] a = new A[4];

...創建 4 個A引用，類似於這樣做：

A a1;
A a2;
A a3;
A a4;

現在你不能在不分配a1情況下執行a1.someMethod() ，如下所示：

a1 = new A();

同樣，對於數組，您需要這樣做：

a[0] = new A();

...在使用之前。

Answer 2

這是對的。 你也可以這樣做：

A[] a = new A[] { new A("args"), new A("other args"), .. };

此語法還可用於在任何地方創建和初始化數組，例如在方法參數中：

someMethod( new A[] { new A("args"), new A("other args"), . . } )

Answer 3

是的，它只創建引用，這些引用被設置為它們的默認值 null。 這就是為什么你得到一個 NullPointerException 你需要單獨創建對象並分配引用。 在 Java 中創建數組有 3 個步驟 -

聲明- 在此步驟中，我們指定要創建的數組的數據類型和維度。 但請記住，我們還沒有提到維度的大小。 它們是空的。

實例化——在這一步中，我們使用 new 關鍵字創建數組或為數組分配內存。 在這一步中，我們提到了數組維度的大小。

初始化– 數組始終初始化為數據類型的默認值。 但是我們可以進行自己的初始化。

在 Java 中聲明數組

這就是我們在 Java 中聲明一維數組的方式——

 int[] array; int array[];

Oracle 建議您使用前一種語法來聲明數組。 以下是其他一些法律聲明的例子——

 // One Dimensional Arrays int[] intArray; // Good double[] doubleArray; // One Dimensional Arrays byte byteArray[]; // Ugly! long longArray[]; // Two Dimensional Arrays int[][] int2DArray; // Good double[][] double2DArray; // Two Dimensional Arrays byte[] byte2DArray[]; // Ugly long[] long2DArray[];

這些是一些非法聲明的例子——

 int[5] intArray; // Don't mention size! double{} doubleArray; // Square Brackets please!

實例化

這就是我們“實例化”或為數組分配內存的方式——

 int[] array = new int[5];

當 JVM 遇到new關鍵字時，它明白它必須為某些東西分配內存。 通過指定int[5] ，我們的意思是我們想要一個大小為 5 的int數組。因此，JVM 創建內存並將新分配的內存的引用分配給數組，該數組是int[]類型的“引用” int[]

初始化

使用循環——使用 for 循環來初始化數組的元素是使數組運行的最常見方法。 如果您要自己分配默認值，則無需運行 for 循環，因為 JVM 會為您完成。

一體..！ – 我們可以一次性聲明、實例化和初始化我們的數組。 這是語法 -

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

在這里，我們沒有提到大小，因為JVM可以看到我們給出了5個值。

所以，在我們實例化之前，引用保持為空。 希望我的回答對你有幫助..！ :)

Source - Java 中的數組

Answer 4

這是創建 10 個員工對象的數組的清晰示例，其構造函數帶有參數：

public class MainClass
{  
    public static void main(String args[])
    {
        System.out.println("Hello, World!");
        //step1 : first create array of 10 elements that holds object addresses.
        Emp[] employees = new Emp[10];
        //step2 : now create objects in a loop.
        for(int i=0; i<employees.length; i++){
            employees[i] = new Emp(i+1);//this will call constructor.
        }
    }
}

class Emp{
    int eno;
    public Emp(int no){
        eno = no;
        System.out.println("emp constructor called..eno is.."+eno);
    }
}

Answer 5

你是對的。 除此之外，如果我們想創建由某個“工廠”提供的元素填充的特定大小的數組，因為 Java 8（引入了流 API ）我們可以使用這個單行：

A[] a = Stream.generate(() -> new A()).limit(4).toArray(A[]::new);

• Stream.generate(() -> new A())就像以 lambda 描述的方式創建的單獨 A 元素的工廠， () -> new A()這是Supplier<A>實現 - 它描述了每個新元素如何應該創建一個實例。
• limit(4)設置流將生成的元素數量
• toArray(A[]::new) （也可以改寫為toArray(size -> new A[size]) ）——它讓我們決定/描述應該返回的數組類型。

對於某些原始類型，您可以使用DoubleStream 、 IntStream 、 LongStream ，它們還提供諸如range rangeClosed和其他一些生成器。

Answer 6

在java中聲明一個新數組的一般形式如下：

type arrayName[] = new type[numberOfElements];

其中 type 是原始類型或 Object。 numberOfElements是您將存儲到數組中的元素數，該值不能更改，因為 Java 不支持動態數組（如果您需要一個靈活的動態結構來保存對象，您可能希望使用某些 Java 集合）。

讓我們初始化一個數組來存儲一家 5 人的小公司中所有員工的工資：

int salaries[] = new int[5];

數組的類型（在本例中為int ）適用於數組中的所有值。 您不能在一個數組中混合類型。

現在我們已經初始化了salary 數組，我們想將一些值放入其中。 我們可以在初始化期間這樣做：

int salaries[] = {50000, 75340, 110500, 98270, 39400};

或者稍后再這樣做：

salaries[0] = 50000;
salaries[1] = 75340;
salaries[2] = 110500;
salaries[3] = 98270;
salaries[4] = 39400;

數組創建的更直觀示例：

要了解有關數組的更多信息，請查看指南。

Answer 7

是的，在 Java 中是正確的，有幾個步驟可以創建對象數組：

1. 聲明然后實例化（創建內存來存儲“4”個對象）：

    A[ ] arr = new A[4];

2. 初始化對象（在這種情況下，您可以初始化 4 個 A 類對象）

    arr[0] = new A(); arr[1] = new A(); arr[2] = new A(); arr[3] = new A();

   要么

   for( int i=0; i<4; i++ ) arr[i] = new A();

現在您可以開始從您剛剛創建的對象等調用現有方法。

例如：

  int x = arr[1].getNumber();

要么

  arr[1].setNumber(x);

Answer 8

對於泛型類，有必要創建一個包裝類。 例如：

Set<String>[] sets = new HashSet<>[10]

結果：“無法創建通用數組”

改用：

        class SetOfS{public Set<String> set = new HashSet<>();}
        SetOfS[] sets = new SetOfS[10];  

Answer 9

假設A類是這樣的：

class A{
int rollno;
int DOB;
}        

並且你想為 A 類創建一個對象數組。所以你這樣做，

    A[] arr = new A[4];    //Statement 1
    for (int i = 0; i < 4; i++) {
    arr[i] = new A();      //Statement 2
    }

這是絕對正確的。

這里 A 是類，在語句 1 中，A 類是數組的數據類型。 當由於 new 關鍵字而執行此語句時，將創建一個對象並為其動態分配內存，這將等於 4 個數據類型 A 塊所需的空間，即（對於數組中的一個塊，所需空間為 8 個字節(4+4)，我假設 int 占用 4 個字節的空間。因此分配的總空間為數組 4*4 個字節）。 然后將對象的引用賦予 arr 變量。 這里需要注意的重要一點是，語句 1 與為 A 類創建對象無關，沒有為此類創建對象，它僅用作數據類型，它給出了 A 類內存分配所需的大小大批。

然后，當 for 循環運行並執行語句 2 時，JVM 現在為 A 類分配內存（即創建一個對象）並將其引用提供給 arr[i]。 每次調用循環時都會創建一個對象，並將它的引用提供給 arr[i]。

因此，包含 8 個字節空間的 arr[0] 被賦予 A 類對象的引用，每次循環運行時都會創建新對象並賦予該對象引用，以便它現在可以訪問該對象中的數據目的 。