重复数组的元素

Question

如何在Java中重复数组的元素？

例如,给定数组{a,b,c,d,e,f}和数字n,我想生成一个n看起来像的元素数组{a,b,c,d,e,f,a,b,c,d,e,f,a,b,c,...}.

如果我事先知道输入和输出数组的长度,我可以写这样的东西:

int a=input[0], b=input[1], c=input[2], d=input[3], e=input[4], f=input[5];

int[] array = new int[n];
array[0]=a; array[1]=b; array[2]=c; array[3]=d; array[4]=e; array[5]=f;
array[6]=a; array[7]=b; array[8]=c; array[9]=d; array[10]=e; array[11]=f;
array[12]=a; array[13]=b; array[14]=c; // .. and so on

但如果我不知道长度,我怎么能这样做呢？我假设我必须使用某种循环,但我不知道如何写一个.或者是否有一些内置的方法在Java中重复数组,就像其他一些语言一样？

Answer 1

此实现比此处显示的其他实现更清晰,更快捷.

public static <T> T[] repeat(T[] arr, int newLength) {
    T[] dup = Arrays.copyOf(arr, newLength);
    for (int last = arr.length; last != 0 && last < newLength; last <<= 1) {
        System.arraycopy(dup, 0, dup, last, Math.min(last << 1, newLength) - last);
    }
    return dup;
}

理论

System.arraycopy是本地电话.因此它非常快,但并不意味着它是最快的方式.

每个其他解决方案都按元素复制数组元素.我的解决方案复制更大的块.每次迭代都会复制数组中的现有元素,这意味着循环最多只能运行log2(n)次.

分析报告

以下是重现结果的基准代码:

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;

@Fork(3)
@BenchmarkMode(Mode.AverageTime)
@Measurement(iterations = 10, timeUnit = TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
@Threads(1)
@Warmup(iterations = 5, timeUnit = TimeUnit.NANOSECONDS)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MyBenchmark {

  private static final String[] TEST_ARRAY = { "a", "b", "c", "d", "e", "f" };
  private static final int NEW_LENGTH = 10_000;

  @Benchmark
  public String[] testMethod() {
    String[] dup = Arrays.copyOf(TEST_ARRAY, NEW_LENGTH);
    for (int last = TEST_ARRAY.length; last != 0 && last < NEW_LENGTH; last <<= 1) {
      System.arraycopy(dup, 0, dup, last, Math.min(last << 1, NEW_LENGTH) - last);
    }
    return dup;
  }

  @Benchmark
  public String[] testMethod1() {
    String[] arr = new String[NEW_LENGTH];
    for (int i = 0; i < NEW_LENGTH; i++) {
      arr[i] = TEST_ARRAY[i % TEST_ARRAY.length];
    }
    return arr;
  }

  @Benchmark
  public String[] testMethod2() {
    List<String> initialLetters = Arrays.asList(TEST_ARRAY);
    List<String> results = new ArrayList<>();
    int indexOfLetterToAdd = 0;
    for (int i = 0; i < 10000; i++) {
      results.add(initialLetters.get(indexOfLetterToAdd++));
      if (indexOfLetterToAdd == initialLetters.size()) {
        indexOfLetterToAdd = 0;
      }
    }
    return results.toArray(new String[results.size()]);
  }

  @Benchmark
  public String[] testMethod3() {
    String result[] = new String[NEW_LENGTH];
    for (int i = 0, j = 0; i < NEW_LENGTH && j < TEST_ARRAY.length; i++, j++) {
      result[i] = TEST_ARRAY[j];
      if (j == TEST_ARRAY.length - 1) {
        j = -1;
      }
    }
    return result;
  }

  @Benchmark
  public String[] testMethod4() {
    String[] result = Stream.iterate(TEST_ARRAY, x -> x).flatMap(x -> Stream.of(TEST_ARRAY)).limit(NEW_LENGTH)
        .toArray(String[]::new);
    return result;
  }
}

结果

Benchmark                Mode  Cnt      Score      Error  Units
MyBenchmark.testMethod   avgt   30   4154,553 ±   11,242  ns/op
MyBenchmark.testMethod1  avgt   30  19273,717 ±  235,547  ns/op
MyBenchmark.testMethod2  avgt   30  71079,139 ± 2686,136  ns/op
MyBenchmark.testMethod3  avgt   30  18307,368 ±  202,520  ns/op
MyBenchmark.testMethod4  avgt   30  68898,278 ± 2488,104  ns/op

编辑

我重新提出了这个问题,并按照建议的更精确的基准回答了这个问题. 创建长度为N的新数组的最快方法,并通过重复给定数组来填充它

Answer 2

你可以这样试试

String arr[] = {"a", "b", "c", "d", "e", "f"};
int repeat = 10000;
String result[] = new String[repeat];
for(int i=0, j=0; i<repeat && j<arr.length; i++, j++)
{
   result[i] = arr[j];
   if(j == arr.length -1)
         j = -1;
   System.out.println("array["+i+"] : "+result[i]);
}

Answer 3

我假设您知道输入的大小,(例如,您知道上面的输入中有六个元素.让我们命名它iSize.或者,您可以使用输入数组的arr.length位置找到它arr.)

对于上述情况,这可能是更清洁的解决方案.

for(int i=iSize; i<10000; i++)
    arr[i] = arr[i%iSize];

Answer 4

List<String> initialLetters = Arrays.asList("a", "b", "c", "d", "e", "f");
List<String> results = new ArrayList<>();
int indexOfLetterToAdd = 0;
for (int i=1;i<10000;i++){
    results.add(initialLetters.get(indexOfLetterToAdd++));
    if(indexOfLetterToAdd==initialLetters.size()){ //reset counter when necessary
        indexOfLetterToAdd=0;
    }
}
return results;