Hallo, ich habe ein Problem beim Auslesen von Objekte (hier Objekt LL) aus einer LinkedList.
Das Problem liegt in der Methode "Verzweigen" der Klasse "LLProblem":
Ich stelle zwei Objekte LL in die LinkedList llliste ein. Jedes Objekt LL enthält eine Matrix: das erste Objekt, das ich einstelle, eine Matrix mit Inhalt "A", das zweite Objekt enthält eine andere Matrix nämlich mit dem Inhalt "B". Danach lese ich die LinkedList llliste wieder aus, zweimal mit dem
removeLast-command. Ich erhalte aber immer nur die zuletzt eingestelle Matrix mit dem Inhalt "B",
aber nie wieder die zuerst eingestellte Matrix mit dem Inhalt "A".
Ich habe den Code aus einer größeren Programmstruktur herausgebrochen, um den
Fokus auf das Problem zu lenken. Die Struktur muss schon so bleiben und die Objekte LL und VL
sind mit wesentlich mehr Daten angereichert.
Ich bitte um Hilfe und bedanke mich im Voaus.
Das Problem liegt in der Methode "Verzweigen" der Klasse "LLProblem":
Ich stelle zwei Objekte LL in die LinkedList llliste ein. Jedes Objekt LL enthält eine Matrix: das erste Objekt, das ich einstelle, eine Matrix mit Inhalt "A", das zweite Objekt enthält eine andere Matrix nämlich mit dem Inhalt "B". Danach lese ich die LinkedList llliste wieder aus, zweimal mit dem
removeLast-command. Ich erhalte aber immer nur die zuletzt eingestelle Matrix mit dem Inhalt "B",
aber nie wieder die zuerst eingestellte Matrix mit dem Inhalt "A".
Ich habe den Code aus einer größeren Programmstruktur herausgebrochen, um den
Fokus auf das Problem zu lenken. Die Struktur muss schon so bleiben und die Objekte LL und VL
sind mit wesentlich mehr Daten angereichert.
Ich bitte um Hilfe und bedanke mich im Voaus.
Java:
import java.util.Collections;
import java.util.LinkedList;
public class LLProblemMain
{
public static LinkedList<VL> vlliste = new LinkedList<VL>();
public static LinkedList<LL> llliste = new LinkedList<LL>();
public static void main(String[] args)
{
try { lltest1(); }
catch (ArithmeticException e) { e.printStackTrace(); }
StdOut.println("--------------------------------");
}
public static void lltest(double[][] A) {
int countElements = 0;
int index = 0;
VL vl_temp = new VL(A);
vlliste.add(vl_temp);
vl_temp = null;
countElements = vlliste.size();
System.out.println("countElements " + countElements);
while (vlliste.size() > 0)
{
// gets and remove lastElement
vl_temp = vlliste.removeLast();
// vl_temp = vlliste.remove((vlliste.size() - 1));
// zeigt ausgewählten VL-Objekt
System.out.println("ausgewaehltes VL-Objekt");
vl_temp.showMatrix();
// Verzweigen
StdOut.println("=============================================>>>>>>>> Verzweigen-Aufruf");
LLProblem.Verzweigen(vl_temp);
vl_temp = null;
}
countElements = vlliste.size();
}
// max 1x + 1y + 1z ---> max eingefuehrt in das tableau mit umgekehrten Vorzeichen
public static void lltest1() {
double[][] A = {
{ -1, 1, 0 },
{ 1, 4, 0 },
{ 2, 1, 0 },
{ 3, -4, 0 },
{ 0, 0, 1 },
};
System.out.println("-------------------------- Test1 -----------------------------------------");
lltest(A);
}
}
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import ilp.LL;
public class LLProblem
{
public static void Verzweigen (VL vl) {
int countElements = 0;
double Atemp [] [];
double[][] a; // erweitertes Tableaux
int M; // number of constraints
int N; // number of original variables
LL ll_links = new LL();
LL ll_rechts = new LL();
LL ll_temp = new LL();
Atemp = vl.getA_Matrix();
a = new double[Atemp.length] [Atemp[0].length];
for (int i = 0; i < a.length; i++)
for (int j = 0; j < a[i].length; j++)
a[i][j] = Atemp [i][j];
//
System.out.println("\t-------> erstes Objeckt in die ll-Liste <---------");
ll_links = null;
ll_links = new LL(a);
LLProblemMain.llliste.add(ll_links);
System.out.println("ll_links:");
ll_links.showMatrix();
System.out.println("\t");
System.out.println("\t-------> zweites Objekt in die ll-Liste <---------");
for (int i = 0; i < a.length; i++)
for (int j = 0; j < a[i].length; j++)
a[i][j] = 222.0;
ll_rechts = null;
ll_rechts = new LL(a);
LLProblemMain.llliste.add(ll_rechts);
System.out.println("ll_rechts:");
ll_links.showMatrix();
System.out.println("LL-Listen-Groesse = " + LLProblemMain.llliste.size());
countElements = VILPMain.bilpliste.size();
StdOut.println(VILPMain.bilpliste);
System.out.println("countElements " + countElements);
while (LLProblemMain.llliste.size() > 0)
{
// Block Auswahl des letzten LL-Objktes aus der ll-Liste?
System.out.println(" ------------> Auswahl des letzten LL-Objktes aus der ll-Liste und entfernen <------- ");
if ((LLProblemMain.llliste.size()) == 2) {
System.out.println("------------> da erwarte ich die Matrix mit den 222er Elementen <------- ");
} else {
System.out.println("------------> und jetzt erwarte ich die erste Matrix mit den nicht-222er Elementen <------- ");
System.out.println("------------> es kommt aber wieder die mit den 222er Elementen <------- ");
}
// gets and remove lastElement
//
ll_temp = null;
System.out.println("vor ll-Liste-Remove: " + LLProblemMain.llliste.size());
System.out.println("Adressen der ll-Liste: " + LLProblemMain.llliste);
ll_temp = LLProblemMain.llliste.removeLast();
// ll_temp = LLProblemMain.llliste.remove((LLProblemMain.llliste.size() - 1));
ll_temp.showMatrix();
System.out.println("nach LL-Liste-Remove: " + LLProblemMain.llliste.size());
System.out.println("Adressen der ll-Liste: " + LLProblemMain.llliste);
/** Atemp = ll_temp.getA_Matrix();
for (int i = 0; i < Atemp.length; i++) {
for (int j = 0; j < Atemp[i].length; j++) {
System.out.print(Atemp[i][j] + " ");
}
System.out.println();
} **/
countElements = LLProblemMain.llliste.size(); // muss max 1 sein
} // end While
countElements = LLProblemMain.llliste.size(); // muss hier null sein
StdOut.println("vorzeitiges Ende - gewollter Abbruch --- Objekte in der LL-Liste = " + countElements);
System.exit(0);
} // end Branch
} // End Branching
public class VL {
double[][] A; // Koeffizienten
// Default Konstruktor
VL() {
}
// Konstruktor 1
VL(double[][] A) {
this.A = A;
}
public void setA_Matrix(double[][] A) {
this.A = A;
}
public double[][] getA_Matrix() {
return A;
}
// print tableaux
public void showMatrix() {
for (int i = 0; i < A.length; i++) {
for (int j = 0; j < A[i].length; j++) {
System.out.print(A[i][j] + " ");
}
System.out.println();
}
}
}
public class LL {
double[][] A; // Koeffizienten
// Default Konstruktor
LL() {
}
// Konstruktor 1
LL(double[][] A) {
this.A = A;
}
public void setA_Matrix(double[][] A) {
this.A = A;
}
public double[][] getA_Matrix() {
return A;
}
// print tableaux
public void showMatrix() {
for (int i = 0; i < A.length; i++) {
for (int j = 0; j < A[i].length; j++) {
System.out.print(A[i][j] + " ");
}
System.out.println();
}
}
}
