Как распечатать vaule с публичным void testDistanceBetween_AD

Question

Я представляю свой исходный код для этой проблемы, потому что мне стало неприятно, что я не могу сделать простую распечатку системы в классе TrainsTest. как вы видите, у меня возникла проблема с печатью vaule в классе TrainsTest для следующих методов;

общественная пустота testDistanceBetween_ABC общественный недействительными testDistanceBetween_AD общественность недействительного testDistanceBetween_ADC общественных недействительный testDistanceBetween_AEBCD общественность недействительный testDistanceBetween_AED общественных недействительным numRoutesWithin_CC30 общественных недействительного testEquals

любой помощь будет оценена по достоинству! Спасибо!

Ниже мой класс узел

---

package com.utsavized.trains; 

public class Node { 
public String name; 
public boolean visited; 

public Node(String name) { 
    this.name = name; 
    this.visited = false; 
} 

@Override 
public boolean equals(Object b) { 
    if (b == null || b.getClass() != getClass()) { 
     return false; 
    } 
    Node bx = (Node)b; 
    return this.name.equals(bx.name); 
} 

@Override 
public int hashCode() { 
    if(this.name == null) return 0; 
    return this.name.hashCode(); 
} 
} 

Ниже мой край класс

---

public class Edge { 

public Node origin; 

public Node destination; 

public int weight; 

public Edge next; 

public Edge(Node origin, Node destination, int weight) { 
    this.origin   = origin; 
    this.destination = destination; 
    this.weight   = weight; 
    this.next  = null; 
} 

public Edge next(Edge edge) { 
    this.next = edge; 
    return this; 
} 
} 

Ниже мои маршруты класса

---

import java.util.ArrayList; 
import java.util.Hashtable; 

public class Routes { 
public Hashtable<Node, Edge> routeTable; 

public Routes() { 
    this.routeTable = new Hashtable<Node, Edge>(); 
} 


public int distanceBetween(ArrayList<Node> cities) throws Exception { 
    /*There is no distance between 
    * no cities or 1 city*/ 
    if(cities.size() < 2) 
     return 0; 
    int distance, depth, i; 
    distance = depth = i = 0; 

    /* For each city in the list, 
    * we check if entry exists in our 
    * hash table. 
    */ 
    while(i < cities.size() - 1) { 
     if(this.routeTable.containsKey(cities.get(i))) { 
      Edge route = this.routeTable.get(cities.get(i)); 
      /*If key exists, we check if route from key to next 
      * city exists. We add the distance, and maintain a 
      * depth count 
      */ 
      while(route != null) { 
       if(route.destination.equals(cities.get(i + 1))) { 
        distance += route.weight; 
        depth++; 
        break; 
       } 
       route = route.next; 
      } 
     } 
     else 
      throw new Exception("NO SUCH ROUTE"); 
     i++; 
    } 
    /*If edge depth is not equal to vertex - 1, 
    * then it is safe to assume that one ore more 
    * routes do not exist 
    */ 
    if(depth != cities.size() - 1) 
     throw new Exception("NO SUCH ROUTE"); 

    return distance; 
} 

/* 
* Number of stops; 
* Wrapper for recursive function 
*/ 
public int numStops(Node start, Node end, int maxStops) throws Exception{ 
    //Wrapper to maintain depth of traversal 
    return findRoutes(start, end, 0, maxStops); 
} 

/* 
* Finds number of stops from start to end, 
* with a maximum of maxStops and the depth 
* limit. 
*/ 
private int findRoutes(Node start, Node end, int depth, int maxStops) throws Exception{ 
    int routes = 0; 
    //Check if start and end nodes exists in route table 
    if(this.routeTable.containsKey(start) && this.routeTable.containsKey(end)) { 
     /* 
     * If start node exists then traverse all possible 
     * routes and for each, check if it is destination 
     * If destination, and number of stops within 
     * allowed limits, count it as possible route. 
     */ 
     depth++; 
     if(depth > maxStops)  //Check if depth level is within  limits 
      return 0; 
     start.visited = true;  //Mark start node as visited 
     Edge edge = this.routeTable.get(start); 
     while(edge != null) { 
      /* If destination matches, we increment route 
      * count, then continue to next node at same depth 
      */ 
      if(edge.destination.equals(end)) { 
       routes++; 
       edge = edge.next; 
       continue; 
      } 
      /* If destination does not match, and 
      * destination node has not yet been visited, 
      * we recursively traverse destination node 
      */ 
      else if(!edge.destination.visited) { 
       routes += findRoutes(edge.destination, end, depth,              maxStops); 
       depth--; 
      } 
      edge = edge.next; 
     } 
    } 
    else 
     throw new Exception("NO SUCH ROUTE"); 

    /* 
    * Before exiting this recursive stack level, 
    * we mark the start node as visited. 
    */ 
    start.visited = false; 
    return routes; 
} 

/* 
* Shortest route; 
* Wrapper for recursive function 
*/ 
public int shortestRoute(Node start, Node end) throws Exception { 
    //Wrapper to maintain weight 
    return findShortestRoute(start, end, 0, 0); 

} 

/* 
* Finds the shortest route between two nodes 
*/ 
private int findShortestRoute(Node start, Node end, int weight, int shortestRoute) throws Exception{ 
    //Check if start and end nodes exists in route table 
    if(this.routeTable.containsKey(start) && this.routeTable.containsKey(end)) { 
     /* 
     * If start node exists then traverse all possible 
     * routes and for each, check if it is destination 
     */ 
     start.visited = true;  //Mark start node as visited 
     Edge edge = this.routeTable.get(start); 
     while(edge != null) { 
      //If node not already visited, or is the destination, increment weight 
      if(edge.destination == end || !edge.destination.visited) 
       weight += edge.weight; 

      /* If destination matches, we compare 
      * weight of this route to shortest route 
      * so far, and make appropriate switch 
      */ 
      if(edge.destination.equals(end)) { 
       if(shortestRoute == 0 || weight < shortestRoute) 
        shortestRoute = weight; 
       start.visited = false; 
       return shortestRoute;   //Unvisit node and return shortest route 
      } 
      /* If destination does not match, and 
      * destination node has not yet been visited, 
      * we recursively traverse destination node 
      */ 
      else if(!edge.destination.visited) { 
       shortestRoute = findShortestRoute(edge.destination, end, weight, shortestRoute); 
       //Decrement weight as we backtrack 
       weight -= edge.weight; 
      } 
      edge = edge.next; 
     } 
    } 
    else 
     throw new Exception("NO SUCH ROUTE"); 

    /* 
    * Before exiting this recursive stack level, 
    * we mark the start node as visited. 
    */ 
    start.visited = false; 
    return shortestRoute; 

} 

/* 
* Shortest route; 
* Wrapper for recursive function 
*/ 
public int numRoutesWithin(Node start, Node end, int maxDistance) throws Exception { 
    //Wrapper to maintain weight 
    return findnumRoutesWithin(start, end, 0, maxDistance); 
} 

/* 
* Finds the shortest route between two nodes 
*/ 
private int findnumRoutesWithin(Node start, Node end, int weight, int maxDistance) throws Exception{ 
    int routes = 0; 
    //Check if start and end nodes exists in route table 
    if(this.routeTable.containsKey(start) && this.routeTable.containsKey(end)) { 
     /* 
     * If start node exists then traverse all possible 
     * routes and for each, check if it is destination 
     */ 
     Edge edge = this.routeTable.get(start); 
     while(edge != null) { 
      weight += edge.weight; 
      /* If distance is under max, keep traversing 
      * even if match is found until distance is > max 
      */ 
      if(weight <= maxDistance) { 
       if(edge.destination.equals(end)) { 
        routes++; 
        routes += findnumRoutesWithin(edge.destination, end, weight, maxDistance); 
        edge = edge.next; 
        continue; 
       } 
       else { 
        routes += findnumRoutesWithin(edge.destination, end, weight, maxDistance); 
        weight -= edge.weight; //Decrement weight as we backtrack 
       } 
      } 
      else 
       weight -= edge.weight; 

      edge = edge.next; 
     } 
    } 
    else 
     throw new Exception("NO SUCH ROUTE"); 

    return routes; 

} 

}

Ниже мой TrainsTest класс

---

package com.utsavized.trains; 



    import static org.junit.Assert.*; 

    import java.util.ArrayList; 
    import java.util.stream.Collectors; 

    import org.junit.BeforeClass; 
    import org.junit.Test; 

    public class TrainsTest { 
static Routes graph; 
static Node a, b, c, d, e; 

@BeforeClass 
public static void setUpBeforeClass() throws Exception { 
    graph = new Routes(); //Build graph 

    a = new Node("A"); 
    b = new Node("B"); 
    c = new Node("C"); 
    d = new Node("D"); 
    e = new Node("E"); 

    /*Input given in programming challenge 
    Graph: AB5, BC4, CD8, DC8, DE6, AD5, CE2, EB3, AE7*/ 
    graph.routeTable.put(a, new Edge(a, b, 5).next(new Edge(a, d, 5).next(new Edge(a, e, 7)))); 
    graph.routeTable.put(b, new Edge(b, c, 4)); 
    graph.routeTable.put(c, new Edge(c, d, 8).next(new Edge(c, e, 2))); 
    graph.routeTable.put(d, new Edge(d, c, 8).next(new Edge(d, e, 6))); 
    graph.routeTable.put(e, new Edge(e, b, 3)); 
} 

@Test 
public void testDistanceBetween_ABC() throws Exception { 
    ArrayList<Node> route = new ArrayList<Node>(); 
    route.add(a); 
    route.add(b); 
    route.add(c); 
    //System.out.println(a); 
    assertEquals(9, graph.distanceBetween(route));  

} 

@Test 
public void testDistanceBetween_AD() throws Exception { 
    ArrayList<Node> route = new ArrayList<Node>(); 
    route.add(a); 
    route.add(d); 
    assertEquals(5, graph.distanceBetween(route)); 
} 

@Test 
public void testDistanceBetween_ADC() throws Exception { 
    ArrayList<Node> route = new ArrayList<Node>(); 
    route.add(a); 
    route.add(d); 
    route.add(c); 
    assertEquals(13, graph.distanceBetween(route)); 
} 

@Test 
public void testDistanceBetween_AEBCD() throws Exception { 
    ArrayList<Node> route = new ArrayList<Node>(); 
    route.add(a); 
    route.add(e); 
    route.add(b); 
    route.add(c); 
    route.add(d); 
    assertEquals(22, graph.distanceBetween(route)); 
} 

@Test(expected=Exception.class) 
public void testDistanceBetween_AED() throws Exception { 
    ArrayList<Node> route = new ArrayList<Node>(); 
    route.add(a); 
    route.add(e); 
    route.add(d); 
    assertEquals(-1, graph.distanceBetween(route)); 
} 

@Test 
public void testNumStops_CC3() throws Exception { 
    int numStops = graph.numStops(c, c, 3); 
    assertEquals(2, numStops); 
} 

@Test 
public void testNumStops_AC4() throws Exception { 
    int numStops = graph.numStops(a, c, 4); 
    assertEquals(4, numStops); 
} 

@Test 
public void testShortestRoute_AC() throws Exception { 
    int shortestRoute = graph.shortestRoute(a, c); 
    assertEquals(9, shortestRoute); 
    System.out.println(shortestRoute); 
} 

@Test 
public void testShortestRoute_BB() throws Exception { 
    int shortestRoute = graph.shortestRoute(b, b); 
    assertEquals(9, shortestRoute); 
} 

@Test 
public void numRoutesWithin_CC30() throws Exception { 
    int numRoutesWithin = graph.numRoutesWithin(c, c, 30); 
    assertEquals(7, numRoutesWithin); 
} 

@Test 
public void testEquals() { 
    Node a1 = new Node("A"); 
    Node a2 = new Node("A"); 
    Node b = new Node("B"); 

    assertEquals(true, a1.equals(a2)); 
    assertEquals(false, a1.equals(b)); 
    assertEquals(true, (new Node("Test").equals(new Node("Test")))); 
} 

}

Привет Я пытаюсь напечатать значение а, Ь и с. Как вы можете видеть, я использую System out println на маршруте, но он ничего не выводит. Есть ли способ вывести результат без слишком большой модификации метода?

public void testDistanceBetween_ADC() throws Exception { 
    ArrayList<Node> route = new ArrayList<Node>(); 
    route.add(a); 
    route.add(d); 
    route.add(c); 
    assertEquals(13, graph.distanceBetween(route)); 
    System.out.println(route); 
} 

Я не уверен, если я должен выводить переменную «маршрут» или, если мне нужно добавить еще один небольшой метод жгутов это. Любая помощь будет оценена. Я знаю, что это простая вещь, которую я пытаюсь сделать, но по какой-то причине она не работает для меня.

много спасибо !!

Answer 1

В Редактировании моего первоначального ответа кажется, что в вашем внутреннем while-loop вашего distanceBetween-метода есть ошибка.

В случае маршрута, содержащего узлы A, B, C, он будет вычислять узел A, получить край к узлу B, а затем во внутреннем цикле он суммирует вес края. После этого вы вызываете break. Это нарушит как при-петлю

Если вы действительно хотите, чтобы сломать петлю, вы должны смотреть, как маркировать петлю в Java: Labeled Loops

Я не предпочитаю работать с мечеными петлями потому, что он иногда становится немного грязным.В вашем случае, просто используйте:

if(route.destination.equals(cities.get(i + 1))) { 
       distance += route.weight; 
       depth++; 
} else { 
      route = route.next; 
} 

//do further (error) handling 

На данный момент не ясно, что вы хотите сделать с изменяемой глубиной. В вашей реализации он всегда будет генерировать исключение, потому что вы разбиваете свои петли после нахождения первого маршрута, затем суммируете глубину, а затем проверяете, имеет ли глубина определенный размер. Таким образом, на маршрутах более 2 узлов это исключение всегда будет выполняться.

Для минимального, например, это может быть полезно для работы только с расстоянием:

 //... 
     Edge route = this.routeTable.get(cities.get(i)); 
     int newDistance = distance; 
     /*If key exists, we check if route from key to next 
     * city exists. We add the distance, and maintain a 
     * depth count 
     */ 
     while(route != null) { 
      if(route.destination.equals(cities.get(i + 1))) { 
       newDistance += route.weight; 
       // depth++; 
      } else { 
       route = route.next; 
      } 
     } 

     if(newDistance == distance) { 
      //the distance didnt change - it seems there was no route found, throw Exception or expand the graph or whatever 
     } else { 
      distance = newDistance; //now you have the distance for the next loop-run 
     } 

Answer 2

У вас есть 3 варианта

Реализовать ToString()

В случае Node класс является частью ваших источников, просто добавьте toString метод

public String toString(){ 
    return name; 
} 

Переопределяющий узел

В случае, если класс Node является частью внешней библиотеки, но не окончательный, вы можете переопределить узел и реализовать toString() вместо класса переопределения, как предложено supahupe.

Используйте поток & карты для отображения

В случае, если вы не можете переопределить узел, как предложил Supahupe, вы могли бы использовать общедоступное name поле и карту, что новый список строк и распечатать это

System.out.println(route.stream().map(n -> n.name).collect(Collectors.toList())); 

в качестве альтернативы можно создать класс декоратора для вашего узла с единственной целью печати ее красиво, будет Подход такой же, как для потока

...stream().map(n -> new NodeDecorator(n))...