Merge Intervals

public List<Interval> merge(List<Interval> intervals) {
        if (intervals == null || intervals.size() <= 1)
            return intervals;

        Collections.sort(intervals, new Comparator<Interval> () {
            public int compare(Interval i1, Interval i2) {
                return i1.start - i2.start;
            }
        });

        List<Interval> result = new LinkedList<Interval>();
        int start = intervals.get(0).start;
        int end = intervals.get(0).end;

        for (Interval interval : intervals) {
            if (interval.start <= end) // Overlapping intervals, move the end if needed
                end = Math.max(end, interval.end);
            else {                     // Disjoint intervals, add the previous one and reset bounds
                result.add(new Interval(start, end));
                start = interval.start;
                end = interval.end;
            }
        }

        // Add the last interval
        result.add(new Interval(start, end));
        return result;

    }

Insert Intervals

public class Solution {
    public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
        /* method 1, using merge function, bad performance
        intervals.add(newInterval);
        return merge(intervals);
        */

        // method 2
        int i = 0;
        while (i<intervals.size() && intervals.get(i).end<newInterval.start) 
            i++;
        while (i<intervals.size() && intervals.get(i).start<=newInterval.end) {
            newInterval = new Interval(Math.min(intervals.get(i).start, newInterval.start), Math.max(intervals.get(i).end, newInterval.end));
            intervals.remove(i);
        }

        intervals.add(i,newInterval);
        return intervals;

    }

    public List<Interval> merge(List<Interval> intervals) {
        if (intervals == null || intervals.size() <= 1)
            return intervals;

        Collections.sort(intervals, new Comparator<Interval> () {
            public int compare(Interval i1, Interval i2) {
                return i1.start - i2.start;
            }
        });

        List<Interval> result = new LinkedList<Interval>();
        int start = intervals.get(0).start;
        int end = intervals.get(0).end;

        for (Interval interval : intervals) {
            if (interval.start <= end) // Overlapping intervals, move the end if needed
                end = Math.max(end, interval.end);
            else {                     // Disjoint intervals, add the previous one and reset bounds
                result.add(new Interval(start, end));
                start = interval.start;
                end = interval.end;
            }
        }

        // Add the last interval
        result.add(new Interval(start, end));
        return result;

    }

Data Stream as disjoint Intervals

public class SummaryRanges {

    List<Interval> res;
    /** Initialize your data structure here. */
    public SummaryRanges() {
        res = new ArrayList();
    }

    public void addNum(int val) {
        Interval cur = new Interval(val,val);
        List<Interval> rst = new ArrayList<Interval>();

        int pos = 0;
        for(Interval interval : res){
            //non Overlap， cur is before
            if(cur.end + 1 < interval.start) {
                rst.add(interval);
                continue;
            }
            // non overlap, cur is after
            if(cur.start > interval.end + 1){
                rst.add(interval);
                pos++;
                continue;
            }

            cur.start = Math.min(cur.start, interval.start);
            cur.end = Math.max(cur.end, interval.end);

        }
        rst.add(pos, cur);
        res = new ArrayList<Interval>(rst);
    }

    public List<Interval> getIntervals() {
        return res;
    }
}

Non-overlapping Intervals

public int eraseOverlapIntervals(Interval[] intervals) {
        int count = 0;
        if (intervals == null || intervals.length <= 1)
            return count;

        Arrays.sort(intervals, new Comparator<Interval> () {
            public int compare(Interval i1, Interval i2) {
                return i1.start - i2.start;
            }
        });


        int last = 0;
        for (int i = 1; i < intervals.length; i++) {

            if (intervals[i].start < intervals[last].end) { // overlapping
                ++count;
                if (intervals[i].end < intervals[last].end) 
                    last = i;
            } else { // non overlapping
                last = i;
            }
        }

       return count;
    }

Find Right Interval [TO DO]