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

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

问：

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

答1:

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

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

对于原始类型：

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

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

  1. String[] myStringArray = new String[3];
  2. String[] myStringArray = {
  3.     "a", "b", "c"};
  4. String[] myStringArray = new String[]{
  5.     "a", "b", "c"};

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

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

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

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

答2:

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

有两种类型的数组。

一维数组

默认值的语法：

  1. int[] num = new int[5];

或（不太喜欢）

  1. int num[] = new int[5];

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

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

或（不太喜欢）

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

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

多维数组

宣言

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

或者

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

或者

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

初始化

  1. num[0][0]=1;
  2.  num[0][1]=2;
  3.  num[1][0]=1;
  4.  num[1][1]=2;
  5.  num[2][0]=1;
  6.  num[2][1]=2;
  7.  num[3][0]=1;
  8.  num[3][1]=2;
  9.  num[4][0]=1;
  10.  num[4][1]=2;

或者

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

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

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

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

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

对于访问：

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

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

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

Google style 也建议这样做。

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

答4:

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

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

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

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

答5:

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

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

  1. Type[] name = new Type[5];

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

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

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

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

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

答6:

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

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

  1. int[] myIntArray = new int[3];

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

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

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

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

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

如果我们只写：

  1. int[] myIntArray;

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

  1. myIntArray=new int[3];

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

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

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

答7:

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

或者，

  1. // Either method works
  2. String arrayName[] = new String[10];
  3. String[] arrayName = new String[10];

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

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

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

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

答8:

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

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

  1. List listOfString = new ArrayList();
  3. listOfString.add("foo");
  4. listOfString.add("bar");
  6. String value = listOfString.get(0);
  7. assertEquals( value, "foo" );

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

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

答9:

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

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

这个，对于一个空数组：

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

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

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

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

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

答10:

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

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

  1. int[] i = new int[capacity];
  2. int[] i = new int[] {
  3.     value1, value2, value3, etc};
  4. int[] i = {
  5.     value1, value2, value3, etc};

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

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

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

  1. public static void varargs(int fixed1, String fixed2, int... varargs) {
  2.     ...}
  3. ...
  4. varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100}
  5. 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] 是：

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

答11:

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

在 Java 9 中

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

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

在 Java 10 中

使用 Local Variable Type Inference：

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

原文链接：https://www.huntsbot.com/qa/9r20/how-do-i-declare-and-initialize-an-array-in-java?lang=zh_CN&from=csdn

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

发表评论

表情：
评论列表 （有 0 条评论，205人围观）

还没有评论，来说两句吧...

相关阅读