重复数组的元素

Question

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

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

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?

Answer 1

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;
}

Theory

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

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.

Profiling reports

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;
  }
}

Results

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

EDIT

I rephrased this question and answered it with more precise benchmarks as it was suggested. Fastest way to create new array with length N and fill it by repeating a given array

Answer 2

You can try like this

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

I am assuming you know the size of the input, (eg you know that there are six elements in the input above. Let us name it iSize . Alternatively, you could find this using arr.length where arr is the input array.)

This might be a cleaner solution for the above.

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;

Answer 5

A very clean and fast implementation is like this with a little expanded and much readable form:

public static String[] nLenArry(String[] inpArry, int n) {
    String[] output = new String[n];
    int length = inpArry.length;
    int position = 0;

    // Copy Iterations
    while (position < n-length) {
        System.arraycopy(inpArry, 0, output, position, length);
        position += length;
    }

    // Copy the last part
    System.arraycopy(inpArry, 0, output, position, n % length);

    return output;
}

---

Same code in more compact form:

public static String[] nLenArry(String[] inpArry, int n) {
    String[] output = new String[n];
    int position = 0;
    while (position < n - inpArry.length) {
        System.arraycopy(inpArry, 0, output, position, inpArry.length);
        position+=inpArry.length;
    }
    System.arraycopy(inpArry, 0, output, position, n % inpArry.length);
    return output;
}

---

Also, if you want to save some space, you can use this clever little trick and try implementing it as a new class:

import java.util.AbstractList;

public class RepeatedArrayList<E> extends AbstractList<E> {
    private E[] arry;
    private int size;

    public RepeatedArrayList(E[] inpArry, int size) {
        this.arry = inpArry;
        this.size = size;
    }

    public E get(int position) {
        if (position >= 0 && position < size)
            return arry[position % arry.length];
        else throw new IndexOutOfBoundsException(
            "index " + position + " is negative or >= " + size
        );
    }

    public int size() {
        return this.size;
    }
}

After this all you need to do is the following code in your other classes

repeatedArry cst = new RepeatedArrayList(arr, 10000);

and

//use
cst.get(x);

//instead of 
arr[x];

Answer 6

This should help:

static int[] function(int[] array, int n)
{
    if(array == null)
    {
        throw new NullPointerException();
    }

    if(n < 0)
    {
        throw new RuntimeException();
    }

    int[] newArray = new int[n];
    int arraysize = array.length;
    int i = 0 , j = 0;

    int loop = n -  (n % arraysize);

    while(i < loop)
    {
        for(j = 0 ; j < arraysize; j++, i++)
        {
            newArray[i] = array[j];
        }
    }

    j = 0;
    while(i < n)
    {
        newArray[i++] = array[j++]; 
    }

    return newArray;
}

Answer 7

same answer in another didactic form, without specific function on array

// INPUT
int[] input={1,2,3,4,5,6}; // new int[6];
int n=10;

// original size: you get it her
int size=input.length;

// final size : original size X repetition
int final_size=size*n;

int[] final_array=new int[final_size];

// we just copy in a loop, with % (modulus function)
for (int pos=0;pos<final_size;pos++)
    final_array[pos]=input[pos%size];

// OUTPUT : that's it
// => final_array

Answer 8

Assume that your n is known and your array is a primitive type and not an object (eg List)

int fLen = input.length * n;
int[] outputArray = new int[fLen];
for ( int i = 0; i < n; i++) {
    System.arraycopy(input, 0, outputArray, i * input.length, input.length);
}

fLen is the final length of your output array

Assume you don't know n

int[] outputArray2 = new int[input.length]; // at least can contain input once
System.arraycopy(input, 0, outputArray2, 0, input.length);
System.out.print("More? > (Y/N) ");
String ans = System.console().readLine();
while ( ans.equals("Y") || ans.equals("y") ) {
    int[] tmp = new int[outputArray2.length + input.length];
    System.arraycopy(outputArray2, 0, tmp, 0, outputArray2.length);
    System.arraycopy(input, 0, tmp, outputArray2.length, input.length);
    outputArray2 = tmp;
    System.out.print("More? > (Y/N) ");
    ans = System.console().readLine();
}

for ( int i = 0; i < outputArray2.length;i++)
    System.out.println("["+i+"] => " + outputArray2[i]);

Then you can use the outputArray as you want.

Answer 9

I saw that others have implemented similar solutions as I (using lists, but not ArrayLists), but here is how I would approach the problem. My Java is a little rusty, so I'm sure there are faster ways to do this, but here we go:

   char[] array = {'a','b','c','d','e','f'};
    ArrayList<Character> arrList = new ArrayList<Character>();

    System.out.println("How many elements in the new array?");
    Scanner kb = new Scanner(System.in);
    int length = kb.nextInt();

    for(int i = 0; i < length; i++){
        arrList.add(array[i%(array.length)]);
    }

    char[] finalArray = new char[length];
    for(int i = 0; i < length; i++){
        finalArray[i] = arrList.get(i);
    }

    System.out.println(finalArray);

Basically what I am doing is getting input as to how long the resultant array should be and then appending the elements of the original array to an ArrayList that many times. The data types could be changed to work for any other data type, but since the question used chars in the array that's how I did mine. Also, if you were okay with ending with an ArrayList instead of an array, you could drop the last for() loop.

After running this, my console displays:

How many elements in the new array?
10
abcdefabcd

If you don't know the input array size before the program runs, I would first implement it as an ArrayList so that it can be dynamically grown. Then, once the user stops entering new values for the input array, it could be converted to an array (unnecessary unless you NEED the array data type instead of an ArrayList) or it can be used as is. After that you can use the same idea as above to create the output array. Code example as follows:

   ArrayList<Character> inputArr = new ArrayList<Character>();
    ArrayList<Character> arrList = new ArrayList<Character>();
    Scanner kb = new Scanner(System.in);

    System.out.println("How many elements in the new array?");
    int length = kb.nextInt();

    System.out.print("Enter a value? (y/n): ");

    while(kb.next().equals("y")){
        System.out.print("Enter the value: ");
        inputArr.add(kb.next().charAt(0)); //in case the user inputs more than a char, only accepts the first char of the line
        System.out.print("Enter another value? (y/n): ");
    }
    System.out.println(inputArr);

    for(int i = 0; i < length; i++){
        arrList.add(inputArr.get(i%(inputArr.size())));
    }

    System.out.println(arrList);