重复一个数组元素 [英] Repeating the elements of an array

问题描述

我怎么能重复一个数组的元素在Java中？

How can I repeat the elements of an array in Java?

，例如，给定阵列 {A，B，C，D，E，F} 等一批 N ，我想产生一个 N -element阵列看起来像 {A，b，C，D，E，F，A，b ，C，D，E，F，A，b，C，...} 。

For example, given the array {a,b,c,d,e,f} and a number n, I want to produce an n-element array that looks like {a,b,c,d,e,f,a,b,c,d,e,f,a,b,c,...}.

如果我知道事先输入和输出数组的长度，我可以这样写：

If I knew the length of the input and output arrays in advance, I could just write something like this:

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中的数组一些内置的方式，像其他一些语言有？

But how can I do this if I don't know the lengths yet? I assume I would have to use a loop of some kind, but I'm not sure how to write one. Or is there some built-in way to repeat an array in Java, like some other languages have?

推荐答案

这实现比这里显示的其他更清洁，更快速。

This implementation is much cleaner and faster than the others shown here.

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 是本机调用。因此，这是非常快的，但它并不意味着它是最快的方法。

Theory

System.arraycopy is a native call. Therefore it is very fast but it doesn't mean it is the fastest way.

每一个其他的解决办法copys通过元素的数组元素。我的解决方案copys更大的块。每次迭代复制数组中的现有元素，这意味着循环将最多运行的 LOG2（N）倍。

Every other solution copys the array element by element. My solution copys larger blocks. Every iteration duplicates the existing elements in the array which means the loop will run at most log2(n) times.

下面是我的标杆code重现的结果：

Here is my benchmark code to reproduce the results:

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

修改

我改写了这个问题，并与更多的precise基准回答它，因为它建议。
创建长度为N个新阵列和重复给定阵列

这篇关于重复一个数组元素的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！