Merge 2 ArrayLists basierend auf einer gemeinsamen Variablen

Question

Ich habe zwei separate ArrayLists. Zum Beispiel:

array1 = [[1 2 3 4 5 6]] 
array2 = [[3 7 8 9 10 11 16]] 

möchte ich wie unter einem Arraylist haben:

arrayResult = [[1 2 3 7 8 9 10 11 16]] 

Es gibt eine gegenseitige Variable auf zwei Arraylisten und ich möchte den ersten Teil des array1 haben + zweiten Teil array2 in eine neue Arraylist.

Answer 1

Gerade Schleife über die ersten List und prüfen den Wert in jedem Index der ersten List die Existenz in den zweiten List. Wenn der Wert nicht vorhanden ist, fügen Sie den ersten Wert List hinzu, wenn dies der Fall ist, kopieren Sie die restlichen Werte von der zweiten List.

List<Integer> l1 = Arrays.asList(1,2,3,4,5,6); 
List<Integer> l2 = Arrays.asList(3,7,8,9,10,11,16); 
List<Integer> l3 = new ArrayList<Integer>();//joined List 
for (int i = 0; i < l1.size(); i++){ 
    int index = l2.indexOf(l1.get(i)); 
    if (index == -1){ 
     l3.add(l1.get(i)); 
    }else{ 
     for (int j = index; j < l2.size(); j++){ 
      l3.add(l2.get(j)); 
     } 
     break; 
    } 
} 

Answer 2

Es ist Merge Sort Problem. Versuchen Sie, den Merge-Sortieralgorithmus anzuwenden. Prüfen Sie dies für mehr Klarheit und Code-Snap: Merge Sort

Else versuchen Sie dies:

List<Integer> list1 = Arrays.asList(array1); 

List<Integer> list2 = Arrays.asList(array2); 

set.addAll(list1); 
set.addAll(list2); 

yourResult = set.toArray(); 

Answer 3

Sie können etwas tun:

List<Integer> a1 = Arrays.asList(1, 2, 3, 4, 5, 6); 
List<Integer> a2 = Arrays.asList(3, 7, 8, 9, 10, 11, 16); 
ArrayList<Integer> merged = new ArrayList<>(); 
for(Integer val: a1){ 
    if(val == a2.get(0)){ 
     for(Integer val2: a2){ 
      merged.add(val2); 
     } 
     break; 
    } 
    merged.add(val); 
} 
System.out.println(merged); 

Sie müssen sicherstellen, dass die zweite Liste enthält mindestens einen Wert und Sie müssen die Listen sortieren, wenn sie nicht bereits sortiert sind.

Answer 4

Schleife durch die Elemente von Array1 und jedes Mal überprüfen, ob sie in Array2 sind. Wenn nicht, füge sie hinzu und fahre mit der Schleife von array1 fort. Wenn es in Array2 vorhanden ist, stoppen Sie looping array1 und starten Sie looping array2 bei diesem Index.

Dies sollte helfen ..

Boolean found = false; 
integer foundInd = 0; 
Boolean useArray1 = false; 
if (array1.length >= array2.length) 
    useArray1 = true 

For (integer cnt1 = 0; cnt1 < array1.length; cnt1 ++) 
{ 
    For (integer cnt2 = 0; cnt2 < array2.length; cnt2 ++) 
    { 
     if (array1[cnt1] == array2[cnt2]) 
     { 
      found = true; 
      foundInd = cnt2; 
     } 
    } 
    if (useArray1 == false) 
     Array2[cnt] = Array1[cnt]; 
    if (found == true) 
     break; 
} 

For (integer cnt2 = foundInd; cnt2 < array2.length; cnt2 ++) 
{ 
    if (useArray1 == true) 
     useArray1[foundInd + cnt2] = array2[cnt2]; 
} 

Side Note- Anstatt ein neues Array erstellen, die Werte zu speichern, ich entweder array1 oder array2 nur je nach verwendetem auf, die länger war. Es hat bereits die richtige Länge und mindestens die Hälfte seiner Daten ist bereits die richtige Nummer an der richtigen Stelle.

Answer 5

wenn Sie Sammlungen verwenden, dann können Sie beide zusammen Liste erhalten und das gemeinsame Element finden ziemlich viel einfacher ...

Blick auf dieses Beispiel:

public static void main(String[] args) { 
List<Integer> a1 = Arrays.asList(1, 2, 3, 4, 5, 6); 
List<Integer> a2 = Arrays.asList(3, 7, 8, 9, 10, 11, 16); 
List<Integer> common = new ArrayList<>(); 
int commonw; 
// merge both and find common Element.class.. 
// IllegalMonitorStateException must be one 
common.addAll(a1); 
common.retainAll(a2); 
commonw = common.get(0); 
common.clear(); 

// fill the common elements 
for (int i = 0; i < a1.indexOf(commonw); i++) { 
    common.add(a1.get(i)); 
} 
for (int i = a2.indexOf(commonw) + 1; i < a2.size(); i++) { 
    common.add(a2.get(i)); 
} 
System.out.println(common); 
} 

Answer 6

Wenn Sie java8 haben, können Sie versuchen

public List<Integer> merge(List<Integer> first, List<Integer> second) { 
    Integer integerToMergeAt = first.stream().filter(i -> second.indexOf(i) >= 0).findFirst().get(); 
    return Stream.concat(first.stream().limit(first.indexOf(integerToMergeAt)), 
      second.stream().skip(second.indexOf(integerToMergeAt))).collect(Collectors.toList()); 
}