# Zusammenfügen von zwei Arraylisten



## butterfly84 (30. Mrz 2011)

Hallo,

ich würde gerne zwei ArrayLists so kombinieren, dass Zeile 1 von ArrayList1 gleich hinter Zeile 1 von ArrayList2 kommt. Also nicht untereinander sondern nebeneinander, weil ich diese Kombination später vergleichen will. Ist so etwas möglich?

Mfg


----------



## XHelp (30. Mrz 2011)

"nebeneinander" gibts nicht. Du könntest aber sowas wie 
	
	
	
	





```
List<List>
```
 machen, dann kannst du in einer Position mehrere Werte abspeichern. Oder eben eine eigene Klasse 
	
	
	
	





```
Eintrag
```
 machen.


----------



## nrg (30. Mrz 2011)

könntest sie schon so verbinden:

list1 wert1
list1 wert2
list1 wert3

list2 wert1
list2 wert2
list2 wert3

wird zu list3 mit:

list1 wert1
list2 wert1
list1 wert2
list2 wert2
list1 wert3
list2 wert3

glaube aber dein vorhaben ist einfacher/besser realisierbar


----------



## butterfly84 (30. Mrz 2011)

Vielen Dank für die schnelle Antwort, kannst Du vielleicht ein kleines Beispiel geben? Bin absolute Anfängerin und weiß nicht, wie du das meinst mit  List<List> .


----------



## nrg (30. Mrz 2011)

das ist halt eine liste, die listen enhält. quasi eine 2D-Liste aber ich finde sowas sehr hässlich und bin auch der Meinung, dass man sowas nie bzw. sehr selten braucht.
was hast du denn allgemein vor?


----------



## Gast2 (30. Mrz 2011)

```
import java.util.ArrayList;
import java.util.List;
public class Test {
	public static void main(String[] argv) {

		List<String> list1 = new ArrayList<String>();
		List<String> list2 = new ArrayList<String>();

		List[] listen = new List[] { list1, list2 }; // oder auch eine Liste von
														// Listen, List<List>
														// halt

		list1.add("123");
		list1.add("3453");
		list1.add("fdsf");
		list1.add("456");

		list2.add("123");
		list2.add("asd");
		list2.add("sdfsf");
		list2.add("456");

		for (int i = 0; i < list1.size(); i++) {
			System.out.println(listen[0].get(i) + "\t|\t" + listen[1].get(i));
		}
	}
}
```


```
OUTPOUT:
123	|	123
3453	|	asd
fdsf	|	sdfsf
456	|	456
```
so zum Beispiel. Ob du jetzt ein Array von Listen nimmst, oder aber eine Liste von Listen ist da erstmal egal. Aber es gibt doch bessere Wege soetwas zu modelieren. Was möchtest du denn genau machen?


----------



## Sempah (30. Mrz 2011)

oder wie Xhelp vorgeschlagen hat:


```
import java.util.ArrayList;
import java.util.List;


public class ListTest {

	public static void main(String[] args) {
		
		List<Eintrag> list = new ArrayList<Eintrag>();
		list.add(new Eintrag("abc", "def"));
		list.add(new Eintrag("abc", "de"));
		list.add(new Eintrag("abc", "defg"));
		
		for (Eintrag eintrag : list)
			System.out.println(eintrag.vergleiche());
	}
}

class Eintrag {
	private String eintrag1;
	private String eintrag2;
	
	public Eintrag(String eintrag1, String eintrag2) {
		this.eintrag1 = eintrag1;
		this.eintrag2 = eintrag2;
	}
	
	public boolean vergleiche() {
		return eintrag1.length() >= eintrag2.length();
	}
	
}
```


----------



## Volvagia (30. Mrz 2011)

Du könntest nach dem Füllen auch die Werte von List 2 in List 1 an jede 2. Stelle füllen. Wäre aber sicher nicht das schnellste, Linked würde das wohl sehr viel schneller hinkriegen. Aber soetwas wäre wohl noch sehr viel schneller und schöner:


```
public class ColMerger<T>
{
	private int colsPointer;
	private List<Collection<T>> colsList;

	public ColMerger()
	{
		super();
		colsPointer = 0;
		colsList = new ArrayList<Collection<T>>();
	}
	public void addCollection(Collection<T> col)
	{
		colsList.add(col);
	}
	public void add(T value)
	{
		int colsCount = colsList.size();
		if(colsCount == 0)
			throw new IndexOutOfBoundsException();
		
		colsList.get(colsPointer).add(value());
		incrPointer();
	}
	private void incrPointer()
	{
		int colsCount = colsList.size();
		colsPointer = (colsPointer != (colsCount - 1)) ? colsPointer + 1 : 0;
	}
	public T get(int i)
	{
		int colsCount = colsList.size();
		int j = i%colsCount;
		return(colsList.get(j).add(i / colsSize));
	}
}
```

(VHidT.)


Edit: Ups, war ich laaaaaaaaaaaaaahm.


----------



## butterfly84 (30. Mrz 2011)

Also ich habe eine Liste mit Polylines (Kanten) und eine Liste mit Rechtecken (Knoten), wo eine Überschneidung stattfindet. Jedoch tauchen hier auch die Polylines auf, bei deinen keine wirkliche Überschneidungen existieren, also die Kante geht nicht durch den Knoten, sondern berührt halt nur den Rand.

Eine Überschneidung ist ja nur vorhanden wenn eine Polyline ein Rechteck zweimal durchquert. Also dachte ich mir ich verbinde diese beiden Listen und die, die doppelt sind zeigen die Überschneidung. Das kann man bestimmt eleganter lösen, aber wie gesagt bin noch unerfahren.


----------



## Volvagia (30. Mrz 2011)

Wenn ich das jetzt richtig verstanden habe, schau dir mal Rectangle#intersects(Rectangle) an. Damit kannst du Überschneidungen einfach prüfen, und musst dafür keine Listeinträge kontrollieren. ^^ (Was der Verständlichkeit sicher auch zu Gute kommt.)


----------



## butterfly84 (30. Mrz 2011)

Ich muss die Überprüfung für UML-Klassendiagramme machen, die in XFig gezeichnet werden. D.h. ich hab ne Fig-Datei aus der ich alle Infos hole, deshalb die Listen.


----------



## LP_SE (30. Mrz 2011)

Ich würde einfach eine dritte Liste nehmen:

list 3 wert1 => list1 wert1
list 3 wert2 => list2 wert1
list 3 wert3 => list1 wert2
list 3 wert4 => list2 wert2
list 3 wert5 => list1 wert3
list 3 wert6 => list2 wert3

und dann die Liste übergeben oder auf list 1 übertragen ...


----------

