Set<> auslesen

[simon1101]

Hallo,

ich habe folgendes Problem. Ich habe eine Klasse SearchNode in der ich diverse Knoten und Entfernungen speichern kann, die Beziehungen der Knoten und Distanzen werden in der Klasse SearchEdge angelegt:

/**
public class SearchNode extends Node
{
    private int entfernung = 0;
    private SearchEdge vorgaenger;
    
    public SearchNode(String label, int entfernung, SearchEdge vorgaenger) {
        super(label);
        this.entfernung = Integer.MAX_VALUE;
        this.vorgaenger = null;
    }
    
    public int getEntfernung() {
        return entfernung;
    }
    
    public void setEntfernung(int entfernung) {
        this.entfernung = entfernung;
    }
    
    public SearchEdge getVorgaenger() {
        return vorgaenger;
    }
    
    public void setVorgaenger(SearchEdge vorgaenger) {
        this.vorgaenger = vorgaenger;
    }
}

public class SearchEdge extends Edge
{
    private boolean bold;
    private SearchNode start;
    private SearchNode end;
    private int distance;
    
    SearchEdge(SearchNode start, SearchNode end, int distance, boolean bold) {
        super(start, end, distance);
        this.bold = bold;
    }
    
    public boolean getBold() {
        return bold;
    }
    
    public void setBold() {
        bold = true;
    }
    
    public String toString() {
        if(bold == true) {
            return start.getName() + " -- " + end.getName()
				+ " [label=\"" + distance + "\"];" + " [,style=\"" + bold + "\"];";
        }
        else {
            super.toString();
        }
 
    return toString(); 
    }
    
    private void joinsNode(SearchNode node) {
        
        boolean kante = false;
        
        if(node == start || node == end) {
            kante = true;
        } 
        else {
            kante = false;
        }
            
    }
    

    private SearchNode getOtherNode(SearchNode node) {
        SearchNode othernode = start;
        
        if(node != othernode) {
            othernode = end;
        }
        
        return othernode;
    }
}

Die "Hauptklasse" Graph sieht so aus:

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class Graph<T extends Node, S extends Edge> {
	
	/** die Menge der Knoten */
	private final List<T> nodes;
	
	/** die Menge der Kanten */
	private final List<S> edges;
	
	/**
	 * Konstruktor
	 */
	public Graph() {
		this.nodes = new ArrayList<T>();
		this.edges = new ArrayList<S>();
	}
	
	/**
	 * Getter
	 * 
	 * @return die <b>Menge</b> aller bekannten <b>Edge</b>-Objekte, die dem Graphen angeh&ouml;ren. 
	 */
	public List<S> getEdges() {
		return this.edges;
	}
	
	/**
	 * F&uuml;gt ein <b>Edge</b>-Objekt zum Graphen hinzu.
	 * 
	 * @param kante die hinzugefügt werden soll.
	 */
	public void addEdge(final S edge) {
		this.edges.add(edge);
	}
	
	/**
	 * Getter
	 * 
	 * @return die <b>Menge</b> aller bekannten <b>Node</b>-Objekte, die dem Graphen angeh&ouml;ren.
	 */
	public List<T> getNodes() {
		return this.nodes;
	}
	
	/**
	 * F&uuml;gt ein <b>Node</b>-Objekt zum Graphen hinzu.
	 * 
	 * @param kante die hinzugefügt werEdgeden soll.
	 */
	public void addNode(final T node) {
		this.nodes.add(node);
	}
	
	/**
	 * Diese Methode schreibt den gegebenen Graphen inklusive aller Knoten und Kanten
	 * in eine Datei namens out[nummer].dot. Wobei [nummer] um eins erh&ouml;ht wird, falls die
	 * Datei out.dot bereits besteht. 
	 * 
	 * Diese Methode benutzt die toString()-Methode des Graphen, welche den Inhalt der 
	 * zu schreibenden Datei vorbereitet.
	 * 
	 * @return true wenn die Aktion erfolgreich war, ansonsten false.
	 */
	public boolean writeGraph() {
		return writeGraph(this);
	}
	
	/**
	 * @see {@link #writeGraph()}
	 * 
	 * @param Graph  
	 * @return true oder false
	 */
	private static boolean writeGraph(final Graph graph) {
		
		File out = new File(System.getProperty("user.dir")
				+ System.getProperty("file.separator") + "out.dot");
		
		int i = 1;
		
		while (out.exists()) {
			out = new File(System.getProperty("user.dir")
					+ System.getProperty("file.separator") + "out" + i + ".dot");
			i++;
		}
		
		try {
			final FileWriter writer = new FileWriter(out);
			writer.write(graph.toString());
			writer.flush();
			writer.close();
		} catch (final IOException e) {
			return false;
		}
		
		return true;
	}
	
	/**
	 * Diese Methode benutzt die toString()-Methoden der Node- und Edge-Objekte, um 
	 * den Graphen im dot-Format auszugeben. (Voraussetzung daf&uuml;r ist, dass die 
	 * toString()-Methoden der Klasse Node und Edge das richtige Format erzeugen.)
	 * 
	 * @return den Graph als String im dot-Format.
	 */
	public String toString() {
		final StringBuilder result = new StringBuilder();
		
		result.append("graph{");
		result.append("\n");
		
		for (final Edge edge : getEdges()) {
			result.append(edge.toString());
			result.append("\n");
		}
		
		for (final Node node : getNodes()) {
			result.append(node.toString());
			result.append("\n");
		}
		
		result.append("}");
		
		return result.toString();
	}
}

Nun will ich mir in einer Klasse Routenplaner in der Methode SearchNode getMinimalNode ein Set<SearchNode> übergeben lassen und dieses dahingehend auslesen, dass der Knoten mit der kleinsten entfernung zurückgegeben wird.

import java.util.*;

public class Routenplaner
{
    public Graph<SearchNode, SearchEdge> graph;
    private SearchNode startknoten;
    private SearchNode zielknoten;
    HashSet<SearchNode> unbesuchteknoten;
    HashSet<SearchNode> benachbarteknoten;
    
     public Routenplaner(Graph<SearchNode, SearchEdge> graph) {
        this.graph = graph;
    }
   
    public SearchNode getStartKnoten() {
        return startknoten;
    }
    
    public SearchNode getZielKnoten() {
        return zielknoten;
    }
    
    public void setStartKnoten(SearchNode startknoten) {
        this.startknoten = startknoten;
    }
    
    public void setZielKnoten(SearchNode zielknoten) {
        this.zielknoten = zielknoten;
    }

    [B]public SearchNode getMinimalNode(Set<SearchNode> kleinsteentfernung) {
        
	}[/B]
    
    public SearchNode getNextEdges(SearchNode ausgangsknoten) {
        set<SearchEdge> kanten = null;
        
        return kanten;
    }
}

Ich habe es schon mit Iteratoren und Umwandlung des Sets in ein Array versucht, stehe aber voll auf dem Schlauch, wie ich dem Set die benötigte Information entlocken kann???:L Hoffe es kann mir jemand sagen, wie das funktioniert.

Viele Grüße
Simon

 

[bygones]

Collections.min(kleinsteentfernung);

wobei dein SearchNode dann das Comparable Interface implementieren muss so dass die kleinste Entfernung genommen wird.

oder Collections.min(kleinsteentfernung, new Comparator...) einen Comparator geben der dann nur in diesem Fall dein Set sortiert

 

[simon1101]

Danke erstmal.

Ich habe beides Probiert, bekomme es aber nicht zum Laufen? Woher weiß die Collection enn, dass sie mir den Wert der kleinsten Entfernung des Sets zurückgeben soll?

Gruß
Simon

 

[SlaterB]

durch den übergebenen Comparator, siehe zum Grundverständnis
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 12 Datenstrukturen und Algorithmen

 

[simon1101]

Hallo,

ich habe es jetzt mal so versucht:

public SearchNode getMinimalNode(Set<SearchNode> kleinsteentfernung) {
        SearchNode kurzer = null;
        
        Collections.min(kleinsteentfernung, ???);
        
        return kurzer;
	}

Ich will ja den kleinsten Knoten zurückgegeben bekommen.
An der Stelle mit den Fragezeichen soll ich ja den Comparator initialisieren, aber wie mache ich das konkret. Stehe gerade voll auf dem Schlauch. Kann mir jemand anhand der geposteten Methode einen konkreten Comperator reinbasteln, so dass das Ding läuft? Wäre super.

Gruß,
Simon

 

[simon1101]

Habe es jetzt soweit:

Danke, Simon

 

[SlaterB]

der Rückgabewert der Methode ist doch unverkennbar SearchNode,
was willst du mehr?