Dodaj ciąg do początku tablicy łańcuchów

Question

Czy jest możliwe dodanie łańcucha do początku tablicy String bez powtarzania całej tablicy.

Answer 1

Jedynym sposobem, aby to zrobić, to zachować bufor pierścieniowy. np. masz licznik, który pamięta, gdzie jest początek, i przenosisz go zamiast przenosić wszystkie wpisy w tablicy. Działa to tylko dlatego, że ponownie definiujesz, co oznacza "start".

Zobacz źródło dla ArrayDeque który ma trzy pola

86  /** 
    87  * The array in which the elements of the deque are stored. 
    88  * The capacity of the deque is the length of this array, which is 
    89  * always a power of two. The array is never allowed to become 
    90  * full, except transiently within an addX method where it is 
    91  * resized (see doubleCapacity) immediately upon becoming full, 
    92  * thus avoiding head and tail wrapping around to equal each 
    93  * other. We also guarantee that all array cells not holding 
    94  * deque elements are always null. 
    95  */ 
    96  private transient E[] elements; 
    97 
    98  /** 
    99  * The index of the element at the head of the deque (which is the 
    100  * element that would be removed by remove() or pop()); or an 
    101  * arbitrary number equal to tail if the deque is empty. 
    102  */ 
    103  private transient int head; 
    104 
    105  /** 
    106  * The index at which the next element would be added to the tail 
    107  * of the deque (via addLast(E), add(E), or push(E)). 
    108  */ 
    109  private transient int tail; 

więc dodanie do początku działa tak

224  public void addFirst(E e) { 
    225   if (e == null) 
    226    throw new NullPointerException(); 
    227   elements[head = (head - 1) & (elements.length - 1)] = e; 
    228   if (head == tail) 
    229    doubleCapacity(); 
    230  } 


    312  /** 
    313  * @throws NoSuchElementException {@inheritDoc} 
    314  */ 
    315  public E getFirst() { 
    316   E x = elements[head]; 
    317   if (x == null) 
    318    throw new NoSuchElementException(); 
    319   return x; 
    320  } 

Uwaga: przesuwa głowicę zamiast przesuwania wszystkich elementów w dół tablicy .

Answer 2

Nie możesz ... Musisz przesunąć wszystkie ciągi nadchodzące po nim, aby pomieścić nowy ciąg. Jeśli bezpośrednio dodasz go do 0-tego indeksu, stracisz poprzedni element tam:

Answer 3

W tym celu powinieneś użyć List.

A jeśli chcesz korzystać z tablic szczególnie wewnętrzny, pójść na ArrayList

Answer 4

spróbować

String[] a = {"1", "2"}; 
    String[] a2 = new String[a.length + 1]; 
    a2[0] = "0"; 
    System.arraycopy(a, 0, a2, 1, a.length); 

Answer 5

String[] myArray= {"hi","hi2"}; 
List<String> temp = new ArrayList<String>(Arrays.asList(prova)); 
temp.add(0, "h3"); 
myArray = temp.toArray(new String[temp.size()]); 

Answer 6

Najlepszy mogę zarządzać ...

public static void main(String[] args) { 
     String[] s = new String[] { "a", "b", "c" }; 
     System.out.println(Arrays.toString(prepend(s,"d"))); 
} 

public static String[] prepend(String[] a, String el) { 
     String[] c = new String[a.length+1]; 
     c[0] = el; 
     System.arraycopy(a, 0, c, 1, a.length); 
     return c; 
} 

Answer 7

można zrobić kilka rzeczy jak poniżej

public class Test { 

public static String[] addFirst(String s[], String e) { 
    String[] temp = new String[s.length + 1]; 
    temp[0] = e; 
    System.arraycopy(s, 0, temp, 1, s.length); 
    return temp; 
} 

public static void main(String[] args) { 
    String[] s = { "b", "c" }; 
    s = addFirst(s, "a"); 
    System.out.println(Arrays.toString(s)); 
} 
} 

Answer 8

ta jest skorygowana wersja rozwiązania proponowane autor: @matteosilv:

String[] myArray= {"hi","hi2"}; 
List<String> list = new LinkedList<String>(Arrays.asList(myArray)); 
list.add(0, "h3"); 
myArray = list.toArray(new String[list.size()]); 

Answer 9

Jeśli używasz już Guava można użyć ObjectArrays::concat to zrobić:

String[] args = ...; 
ObjectArrays.concat("prepended", args);