Question

我有2个课程如下所示：

public class Route {
    public int node;
    public int link;
    public int weight;
}

节点列表中的数据如下所示：

node    link    weight
----------------------
1       A       0
1       B       10
2       C       5
2       D       8
2       E       12

第二节课是：

public class Segment{
    public int node;
    public String linkFrom, linkTo;
    public int weight;
}

是否有一个优雅的解决方案可以将上面的列表转换为新的细分列表，然后看起来像这样？

node    linkfrom    linkto    weight
------------------------------------
1       A           B         10
2       C           E         25

节点列表按节点grouping转换为段列表。权重是节点中这些链接的权重之和，而linkFrom是节点中的第一个链接，linkTo是组更改之前节点中的最后一个链接。

Answer 1

假设对于特定节点，对于不同的链路，每个链路将具有不同的节点。你可以尝试为你的路由类（或transform函数添加一个自定义比较器的函数，并使它实现〜可比较的iterface）来比较基于权重的路由，我会去定制比较器，因为似乎不比较重量是路线的自然比较。

代码就像 -

compareTo

然后在你的主要或你需要创建这些段的地方，对于路由列表中的每个唯一节点，你可以这样做 -

static class WeightComparator implements Comparator<Route>
 {
     public int compare(Route o1 , Route o2) {
         if(o1.weight > o2.weight) {
             return 1;
         }
         else if(o1.weight < o2.weight) {
             return -1;
         }
         return 1;
     }

public class Segment{
    public int node;
    public String linkFrom, linkTo;
    public int weight;

    public void transform(int node, List<Route> routes) {
        List<Route> routesWithNode = new ArrayList<Route>();
        for(Route route : routes) {
            if(route.node == node) {
                routesWithNode.add(route);
            }
        }
        Collections.sort(routesWithNode , new WeightComparator());
        this.node = node;
        this.linkFrom = routesWithNode.get(0).link;
        this.linkTo = routeWithNode.get(routesWithNode.length - 1).link;
        int tweight = 0;
        for(Route r: routeWithNode) {
            tweight = tweight + r.weight;
        }
        this.weight = tweight;
    }
}

请注意以上不是java代码，它的伪代码，你必须编写完整的代码。

Answer 2

添加一个新类，让我们调用转换

<LinearLayout
    android:layout_width="0dp"
    android:layout_height="144dp"
    android:layout_weight="0.5"
    android:background="@android:color/holo_red_dark">

    // Column A.
    // Put your content here..

</LinearLayout>

<LinearLayout
    android:layout_width="0dp"
    android:layout_height="144dp"
    android:orientation="vertical"
    android:weightSum="1"
    android:layout_weight="0.5">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="72dp"
        android:background="@android:color/holo_green_dark"
        android:layout_weight="0.5">

        // Column B, row 1.
        // Put your content here..

    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="72dp"
        android:background="@android:color/holo_blue_dark"
        android:layout_weight="0.5">

        // Column B, row 2.
        // Put your content here..

    </LinearLayout>

</LinearLayout>

然后创建所有路线的地图，以识别所有路线列表中的第一个成员。

public class Convert{
  public Route firstRoute;
  public Route lastRoute;
  public Segment segment;

  public Convert(){
   this.segment = new Segment();
 }
}

创建转换列表以存储转换后的列表数据

public HashMap<Integer,Route> map = new HashMap<>();

然后迭代

public List<Convert> convertedList = new ArrayList<>();

我假设您希望将路由列表中的最后一个链接作为Segment中的linkTo始终。

Answer 3

我创建了以下代码。它非常原始。

public void convert() {
        // List to hole segments
        ArrayList<Segment> segments = new ArrayList<Segment>();
        // List holding routes
        ArrayList<Route> routes = createRoutes();
        // Node id
        int startRouteNode = routes.get(0).node;
        // Start Link
        String startLink = null;
        // Link in previous node traversed
        String previousLink = null;
        // Weight
        int weight = 0;
        for (Route route : routes) {
            // If current route is on the same node as previous one
            if (startRouteNode == route.node) {
                if (startLink == null)
                    startLink = route.link;

                previousLink = route.link;
                weight += route.weight;
            } else {
                // If current route is not on previous node
                segments.add(new Segment(startRouteNode, startLink,
                        previousLink, weight));
                startRouteNode = route.node;
                startLink = previousLink;
                weight = route.weight;
            }
        }
        // Add last segment in segment list
        segments.add(new Segment(startRouteNode, startLink, previousLink,
                weight));
        System.out.println(segments);
    }

    ArrayList<Route> createRoutes() {
        ArrayList<Route> arraylist = new ArrayList<Route>();
        arraylist.add(new Route(1, "A", 0));
        arraylist.add(new Route(1, "B", 10));
        arraylist.add(new Route(2, "C", 5));
        arraylist.add(new Route(2, "D", 8));
        arraylist.add(new Route(2, "E", 12));

        return arraylist;
    }

将结果集转换为具有不同结构的另一个结果集？

3 个答案: