如何在 Java 中声明和初始化数组？

骑猪看日落 2024-03-30 15:24 81阅读 0赞

## 问： ##

如何在 Java 中声明和初始化数组？

## 答1: ##

> HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

您可以使用数组声明或数组文字（但仅当您立即声明并影响变量时，数组文字不能用于重新分配数组）。

对于原始类型：

int[] myIntArray = new int[3];
    int[] myIntArray = {
        1, 2, 3};
    int[] myIntArray = new int[]{
        1, 2, 3};
    
    // Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html
    
    int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
    int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
    int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
    int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort

对于类，例如 String，它是相同的：

String[] myStringArray = new String[3];
    String[] myStringArray = {
        "a", "b", "c"};
    String[] myStringArray = new String[]{
        "a", "b", "c"};

当您先声明一个数组然后对其进行初始化、将数组作为函数参数传递或返回一个数组时，第三种初始化方式很有用。显式类型是必需的。

String[] myStringArray;
    myStringArray = new String[]{
        "a", "b", "c"};

`同时使用第二种和第三种方法的目的是什么？`

`@iamcreasy 看起来第二种方法不适用于 return 语句。 return {1,2,3} 给出错误，而 return new int[]{1,2,3} 工作正常（当然假设您的函数返回一个整数数组）。`

## 答2: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

有两种类型的数组。

一维数组

默认值的语法：

int[] num = new int[5];

或（不太喜欢）

int num[] = new int[5];

给定值的语法（变量/字段初始化）：

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

或（不太喜欢）

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

注意：为方便起见，最好使用 int\[\] num，因为它清楚地表明您在这里谈论的是数组。否则没有区别。一点也不。

多维数组

宣言

int[][] num = new int[5][2];

或者

int num[][] = new int[5][2];

或者

int[] num[] = new int[5][2];

初始化

num[0][0]=1;
     num[0][1]=2;
     num[1][0]=1;
     num[1][1]=2;
     num[2][0]=1;
     num[2][1]=2;
     num[3][0]=1;
     num[3][1]=2;
     num[4][0]=1;
     num[4][1]=2;

或者

int[][] num={
         {
        1,2}, {
        1,2}, {
        1,2}, {
        1,2}, {
        1,2} };

参差不齐的阵列（或非矩形阵列）

int[][] num = new int[5][];
     num[0] = new int[1];
     num[1] = new int[5];
     num[2] = new int[2];
     num[3] = new int[3];

所以在这里我们明确定义列。另一种方式：

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

对于访问：

for (int i=0; i<(num.length); i++ ) {
        
        for (int j=0;j 有关说明，请参阅 the official java tutorials 中的多维数组详细信息
    
     `第一个不会导致空/空数组，而不是具有默认值的数组吗？`
    
    `我同意这一点，我们可以再添加一个功能，我们可以动态更改大小。`
    
    `我可能会与您争论多维数组是数组的另一种“类型”。它只是一个用于描述恰好包含其他数组的数组的术语。外部数组和内部数组（以及介于两者之间的数组，如果它们存在的话）都只是常规数组。`
    
    # 答3:
    > huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。
    
    
    
    ```java
    Type[] variableName = new Type[capacity];
    
    Type[] variableName = {
        comma-delimited values};
    
    
    
    Type variableName[] = new Type[capacity]; 
    
    Type variableName[] = {
        comma-delimited values};

也是有效的，但我更喜欢类型后面的括号，因为更容易看出变量的类型实际上是一个数组。

`我同意这一点。变量的类型不是“TYPE”，而是一个 TYPE[]，所以这样写对我来说是有意义的。`

`Google style 也建议这样做。`

`请注意，int[] a, b; 与 int a[], b; 不同，如果使用后一种形式很容易犯错误。`

## 答4: ##

> huntsbot.com – 高效赚钱，自由工作

在 Java 中可以通过多种方式声明数组：

float floatArray[]; // Initialize later
    int[] integerArray = new int[10];
    String[] array = new String[] {
        "a", "b"};

您可以在 Sun tutorial 网站和 JavaDoc 中找到更多信息。

## 答5: ##

> huntsbot.com全球7大洲远程工作机会，探索不一样的工作方式

如果您了解每个部分，我发现它会很有帮助：

Type[] name = new Type[5];

Type\[\] 是称为名称的变量 的类型（“名称”称为标识符）。文字“Type”是基类型，括号表示这是该基的数组类型。数组类型又是它们自己的类型，它允许您创建像 Type\[\]\[\] （Type\[\] 的数组类型）这样的多维数组。关键字 new 表示为新数组分配内存。括号之间的数字表示新数组有多大以及要分配多少内存。例如，如果 Java 知道基本类型 Type 占用 32 个字节，而您想要一个大小为 5 的数组，则它需要在内部分配 32 \* 5 = 160 个字节。

您还可以使用已经存在的值创建数组，例如

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

这不仅会创建空白空间，还会用这些值填充它。 Java 可以分辨出原语是整数并且它们有 5 个，因此可以隐式确定数组的大小。

`所以没有必要包括 int[] name = new int[5] ？`

## 答6: ##

> huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

下面展示了一个数组的声明，但是数组没有初始化：

int[] myIntArray = new int[3];

下面显示了数组的声明和初始化：

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

现在，下面还显示了数组的声明和初始化：

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

但是这第三个显示了匿名数组对象创建的属性，它由引用变量“myIntArray”指向，所以如果我们只写“new int\[\]\{1,2,3\};”那么这就是创建匿名数组对象的方式。

如果我们只写：

int[] myIntArray;

这不是数组的声明，但以下语句使上述声明完整：

myIntArray=new int[3];

`第二种和第三种方法之间绝对没有区别，除了第二种方法仅在您还声明变量时才有效。目前尚不清楚“显示匿名数组对象创建的属性”是什么意思，但它们确实是等效的代码片段。`

`此外，第一个片段确实初始化了数组 - 它保证每个数组元素的值都为 0。`

`第二种和第三种方法真的没有区别吗？`

## 答7: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

或者，

// Either method works
    String arrayName[] = new String[10];
    String[] arrayName = new String[10];

这声明了一个名为 arrayName 的大小为 10 的数组（您可以使用 0 到 9 的元素）。

`使用的标准是什么？我才刚刚发现前者，我发现它非常具有误导性：|`

`值得我的教授说，第二种方式在 Java 中更典型，它更好地传达了正在发生的事情；作为与变量被转换为的类型相关的数组。`

`附带说明：一种具有多个语义的语言，用于声明一件事意味着糟糕的语言设计。`

## 答8: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

此外，如果您想要更动态的东西，可以使用 List 界面。这不会表现得那么好，但更灵活：

List listOfString = new ArrayList();
    
    listOfString.add("foo");
    listOfString.add("bar");
    
    String value = listOfString.get(0);
    assertEquals( value, "foo" );

`您创建的列表中调用的“<>”是什么？`

`@CyprUS List 是一个泛型类，它有一个类型作为参数，包含在 <> 中。这很有帮助，因为您只需要定义一次泛型类型，然后就可以将它与多种不同的类型一起使用。如需更详细的说明，请参阅 docs.oracle.com/javase/tutorial/java/generics/types.html`

## 答9: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

创建数组有两种主要方法：

这个，对于一个空数组：

int[] array = new int[n]; // "n" being the number of spaces to allocate in the array

而这个，对于一个初始化的数组：

int[] array = {
        1,2,3,4 ...};

您还可以制作多维数组，如下所示：

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
    int[][] array2d = {
         {
        1,2,3 ...}, {
        4,5,6 ...} ...};

## 答10: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

以原始类型 int 为例。有几种方法可以声明和int数组：

int[] i = new int[capacity];
    int[] i = new int[] {
        value1, value2, value3, etc};
    int[] i = {
        value1, value2, value3, etc};

在所有这些中，您可以使用 int i\[\] 而不是 int\[\] i。

通过反射，您可以使用 (Type\[\]) Array.newInstance(Type.class, capacity);

请注意，在方法参数中，… 表示 variable arguments。本质上，任何数量的参数都可以。用代码更容易解释：

public static void varargs(int fixed1, String fixed2, int... varargs) {
        ...}
    ...
    varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100}
    varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};

在方法内部，varargs 被视为普通的 int\[\]。 Type… 只能用在方法参数中，所以 int… i = new int\[\] \{\} 不会编译。

请注意，将 int\[\] 传递给方法（或任何其他 Type\[\]）时，不能使用第三种方式。在语句 int\[\] i = *\{a, b, c, d, etc\}* 中，编译器假定 \{…\} 表示 int\[\]。但那是因为你声明了一个变量。将数组传递给方法时，声明必须是 new Type\[capacity\] 或 new Type\[\] \{…\}。

多维数组

多维数组更难处理。本质上，二维数组是数组的数组。 int\[\]\[\] 表示 int\[\] 的数组。关键是如果将 int\[\]\[\] 声明为 int\[x\]\[y\]，则最大索引为 i\[x-1\]\[y-1\]。本质上，矩形 int\[3\]\[5\] 是：

[0, 0] [1, 0] [2, 0]
    [0, 1] [1, 1] [2, 1]
    [0, 2] [1, 2] [2, 2]
    [0, 3] [1, 3] [2, 3]
    [0, 4] [1, 4] [2, 4]

## 答11: ##

> huntsbot.com – 高效赚钱，自由工作

在 Java 9 中

使用不同的 IntStream.iterate 和 IntStream.takeWhile 方法：

int[] a = IntStream.iterate(10, x -> x <= 100, x -> x + 10).toArray();
    
    Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
    
    
    int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray();
    
    Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

在 Java 10 中

使用 Local Variable Type Inference：

var letters = new String[]{
        "A", "B", "C"};

原文链接：[https://www.huntsbot.com/qa/9r20/how-do-i-declare-and-initialize-an-array-in-java?lang=zh\_CN&from=csdn][https_www.huntsbot.com_qa_9r20_how-do-i-declare-and-initialize-an-array-in-java_lang_zh_CN_from_csdn]

> HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

[https_www.huntsbot.com_qa_9r20_how-do-i-declare-and-initialize-an-array-in-java_lang_zh_CN_from_csdn]: https://www.huntsbot.com/qa/9r20/how-do-i-declare-and-initialize-an-array-in-java?lang=zh_CN&from=csdn