计算与所有线段都重合的线段数目

package com.karl.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class TestOverlap {

    private static List<Duration> getDurations() {
        Duration d1 = new Duration(new Node(4L, true), new Node(5L, false));
        Duration d2 = new Duration(new Node(1L, true), new Node(3L, false));
        Duration d3 = new Duration(new Node(2L, true), new Node(3L, false));
        Duration d4 = new Duration(new Node(2L, true), new Node(4L, false));
        Duration d5 = new Duration(new Node(1L, true), new Node(4L, false));
        List<Duration> list = new ArrayList<Duration>();
        list.add(d1);
        list.add(d2);
        list.add(d3);
        list.add(d4);
        list.add(d5);
        return list;
    }

    private static List<Node> getNodes() {
        List<Duration> durations = getDurations();
        List<Node> nodes = new ArrayList<Node>();
        for (Duration d : durations) {
            nodes.add(d.getStart());
            nodes.add(d.getEnd());
        }
        return nodes;
    }

    private static int getOverlap(Duration d) {
        int max = 1;
        int current = 1;
        List<Node> nodes = getNodes();
        Collections.sort(nodes);
        Iterator<Node> it = nodes.iterator();
        while (it.hasNext()) {
            Node node = it.next();
            System.out.println(node);
            if ((node.getValue() >= d.getStart().getValue())
                    && (node.getValue() <= d.getEnd().getValue())) {
                if (node.isStart()) {
                    current++;
                } else {
                    current--;
                }
                if (current > max) {
                    max = current;
                }
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Duration d = new Duration(new Node(0L, true), new Node(9L, false));
        System.out.println(getOverlap(d));
    }

}

class Duration {
    private Node start;
    private Node end;

    public Node getStart() {
        return start;
    }

    public void setStart(Node start) {
        this.start = start;
    }

    public Node getEnd() {
        return end;
    }

    public void setEnd(Node end) {
        this.end = end;
    }

    public Duration(Node start, Node end) {
        this.start = start;
        this.end = end;
    }

}

class Node implements Comparable<Node> {
    private Long value;
    private boolean start;// this flag indicate the start point or the destination point.

    public Node(Long value, boolean start) {
        this.value = value;
        this.start = start;
    }

    public Long getValue() {
        return value;
    }

    public void setValue(Long value) {
        this.value = value;
    }

    public boolean isStart() {
        return start;
    }

    public void setStart(boolean start) {
        this.start = start;
    }

    @Override
    public String toString() {
        return "[" + value + "," + start + "]";
    }

    @Override
    public int compareTo(Node o) {
        return Long.valueOf(this.value).compareTo(Long.valueOf(o.value));
    }

}