Java 从阵列交替打印

我想从两个数组a和b交替打印 a[1,2,3,4] b[6,7,8,9]

---

这样16273849应该是输出。输入也可以是字符串或数字。所有这些活动都发生在基于条件的函数内部。

我相信这会起作用：

for(int i = 0, i < a.length + b.length; i++){
    if(i%2 == 0){
        System.out.println(a[i/2]);
    }else{
        System.out.println(b[i/2];
    }
}

for（inti=0，i

我相信这会奏效：

for(int i = 0, i < a.length + b.length; i++){
    if(i%2 == 0){
        System.out.println(a[i/2]);
    }else{
        System.out.println(b[i/2];
    }
}

for（inti=0，i

我相信这会奏效：

for(int i = 0, i < a.length + b.length; i++){
    if(i%2 == 0){
        System.out.println(a[i/2]);
    }else{
        System.out.println(b[i/2];
    }
}

for（inti=0，i

我相信这会奏效：

for(int i = 0, i < a.length + b.length; i++){
    if(i%2 == 0){
        System.out.println(a[i/2]);
    }else{
        System.out.println(b[i/2];
    }
}

for（inti=0，i

用于（int i=0；i

用于（int i=0；i

用于（int i=0；i

用于（int i=0；i

您只需交错阵列：

public void interleave(Object[] a, Object[] b){
  for(int i = 0; i < a.length; i++){
    System.out.print(a[i]);
    System.out.print(b[i]);
  }
}

公共无效交织（对象[]a，对象[]b）{
for（int i=0；i

这假设a和b总是相同的长度。让我们假设它们可以是不同的长度：

public void interleaveVariableLengthArrays(Object[] a, Object[] b){
   int maxLen = Math.max(a.length, b.length);
   for(int i = 0; i < maxLen; i++){
      if(a.length > i){
         System.out.print(a[i]);
      }
      if(b.length > i){
         System.out.print(b[i]);
      }
   }
}

public void interleaveVariableLengtharray（对象[]a，对象[]b）{
int maxLen=Math.max（a.长度，b.长度）；
对于（int i=0；ii）{
系统输出打印（a[i]）；
}
如果（b.长度>i）{
系统输出打印（b[i]）；
}
}
}

确保使用System.out.print而不是System.out.println，否则在每个打印元素之后都会有回车符

现在，让我们假设您要交错的列表数量可变

public void interleaveVariableLengthAndNumberOfArrays(ArrayList<Object[]> arrays){
    int maxLen = 0;
    for(Object[] array : arrays){
       if(array.length > maxLen){
          maxLen = array.length;
       }
    }
    for(int i = 0; i < maxLen; i++){
       for(Object[] array : arrays){
          if(array.length > i){
             System.out.print(a[i]);
          }
       }
    }
}

public void interleaveVariableLengthandNumberOfArray（ArrayList数组）{
int maxLen=0；
for（对象[]数组：数组）{
如果（array.length>maxLen）{
maxLen=数组长度；
}
}
对于（int i=0；ii）{
系统输出打印（a[i]）；
}
}
}
}

您只需交错阵列：

public void interleave(Object[] a, Object[] b){
  for(int i = 0; i < a.length; i++){
    System.out.print(a[i]);
    System.out.print(b[i]);
  }
}

公共无效交织（对象[]a，对象[]b）{
for（int i=0；i

这假设a和b总是相同的长度。让我们假设它们可以是不同的长度：

public void interleaveVariableLengthArrays(Object[] a, Object[] b){
   int maxLen = Math.max(a.length, b.length);
   for(int i = 0; i < maxLen; i++){
      if(a.length > i){
         System.out.print(a[i]);
      }
      if(b.length > i){
         System.out.print(b[i]);
      }
   }
}

public void interleaveVariableLengtharray（对象[]a，对象[]b）{
int maxLen=Math.max（a.长度，b.长度）；
对于（int i=0；ii）{
系统输出打印（a[i]）；
}
如果（b.长度>i）{
系统输出打印（b[i]）；
}
}
}

确保使用System.out.print而不是System.out.println，否则在每个打印元素之后都会有回车符

现在，让我们假设您要交错的列表数量可变

public void interleaveVariableLengthAndNumberOfArrays(ArrayList<Object[]> arrays){
    int maxLen = 0;
    for(Object[] array : arrays){
       if(array.length > maxLen){
          maxLen = array.length;
       }
    }
    for(int i = 0; i < maxLen; i++){
       for(Object[] array : arrays){
          if(array.length > i){
             System.out.print(a[i]);
          }
       }
    }
}

public void interleaveVariableLengthandNumberOfArray（ArrayList数组）{
int maxLen=0；
for（对象[]数组：数组）{
如果（array.length>maxLen）{
maxLen=数组长度；
}
}
对于（int i=0；ii）{
系统输出打印（a[i]）；
}
}
}
}

您只需交错阵列：

public void interleave(Object[] a, Object[] b){
  for(int i = 0; i < a.length; i++){
    System.out.print(a[i]);
    System.out.print(b[i]);
  }
}

公共无效交织（对象[]a，对象[]b）{
for（int i=0；i

这假设a和b总是相同的长度。让我们假设它们可以是不同的长度：

public void interleaveVariableLengthArrays(Object[] a, Object[] b){
   int maxLen = Math.max(a.length, b.length);
   for(int i = 0; i < maxLen; i++){
      if(a.length > i){
         System.out.print(a[i]);
      }
      if(b.length > i){
         System.out.print(b[i]);
      }
   }
}

public void interleaveVariableLengtharray（对象[]a，对象[]b）{
int maxLen=Math.max（a.长度，b.长度）；
对于（int i=0；ii）{
系统输出打印（a[i]）；
}
如果（b.长度>i）{
系统输出打印（b[i]）；
}
}
}

确保使用System.out.print而不是System.out.println，否则在每个打印元素之后都会有回车符

现在，让我们假设您要交错的列表数量可变

public void interleaveVariableLengthAndNumberOfArrays(ArrayList<Object[]> arrays){
    int maxLen = 0;
    for(Object[] array : arrays){
       if(array.length > maxLen){
          maxLen = array.length;
       }
    }
    for(int i = 0; i < maxLen; i++){
       for(Object[] array : arrays){
          if(array.length > i){
             System.out.print(a[i]);
          }
       }
    }
}

public void interleaveVariableLengthandNumberOfArray（ArrayList数组）{
int maxLen=0；
for（对象[]数组：数组）{
如果（array.length>maxLen）{
maxLen=数组长度；
}
}
对于（int i=0；ii）{
系统输出打印（a[i]）；
}
}
}
}

您只需交错阵列：

public void interleave(Object[] a, Object[] b){
  for(int i = 0; i < a.length; i++){
    System.out.print(a[i]);
    System.out.print(b[i]);
  }
}

公共无效交织（对象[]a，对象[]b）{
for（int i=0；i

这假设a和b总是相同的长度。让我们假设它们可以是不同的长度：

public void interleaveVariableLengthArrays(Object[] a, Object[] b){
   int maxLen = Math.max(a.length, b.length);
   for(int i = 0; i < maxLen; i++){
      if(a.length > i){
         System.out.print(a[i]);
      }
      if(b.length > i){
         System.out.print(b[i]);
      }
   }
}

public void interleaveVariableLengtharray（对象[]a，对象[]b）{
int maxLen=Math.max（a.长度，b.长度）；
对于（int i=0；ii）{
系统输出打印（a[i]）；
}
如果（b.长度>i）{
系统输出打印（b[i]）；
}
}
}

确保使用System.out.print而不是System.out.println，否则在每个打印元素之后都会有回车符

现在让我们假设您有一个可变数量的列表