我有一组日期范围，如果java中有任何日期重叠，我需要得到组合的日期范围

我有一组日期范围，如果Java中有任何日期重叠，我需要获得组合的日期范围

给定三组日期范围，如果任何日期与另一个日期范围重叠，则需要合并

示例：

20170101-20170331
20170101-20170430
20170430-20170501

20170101-20170430
20170430-20170501

预期结果为：

20170101-20170331
20170101-20170430
20170430-20170501

20170101-20170430
20170430-20170501

我有字符串变量中的所有日期。请任何人帮我写代码。我已经在我的代码下面粘贴了

我想达到预期的结果。我无法找到需要如何修改此代码。我是初学者，请帮我做那件事。我从StackOverflow获得了这个示例程序

package com.kkkkk.Combine;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;

public class Ideone {
    public static void main(String[] args) throws java.lang.Exception {
        ArrayList<Interval> x = new ArrayList<>();
        x.add(new Interval("20170430", "20170501")); // "20170101", "20170430"
        x.add(new Interval("20170101", "20170430"));// 20170101-20170430
                x.add(new Interval("20170101", "20170331"));
                x = merge(x);

        for (Interval i1 : x) {
            System.out.println(i1.getStartDate() + " " + i1.getEndDate());

        }

    }

    public static ArrayList<Interval> merge(ArrayList<Interval> intervals) {


        if (intervals.size() == 0 || intervals.size() == 1)
            return intervals;

        ArrayList<Interval> result = new ArrayList<Interval>();

        Collections.sort(intervals, new IntervalComparator());


        System.out.println("intervals ggggg\n" + intervals + "\n");

        Interval first = intervals.get(0);

        String start = first.getStartDate();
        String end = first.getEndDate();
        Date startDateF = null;
        Date endDateF = null;

        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
            startDateF = sdf.parse(start);
            endDateF = sdf.parse(end);


            // ArrayList<Interval> result = new ArrayList<Interval>();

            for (int i = 1; i < intervals.size(); i++) {

                Interval current = intervals.get(i);

                Date currentEndDate = sdf.parse(current.getEndDate());
                Date currentStartDate = sdf.parse(current.getStartDate());

                // if ((current.getStartDate().after(endDateF)) ||
                                Date d1 = minDate(endDateF, currentStartDate);

                                if ((currentStartDate).compareTo(endDateF) <= 0) {
                    endDateF = maxDate(currentEndDate, endDateF);

                                                        } else {

                                                            result.add(new Interval(start, (sdf.format(endDateF))));

                    // start = current.start;
                    // end = current.end;

                    start = sdf.format(currentStartDate);
                    endDateF = (currentEndDate);



    enter code here

                }

            }
            result.add(new Interval(start, end));
            // result.add(new Interval(start, (sdf.format(endDateF))));
        }

        catch (ParseException ex) {
            ex.printStackTrace();
        }

        // result.add(new Interval(start, end));

        return result;
        // return intervals;

    }

    public static Date minDate(Date date1, Date date2) {
        // if date1 before date2 then return date1 else return date2

        return date1.before(date2) ? date1 : date2;
    }

    /**
     * find Max Dates
     * 
     * @param date1
     * @param date2
     * @return
     */
    public static Date maxDate(Date date1, Date date2) {
        // if date1 after date2 then return date1 else return date2
        System.out.println("date max");
        return date1.after(date2) ? date1 : date2;
    }
}

package com.kkk.Combine；
导入java.text.ParseException；
导入java.text.simpleDataFormat；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.Date；
公共类表意词{
公共静态void main（字符串[]args）引发java.lang.Exception{
ArrayList x=新的ArrayList（）；
x、 添加（新间隔（“20170430”、“20170501”）；/“20170101”、“20170430”
x、 添加（新间隔（“20170101”、“20170430”）；//20170101-20170430
x、 增加（新区间（“20170101”、“20170331”）；
x=合并（x）；
对于（间隔i1:x）{
System.out.println（i1.getStartDate（）+“”+i1.getEndDate（））；
}
}
公共静态ArrayList合并（ArrayList间隔）{
if（interval.size（）==0 | | interval.size（）==1）
返回间隔；
ArrayList结果=新建ArrayList（）；
排序（间隔，新IntervalComparator（））；
System.out.println（“间隔ggggg\n”+间隔+“\n”）；
Interval first=Interval.get（0）；
字符串start=first.getStartDate（）；
字符串end=first.getEndDate（）；
日期startDateF=null；
Date-endDateF=null；
试一试{
SimpleDataFormat sdf=新的SimpleDataFormat（“yyyyMMdd”）；
startDateF=sdf.parse（开始）；
endDateF=sdf.parse（end）；
//ArrayList结果=新建ArrayList（）；
对于（int i=1；i如果（（currentStartDate）.compareTo（endDateF）我假设您的
间隔是这样的：

    private static class Interval {
    private String begin;
    private String end;

    public Interval(String begin, String end) {
        this.begin = begin;
        this.end = end;
    }

    public String getStartDate() {
        return begin;
    }

    public String getEndDate() {
        return end;
    }
}

您需要做的是合并一个
间隔
列表。解决方案是
排序
列表，开始日期和结束日期。然后将最早的开始时间和最晚的结束时间存储在光标变量中。例如：

    public List<Interval> merge(List<Interval> intervals) {
    Collections.sort(intervals, new Comparator<Interval>() {
        @Override
        public int compare(Interval o1, Interval o2) {
            if (o1.getStartDate().equals(o2.getStartDate())) {
                return o1.getEndDate().compareTo(o2.getEndDate());
            }
            return o1.getStartDate().compareTo(o2.getStartDate());
        }
    });
    List<Interval> ret = new ArrayList<>();
    String MAX_VAL = "99999999";
    String MIN_VAL = "00000000";
    String start = MAX_VAL, end = MIN_VAL;

    for (Interval interval : intervals) {
        if (interval.getStartDate().compareTo(end) > 0) {
            if (start.compareTo(MAX_VAL) < 0) {
                ret.add(new Interval(start, end));
            }
            start = interval.getStartDate();
            end = interval.getEndDate();
        } else {
            if (start.compareTo(interval.getStartDate()) < 0) {
                start = interval.getStartDate();
            }
            if (end.compareTo(interval.getEndDate()) > 0) {
                end = interval.getEndDate();
            }
        }
    }
    if (start.compareTo(MAX_VAL) < 0) {
        ret.add(new Interval(start, end));
    }
    return ret;
}

公共列表合并（列表间隔）{
Collections.sort（间隔、新比较器（）{
@凌驾
公共整数比较（区间o1、区间o2）{
如果（o1.getStartDate（）等于（o2.getStartDate（））{
返回o1.getEndDate（）.compareTo（o2.getEndDate（））；
}
返回o1.getStartDate（）.compareTo（o2.getStartDate（））；
}
});
List ret=new ArrayList（）；
字符串MAX_VAL=“9999999”；
字符串MIN_VAL=“00000000”；
字符串开始=最大值，结束=最小值；
用于（间隔：间隔）{
if（interval.getStartDate（）.compareTo（end）>0）{
如果（开始比较到（最大值）<0）{
ret.add（新间隔（开始、结束））；
}
start=interval.getStartDate（）；
end=interval.getEndDate（）；
}否则{
if（start.compareTo（interval.getStartDate（））<0）{
start=interval.getStartDate（）；
}
if（end.compareTo（interval.getEndDate（））>0）{
end=interval.getEndDate（）；
}
}
}
如果（开始比较到（最大值）<0）{
ret.add（新间隔（开始、结束））；
}
返回ret；
}
ISO 8601
将日期时间值序列化为文本时，请使用标准ISO 8601格式。您的格式符合标准的“基本”版本，但最好尽可能使用完整格式：

YYYY-MM-DD

对日期范围使用标准格式，使用斜杠字符作为分隔符：

YYYY-MM-DD/YYYY-MM-DD

如果无法更改输入字符串，请拆分连字符上的字符串。将每一部分解析为
LocalDate
。使用这些对象实例化
LocalDateRange

LocalDate ld = LocalDate.parse( "20170101" , DateTimeFormatter.BASIC_ISO_DATE ) ; 

LocalDateRange
使用扩展java.time类功能的项目中的类。在解析和生成文本时使用标准格式

LocalDateRange range = LocalDateRange.parse( "2017-01-01/2017-03-31" ) ;

收集在
列表中

要排序，请编写一个调用
LocalDateRange:：getStart
的比较器

比较另一个范围以查看它们是否重叠。如果重叠，请结合调用
union

if ( range.overlaps( otherRange ) ) {
    range = range.union( otherRange ) ;
}

如果它们没有重叠，则表示您已完成该轮。请将此结果存储在另一个
列表中。
。使用下一个范围开始另一轮

起泡、冲洗、重复。
公共静态无效主管道（字符串[]args）{
public static void main(String[] args) {
    // TODO Auto-generated method stub


    ArrayList<MainLab.Interval> list = new ArrayList<MainLab.Interval>();


    list.add(new MainLab.Interval("20170430", "20170501"));
    list.add(new MainLab.Interval("20170101", "20170430"));
    list.add(new MainLab.Interval("20170101", "20170331"));



for (Iterator iterator = mergeInterval(list).iterator(); iterator.hasNext();) {
    Interval interval = (Interval) iterator.next();

    System.out.println(interval.getStart()+ "==="+interval.getEnd());
}




}

public static List<Interval>  mergeInterval(ArrayList<MainLab.Interval> list){

    /*
     * Sort the list , Interval class have implemented Comparable Interface.
     *  So we will get sorted intervals. Intervals sorted based on start of interval
     */
    Collections.sort(list);
    Set<MainLab.Interval> resultlist = new TreeSet<MainLab.Interval>();

    List<MainLab.Interval> mergedIntervals = new ArrayList<MainLab.Interval>();

    //declare date formate to parse and format date from string to and from
    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
    if(list.size() == 1){
        //resultlist = list
        return list;
    }
    if(list.size() > 1){
        // get first interval Object. conside it as first interval
        Interval mergeInterval = list.get(0);

        // loop other intervals from second in the list
        for(int i=1; i< list.size() ; i++){

            Interval interval2 = list.get(i);
            try{


                Date startDate1  = sdf.parse(mergeInterval.getStart());
                Date endDate1  = sdf.parse(mergeInterval.getEnd());



                Date startDate2  = sdf.parse(interval2.getStart());
                Date endDate2  = sdf.parse(interval2.getEnd());


                // compare if current interval's start date is before merging interval's end date
                // then the two intervals are overlaping
                if(startDate2.compareTo(endDate1) < 0 ){

                    // check whether end date of current loop interval is after the merging interval.
                    // then we need to update the end date of merging interval with looping interval's end date
                    if(endDate2.compareTo(endDate1) > 0 ){

                        mergeInterval.setEnd(interval2.getEnd());

                    }
                }else{
                    // compare if current interval's start date is after merging interval's end date
                    // then it must be a new interval start so swap mergInterval variable with  current looping interval

                     mergeInterval = interval2;

                }

                //add merge interval to set. 
                resultlist.add(mergeInterval);
            }catch(Exception ex){
                ex.printStackTrace();
            }

        }

    }
    mergedIntervals.addAll(resultlist);
    return mergedIntervals;

}

public static class Interval implements Comparable<Interval>{

    private String start;
    private String end;

    public String getStart() {
        return start;
    }
    public void setStart(String start) {
        this.start = start;
    }
    public String getEnd() {
        return end;
    }
    public void setEnd(String end) {
        this.end = end;
    }
    public Interval(){



            }
    public Interval(String start,String end){

        this.start = start;
        this.end = end;

    }
        @Override
        public boolean equals(Object obj) {
            // TODO Auto-generated method stub
            Interval inteval = (Interval)obj;
            return this.getStart().equals(inteval.getStart()) && this.getEnd().equals(inteval.getEnd()) ;
        }

    @Override
    public int compareTo(Interval o) {
        // TODO Auto-generated method stub

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        try{
            Date startDate  = sdf.parse(start);
            Date endDate  = sdf.parse(end);
            Date pstartDate  = sdf.parse(o.start);
            Date pendDate  = sdf.parse(o.end);


            return startDate.compareTo(pstartDate);

        }catch(Exception ex){
            ex.printStackTrace();
        }
        return 0;
    }


}

//TODO自动生成的方法存根
ArrayList=新建ArrayList（）；
添加列表（新的主实验室间隔（“20170430”、“20170501”）；
添加列表（新的主实验室间隔（“20170101”、“20170430”）；
添加列表（新的主实验室间隔（“20170101”、“20170331”）；
for（Iterator Iterator=mergeInterval（list）.Iterator（）；Iterator.hasNext（）；）{
Interval=（Interval）迭代器.next（）；
System.out.println（interval.getStart（）+“=”+interval.getEnd（））；
}
}
公共静态列表合并间隔（ArrayList列表）{
/*
*排序列表、区间类都实现了可比接口。
*所以我们将得到排序的间隔。间隔根据间隔的开始排序