在Java中创建对象数组

我是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();
}

a[0] = new A();

A[]arr=新的A[4]；
对于（int i=0；i<4；i++）{
arr[i]=新的A（）；
}

这是正确的还是我做错了什么？如果这是正确的，那真的很奇怪

<>编辑：我发现这个奇怪，因为在C++中，你只需要说新的<代码> [4 ] < /代码>，它创建了四个对象。

这是正确的。

A[] a = new A[4];

…创建4个

A

引用，与此类似：

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

现在，如果不按如下方式分配

a1

，则无法执行

a1.someMethod（）

：

a1 = new A();

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

同样，对于阵列，您需要执行以下操作：

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

a[0] = new A();

---

…在使用它之前。

这是正确的。您还可以执行以下操作：

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

此语法还可用于在任何位置创建和初始化数组，例如在方法参数中：

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

---

下面是创建包含10个employee对象的数组的清晰示例，其中构造函数接受参数：

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);
    }
}

public类MainClass
{  
公共静态void main（字符串参数[]）
{
System.out.println（“你好，世界！”）；
//步骤1：首先创建包含10个元素的数组，其中包含对象地址。
Emp[]员工=新Emp[10]；
//步骤2：现在在循环中创建对象。
对于（int i=0；iYes），它只创建引用，这些引用被设置为默认值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!

以下是一些非法申报的例子——

// 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
s数组。
因此，JVM创建内存并将新分配内存的引用分配给数组，数组的类型为
int[]

初始化
使用循环–使用for循环初始化数组元素是使数组运行的最常用方法。如果要自行分配默认值，则无需运行for循环，因为JVM会为您执行此操作

一体机..！–我们可以一次性声明、实例化和初始化数组。以下是语法-

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

这里，我们不提大小，因为JVM可以看到我们给出了5个值

因此，在我们实例化引用之前，引用将保持为空。我希望我的回答对您有所帮助….！：）

Source-
是的，在Java中这是正确的。创建对象数组有几个步骤：

声明然后实例化（创建内存以存储“4”对象）：


初始化对象（在这种情况下，可以初始化4个A类对象）

或

或

对于泛型类，有必要创建一个包装类。
例如：

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

Set[]Set=新哈希集[10]

结果为：“无法创建泛型数组”

改用：

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

class SetOfS{public Set=new HashSet（）；}
SetOfS[]集合=新的SetOfS[10]；
你是对的。除此之外，如果我们想创建一个特定大小的数组，数组中填充一些“工厂”提供的元素，因为Java 8（它引入了）我们可以使用这个一行程序：

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


Stream.generate（（）->new A（））
类似于以lambda描述的方式创建的单独A元素的工厂，
（）->new A（）
是供应商的实现

-它描述了每个新A实例应该如何创建

limit（4）

设置流将生成的元素数量

toArray（A[]：：new）

（也可以重写为

toArray（size->newa[size]）

）-它让我们决定/描述应该返回的数组类型

---

对于某些基本类型，您可以使用

DoubleStream

、

IntStream

、

LongStream

，它们还提供了

range

等生成器。

在java中声明新数组的一般形式如下：

type arrayName[]=新类型[numberOfElements]；

其中type是基本类型或对象。

numberOfElements

是要存储到数组中的元素数，此值不能更改，因为Java不支持动态数组（如果需要灵活的动态结构来保存对象，可能需要使用一些Java集合）

让我们初始化一个数组，以存储5人小公司中所有员工的工资：

int工资[]=新int[5]；

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