Collections.sort(allValidPeriods, new Comparator<CheckInPeriod>() {

            @Override

            public int compare(CheckInPeriod o1, CheckInPeriod o2) {

                return o2.priority.compareTo(o1.priority);

            }

        });

        if (allValidPeriods.isEmpty()) {

            return result;

        }

        result.add(allValidPeriods.get(0));

        for (CheckInPeriod cip : allValidPeriods) {

            CheckInPeriod first = result.getFirst();

            if (cip.periodFrom.before(first.periodFrom)) {

                if (!cip.cid.equals(first.cid) || !cip.cod.equals(first.cod) || !cip.agencyMinimum.equals(first.agencyMinimum) || cip.periodTo.before(first.periodFrom)) {

                    CheckInPeriod c = new CheckInPeriod(cip);

                    if (!cip.periodTo.before(first.periodFrom)) {

                        c.periodTo = first.periodFrom;

                    }

                    result.addFirst(c);

                } else {

                    result.getFirst().periodFrom = cip.periodFrom;

                }

            }

            CheckInPeriod last = result.getLast();

            if (cip.periodTo.after(last.periodTo)) {

                if (!cip.cid.equals(last.cid) || !cip.cod.equals(last.cod) || cip.periodFrom.after(last.periodTo)) {

                    CheckInPeriod c = new CheckInPeriod(cip);

                    if (!cip.periodFrom.after(last.periodTo)) {

                        c.periodFrom = last.periodTo;

                    }

                    result.addLast(c);

                } else {

                    result.getLast().periodTo = cip.periodTo;

                }

            }

            CheckInPeriod former = result.getFirst();

            ListIterator<CheckInPeriod> iterator = result.listIterator();

//            for(CheckInPeriod c : finalPeriods){

            while (iterator.hasNext()) {

                CheckInPeriod c = iterator.next();

                if (c.periodTo.after(cip.periodTo)) {

                    break;

                }

                if (DateUtils.getDaysBetween2(former.periodTo, c.periodFrom) > 1 && former.periodTo.before(c.periodFrom) && cip.periodFrom.before(c.periodFrom)) {

                    CheckInPeriod gap = new CheckInPeriod(cip);

                    gap.periodFrom = DateUtils.addDays(former.periodTo, 1);

                    gap.periodTo = DateUtils.addDays(c.periodFrom, -1);

                    iterator.previous();

                    iterator.add(gap);

                    iterator.next();

                }

                former = c;

            }

        }

        return result;

​

​

​

​

​

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collections;

import java.util.Comparator;

import java.util.Date;

import java.util.LinkedList;

import java.util.List;

import java.util.ListIterator;

import java.util.Random;

import java.util.function.Predicate;

import org.joda.time.LocalDate;

​

/**

 *

 * @author development

 */

public class FindPriorityPeriodsList {

​

    Date periodFrom;

    Date periodTo;

    Integer priority;

    Predicate<Object> mergeConditions;

​

    public FindPriorityPeriodsList(Date periodFrom, Date periodTo, Integer priority) {

​

        this.periodFrom = periodFrom;

        this.periodTo = periodTo;

        this.priority = priority;

    }

​

    public FindPriorityPeriodsList(FindPriorityPeriodsList FPPL) {

​

        this.periodFrom = FPPL.periodFrom;

        this.periodTo = FPPL.periodTo;

        this.priority = FPPL.priority;

​

    }

​

    public boolean mergeConditions(Object o) {

        if (o == this) {

            return true;

        }

​

        if (!(o instanceof FindPriorityPeriodsList)) {

            return false;

        }

​

        return true;

    }

​

    public static void main(String args[]) {

        List<FindPriorityPeriodsList> testFindPriorityPeriodsList = new ArrayList<>();

​

        Date periodFrom = new Date(2022, 1, 2);

        Date periodTo = new Date(2022, 1, 4);

        int random = 10000;

        FindPriorityPeriodsList testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        periodFrom = new Date(2022, 1, 3);

        periodTo = new Date(2022, 1, 6);

        random = 9000;

        testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        periodFrom = new Date(2022, 1, 1);

        periodTo = new Date(2022, 1, 5);

        random = 8000;

        testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        periodFrom = new Date(2022, 1, 3);

        periodTo = new Date(2022, 1, 7);

        random = 7000;

        testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        periodFrom = new Date(2022, 1, 2);

        periodTo = new Date(2022, 1, 10);

        random = 6000;

        testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        LinkedList<FindPriorityPeriodsList> resultOfTest = priorityPeriodsList(testFindPriorityPeriodsList);

        System.out.println("result");

    }

​

    public static int randomNumber(int min, int max) {

​

        return min + (int) (Math.random() * ((max - min) + 1));

    }

​

    public static Date randomDate(int min, int max) {

​

        int year = randomNumber(min, max); // generate a year between 1900 and 2010;

        int dayOfYear = randomNumber(1, 10);// generate a number between 1 and 365 (or 366 if you need to handle leap year);

        Calendar calendar = Calendar.getInstance();

        calendar.set(Calendar.YEAR, year);

        calendar.set(Calendar.DAY_OF_YEAR, dayOfYear);

        return calendar.getTime();

​

    }

    /*

 * DateUtils.java

 *

 * Created on August 21, 2007, 2:11 PM

 *

 * To change this template, choose Tools | Template Manager

 * and open the template in the editor.

 */

package hr.stratusit.cbms.commonNew;

​

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.time.ZoneId;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.List;

import java.util.Locale;

import java.util.TimeZone;

import org.joda.time.DateTime;

​

​

/**

 *

 * @author root

 */

public class DateUtils {

​

    public static Integer getWeeksBetweenLow(Date from, Date to) {

        Integer result = getDaysBetween(from, to);

        result = result / 7;

        return result;

    }

​

    public static Integer getWeeksBetweenHigh(Date from, Date to) {

        Integer result = getDaysBetween(from, to);

        if ((result % 7) > 0) {

            result = (result / 7) + 1;

        } else {

            result = (result / 7);

        }

​

        return result;

    }

​

    /**

     * Vraca koliko dana ima u mjesecu

     *

     * @param month je isti kao i kod Calendar.MONTH - znaci 0 je sijecanj

     * @return

     */

    public static Integer getDaysInMonth(int month, int year) {

        return getLastDayOfMonth(month, year);

    }

//    /**

//     * Vraca koliko dana ima u mjesecu

//     *

//     * @param month je isti kao i kod Calendar.MONTH - znaci 0 je sijecanj

//     * @return

//     */

//    public static Integer getDaysInMonth(int month, int year) {

//        Calendar cal = Calendar.getInstance();

//        cal.set(Calendar.DAY_OF_MONTH, 1);

//        cal.set(Calendar.MONTH, month);

//        cal.set(Calendar.YEAR, year);

//        cal.set(Calendar.HOUR_OF_DAY, 0);

//        cal.set(Calendar.MINUTE, 0);

//        cal.set(Calendar.SECOND, 0);

//        cal.set(Calendar.MILLISECOND, 1);

//        Date from = cal.getTime();

//        cal.add(Calendar.MONTH, 1);

//        Date to = cal.getTime();

//

//        Integer result = getDaysBetween(from, to);

//        return result;

//    }

​

​

    /**

     * @param time - take time from this date

     * @param date - apply to this date

     * @return d2 with applied time from d1

     */

​

    public static int getAgeOfPerson(Date dateOfBirth) {

        Calendar dob = Calendar.getInstance();

        dob.setTime(dateOfBirth);

        Calendar today = Calendar.getInstance();

        int age = today.get(Calendar.YEAR) - dob.get(Calendar.YEAR);

        if (today.get(Calendar.MONTH) < dob.get(Calendar.MONTH)) {

            age--;

        } else if (today.get(Calendar.MONTH) == dob.get(Calendar.MONTH)

                && today.get(Calendar.DAY_OF_MONTH) < dob.get(Calendar.DAY_OF_MONTH)) {

            age--;

        }

        return age;

    }

​

    public static Date getNormalizedDate(Date date) {

        try {

            SimpleDateFormat oldFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");

            SimpleDateFormat isoFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");

            isoFormat.setTimeZone(TimeZone.getTimeZone("UTC"));

            return isoFormat.parse(oldFormat.format(date));

        } catch (Exception ex) {

        }

        return null;

    }

​

    public static boolean isDateBetween(Date date, Date from, Date to) {

        date = setZeroHour(date);

        from = setZeroHour(from);

        to = setZeroHour(to);

​

        return ((date.compareTo(from) >= 0) && (date.compareTo(to) <= 0));

    }

​

    public static int getHoursBetween(Date from, Date to) {

        long time1 = from.getTime();

        long time2 = to.getTime();

​

        long diff = time2 - time1;

​

        return (int) (diff / 1000 / 60 / 60);

    }

​

    public static Date setZeroHour(Date date) {

        DateTime dt = new DateTime(date);

        return dt.millisOfDay().setCopy(0).toDate();

    }

​

    public static Date set12Hour(Date date) {

        DateTime dt = new DateTime(date);

        return dt.millisOfDay().setCopy(12 * 3600 * 1000).toDate();

    }

​

    public static Date set24Hour(Date date) {

        DateTime dt = new DateTime(date);

        DateTime result = new DateTime(dt.getYear(), dt.getMonthOfYear(), dt.getDayOfMonth(), 23, 59, 59, 0);

        return result.toDate();

    }

​

    public static Date getStartDate(int month, int year) {

        DateTime dt = new DateTime(year, month, 1, 0, 0, 0, 0);

        return dt.toDate();

    }

​

    public static Date getEndDate(int month, int year) {

        DateTime dt = new DateTime(year, month, 1, 0, 0, 0, 0);

        return dt.dayOfMonth().withMaximumValue().toDate();

    }

//    public static Date getEndDate(int month, int year) {

//        Calendar result = Calendar.getInstance();

//        result.setTime(getStartDate(month, year));

//        result.add(Calendar.MONTH, 1);

//        result.add(Calendar.DAY_OF_YEAR, -1);

//        return result.getTime();

//    }

​

    public static Date addDays(Date date, int days) {

        Calendar cal = Calendar.getInstance();

        cal.setTime(date);

        cal.add(Calendar.DATE, days); //minus number would decrement the days

        return cal.getTime();

    }

​

    public static boolean areDatesTheSame(Date date1, Date date2) {

        if (date1 == null || date2 == null) {

            return false;

        }

​

        DateTime dt1 = new DateTime(date1);

        dt1 = dt1.withMillisOfDay(0);

        DateTime dt2 = new DateTime(date2);

        dt2 = dt2.withMillisOfDay(0);

        return dt1.isEqual(dt2);

    }

    public static boolean arePeriodsOverlapping(Date date1from, Date date1to, Date date2from, Date date2to){

        if(!set12Hour(date1from).after(set12Hour(date2to)) && !set12Hour(date1to).before(set12Hour(date2from))){

            return true;

        }

        return false;

    }

​

//    public static boolean areDatesTheSame(Date date1, Date date2) {

//        if (date1 == null || date2 == null) {

//            return false;

//        }

//

//        Calendar cal1 = Calendar.getInstance();

//        cal1.setTime(date1);

//        Calendar cal2 = Calendar.getInstance();

//        cal2.setTime(date2);

//        return (cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR)) && (cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR));

//    }

    /**

     * Return lower rounded number of days between two days including time

     *

     * @param from

     * @param to

     * @return

     */

    public static Integer getDaysBetween(Date from, Date to) {

        Long fromMsec = from.getTime();

        Long toMsec = to.getTime();

        return convertMilisecondsToDays(toMsec - fromMsec);

    }

​

    public static Integer convertMilisecondsToDays(Long miliseconds) {

        BigDecimal result = new BigDecimal(miliseconds);

        return result.divide(BigDecimal.valueOf(1000 * 60 * 60 * 24), 0, RoundingMode.UP).intValue();

    }

​

    /**

     * Return lower rounded number of days between two days ignoring time

     *

     * @param from

     * @param to

     * @return

     */

    public static Integer getDaysBetween2(Date from, Date to) {

        Long fromMsec = set12Hour(from).getTime();

        Long toMsec = set12Hour(to).getTime();

        return convertMilisecondsToDays2(toMsec - fromMsec);

    }

​

    public static Integer convertMilisecondsToDays2(Long miliseconds) {

        BigDecimal result = new BigDecimal(miliseconds);

        result = result.divide(BigDecimal.valueOf(1000), RoundingMode.HALF_UP); // seconds

        result = result.divide(BigDecimal.valueOf(60), RoundingMode.HALF_UP); // minutes

        result = result.divide(BigDecimal.valueOf(60), RoundingMode.HALF_UP); // hours

        result = result.divide(BigDecimal.valueOf(24), RoundingMode.HALF_UP); // days

        return result.setScale(0, RoundingMode.HALF_UP).intValue();

    }

​

    public static Integer getWeeksBetween(Date from, Date to) {

        Integer result = getDaysBetween(from, to);

        result = result / 7;

        return result;

    }

​

    public static Integer getYearsBetween(Date from, Date to) {

        Integer result = getWeeksBetween(from, to);

        result = result / 52;

        return result;

    }

​

    public static Integer getLastDayOfMonth(Integer month, Integer year) {

        return new DateTime(getEndDate(month, year)).getDayOfMonth();

    }

//    public static Integer getLastDayOfMonth(Integer month, Integer year) {

//        Calendar calendar = Calendar.getInstance();

//        calendar.set(year, month - 1, 1);

//        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);

//    }

​

    public static String dateToString(Date date, String pattern) {

        String result = "";

        if (date != null) {

            SimpleDateFormat sdf = new SimpleDateFormat(pattern, Locale.ENGLISH);

            result = sdf.format(date);

        }

        return result;

    }

​

    public static String dateToString(Date date) {

        String result = "";

        if (date != null) {

            SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy'T'HH:mm:ss");

            result = sdf.format(date);

        }

        return result;

    }

​

    public static String dateToString(Date date, String pattern, Locale locale) {

        String result = "";

        if (date != null) {

            SimpleDateFormat sdf = new SimpleDateFormat(pattern, locale);

            result = sdf.format(date);

        }

        return result;

    }

​

    /**

     *

     * @param date

     * @param pattern

     * @return

     */

    public static Date stringToDate(String date, String pattern) {

        try {

            if (date != null) {

                SimpleDateFormat sdf = new SimpleDateFormat(pattern);

                return sdf.parse(date);

            }

            return null;

        } catch (ParseException ex) {

            return null;

        }

    }

​

    public static String getLocalizedNameOfDay(int day, Locale locale) {

        switch (day) {

            case Calendar.SATURDAY:

                if (locale.getLanguage().equals("hr")) {

                    return "subota";

                } else if (locale.getLanguage().equals("it")) {

                    return "sabato";

                } else if (locale.getLanguage().equals("de")) {

                    return "Samstag";

                } else {

                    return "saturday";

                }

            case Calendar.SUNDAY:

                if (locale.getLanguage().equals("hr")) {

                    return "nedjelja";

                } else if (locale.getLanguage().equals("it")) {

                    return "domenica";

                } else if (locale.getLanguage().equals("de")) {

                    return "Sontag";

                } else {

                    return "sunday";

                }

            case Calendar.MONDAY:

                if (locale.getLanguage().equals("hr")) {

                    return "ponedjeljak";

                } else if (locale.getLanguage().equals("it")) {

                    return "lunedì";

                } else if (locale.getLanguage().equals("de")) {

                    return "Montag";

                } else {

                    return "monday";

                }

            case Calendar.TUESDAY:

                if (locale.getLanguage().equals("hr")) {

                    return "utorak";

                } else if (locale.getLanguage().equals("it")) {

                    return "martedì";

                } else if (locale.getLanguage().equals("de")) {

                    return "Dienstag";

                } else {

                    return "tuesday";

                }

            case Calendar.WEDNESDAY:

                if (locale.getLanguage().equals("hr")) {

                    return "srijeda";

                } else if (locale.getLanguage().equals("it")) {

                    return "mercoledì";

                } else if (locale.getLanguage().equals("de")) {

                    return "Mittwoch";

                } else {

                    return "wednesday";

                }

            case Calendar.THURSDAY:

                if (locale.getLanguage().equals("hr")) {

                    return "četvrtak";

                } else if (locale.getLanguage().equals("it")) {

                    return "giovedì";

                } else if (locale.getLanguage().equals("de")) {

                    return "Donnerstag";

                } else {

                    return "thursday";

                }

            case Calendar.FRIDAY:

                if (locale.getLanguage().equals("hr")) {

                    return "petak";

                } else if (locale.getLanguage().equals("it")) {

                    return "venerdì";

                } else if (locale.getLanguage().equals("de")) {

                    return "Freitag";

                } else {

                    return "friday";

                }

​

            default:

                return "";

        }

    }

​

    public static boolean firstDatePeriodIsInSecondDatePeriod(Date from, Date to, Date periodFrom, Date periodTo) {

        final long timeFrom = from.getTime();

        final long timePeriodFrom = periodFrom.getTime();

        final long timeTo = to.getTime();

        final long timePeriodTo = periodTo.getTime();

​

        if (timeFrom <= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodTo && timeTo <= timePeriodTo) {

            return true;

        }

​

        if (timeFrom >= timePeriodTo && timeFrom <= timePeriodTo

                && timeTo >= timePeriodFrom && timeTo >= timePeriodTo) {

            return true;

        }

​

        if (timeFrom >= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodFrom && timeTo <= timePeriodTo) {

            return true;

        }

​

        if (timeFrom <= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodFrom && timeTo >= timePeriodTo) {

            return true;

        }

​

        return false;

    }

​

    /**

     * This returns true for 4 scenarios: # is date input             <br></br>

     * | is date period

     * <br></br>

     * 1. ####|##### |           <br></br>

     * 2. | ######## | (this one is inclusive)      <br></br>

     * 3. | #####|####       <br></br>

     * 4. ###|########|###        <br></br>

     *

     * @param from

     * @param to

     * @param periodFrom

     * @param periodTo

     * @return

     */

    public static boolean firstDatePeriodIsInSecondDatePeriodWithCorners(Date from, Date to, Date periodFrom, Date periodTo) {

        final long timeFrom = from.getTime();

        final long timePeriodFrom = periodFrom.getTime();

        final long timeTo = to.getTime();

        final long timePeriodTo = periodTo.getTime();

​

        if (timeFrom <= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodTo && timeTo <= timePeriodTo) {

            return true;

        }

​

        if (timeFrom > timePeriodTo && timeFrom < timePeriodTo

                && timeTo > timePeriodFrom && timeTo > timePeriodTo) {

            return true;

        }

​

        if (timeFrom >= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodFrom && timeTo <= timePeriodTo) {

            return true;

        }

​

        if (timeFrom <= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodFrom && timeTo >= timePeriodTo) {

            return true;

        }

​

        return false;

    }

​

    /**

     * This returns true for 4 scenarios: # is date input             <br></br>

     * | is date period

     * <br></br>

     * 1. ####|##### |           <br></br>

     * 2. |########| (this one is exclusive)        <br></br>

     * 3. | #####|####       <br></br>

     * 4. ###|########|###        <br></br>

     *

     * @param from

     * @param to

     * @param periodFrom

     * @param periodTo

     * @return

     */

    public static boolean dateInputContainsInDatePeriod(Date from, Date to, Date periodFrom, Date periodTo) {

        final long timeFrom = from.getTime();

        final long timePeriodFrom = periodFrom.getTime();

        final long timeTo = to.getTime();

        final long timePeriodTo = periodTo.getTime();

​

        if (timeFrom <= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodFrom && timeTo <= timePeriodTo) {

            return true;

        }

​

        if (timeFrom >= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodFrom && timeTo <= timePeriodTo) {

            return true;

        }

​

        if (timeFrom >= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodFrom && timeTo >= timePeriodTo) {

            return true;

        }

​

        if (timeFrom <= timePeriodFrom && timeFrom <= timePeriodTo

                && timeTo >= timePeriodFrom && timeTo >= timePeriodTo) {

            return true;

        }

​

        return false;

    }

​

    public static String dateArrayToString(List<Date> possibleAllocDates, String pattern) {

        if (possibleAllocDates == null || possibleAllocDates.isEmpty()) {

            return "[]";

        }

        StringBuilder dateArray = new StringBuilder();

        dateArray.append("[");

        for (Date date : possibleAllocDates) {

            dateArray.append("'");

            dateArray.append(dateToString(date, pattern));

            dateArray.append("',");

        }

        dateArray.deleteCharAt(dateArray.length() - 1);

        dateArray.append("]");

        return dateArray.toString();

    }

​

​

    public static DateTime toFirstSecondOfDay(Date date) {

        return new DateTime(date).withTimeAtStartOfDay().plusSeconds(1);

    }

​

    public static DateTime toLastSecondOfDay(Date date) {

        return new DateTime(date).withTimeAtStartOfDay().plusDays(1).minusSeconds(1);

    }

​

    public static Date StringToDate(String date, String pattern) {

        if (date != null) {

            try {

                SimpleDateFormat sdf = new SimpleDateFormat(pattern);

                return sdf.parse(date);

            } catch (ParseException ex) {

                ex.printStackTrace();

            }

        }

        return null;

    }

​

​

    public static String dateToStringWithLocale(Date date, Locale locale) {

        SimpleDateFormat f = new SimpleDateFormat("dd.MM.yyyy", locale);

        return f.format(date);

    }

​

    /**

     * Calendar.SATURDAY = 7 Javascript.SATURDAY = 6

     *

     * Calendar.SUNDAY = 1 Javascript.SUNDAY = 0

     *

     * Calendar.MONDAY = 2 Javascript.MONDAY = 1

     *

     * Calendar.TUESDAY = 3 Javascript.TUESDAY = 2

     *

     * Calendar.WEDNESDAY = 4 Javascript.WEDNESDAY = 3

     *

     * Calendar.THURSDAY = 5 Javascript.THURSDAY = 4

     *

     * Calendar.FRIDAY = 6 Javascript.FRIDAY = 5

     *

     * @param bookingDay

     * @return SUNDAY(0) if cant resolve

     */

    public static int resolveJavascriptBookingDay(int bookingDay) {

        switch (bookingDay) {

            case 7:

                return 6;

            case 1:

                return 0;

            case 2:

                return 1;

            case 3:

                return 2;

            case 4:

                return 3;

            case 5:

                return 4;

            case 6:

                return 5;

        }

        return 0;

    }

​

    public static int convertCalendarDayToJodaDay(int day) {

        return ((day + 5) % 7) + 1;

    }

    public static int convertJodaDayToCalendarDay(int day){

        if(day == 7){

            return 1;

        }

        return day++;

    }

​

​

​

    public static String getDayOfWeek(java.util.Date date, Locale locale) {

        return getDayOfWeek(date.toInstant().atZone(java.time.ZoneId.systemDefault()).toLocalDate(), locale);

    }

​

    public static String getDayOfWeek(java.time.LocalDate date, Locale locale) {

        java.time.DayOfWeek day = date.getDayOfWeek();

        return day.getDisplayName(java.time.format.TextStyle.FULL, locale);

    }

​

    public static java.time.LocalDate convertDateToJavaTimeLocalDate(Date date) {

        return date.toInstant()

                .atZone(ZoneId.systemDefault())

                .toLocalDate();

    }

​

    public static Date convertJavaTimeLocalDateToDate(java.time.LocalDate date) {

        return Date.from(date.atStartOfDay(ZoneId.systemDefault()).toInstant());

    }

​

    public static java.time.LocalDateTime convertToLocalDateTimeViaInstant(Date dateToConvert) {

        return dateToConvert.toInstant()

                .atZone(ZoneId.systemDefault())

                .toLocalDateTime();

    }

    public static Date convertToDateViaInstant(java.time.LocalDateTime dateToConvert) {

        return java.util.Date

                .from(dateToConvert.atZone(ZoneId.systemDefault())

                        .toInstant());

    }

    public static boolean isPeriodOverlaping(Date from1, Date to1, Date from2, Date to2){

        return !from1.after(to2) && !to1.before(from2);

    }

}

    /*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package hr.stratusit.mavenproject1;

​

/**

 *

 * @author development

 */

import hr.stratusit.cbms.commonNew.DateUtils;

​

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collections;

import java.util.Comparator;

import java.util.Date;

import java.util.LinkedList;

import java.util.List;

import java.util.ListIterator;

import java.util.Random;

import java.util.function.Predicate;

​

/**

 *

 * @author development

 */

public class FindPriorityPeriodsList {

​

    Date periodFrom;

    Date periodTo;

    Integer priority;

    Predicate<Object> mergeConditions;

​

    public FindPriorityPeriodsList(Date periodFrom, Date periodTo, Integer priority) {

​

        this.periodFrom = periodFrom;

        this.periodTo = periodTo;

        this.priority = priority;

    }

​

    public FindPriorityPeriodsList(FindPriorityPeriodsList FPPL) {

​

        this.periodFrom = FPPL.periodFrom;

        this.periodTo = FPPL.periodTo;

        this.priority = FPPL.priority;

​

    }

​

    public boolean mergeConditions(Object o) {

        if (o == this) {

            return true;

        }

​

        if (!(o instanceof FindPriorityPeriodsList)) {

            return false;

        }

​

        return true;

    }

​

    public static void main(String args[]) {

        List<FindPriorityPeriodsList> testFindPriorityPeriodsList = new ArrayList<>();

​

        Date periodFrom = new Date(2022, 1, 2);

        Date periodTo = new Date(2022, 1, 4);

        int random = 10000;

        FindPriorityPeriodsList testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        periodFrom = new Date(2022, 1, 3);

        periodTo = new Date(2022, 1, 6);

        random = 9000;

        testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        periodFrom = new Date(2022, 1, 1);

        periodTo = new Date(2022, 1, 5);

        random = 8000;

        testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        periodFrom = new Date(2022, 1, 3);

        periodTo = new Date(2022, 1, 7);

        random = 7000;

        testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        periodFrom = new Date(2022, 1, 2);

        periodTo = new Date(2022, 1, 10);

        random = 6000;

        testObject = new FindPriorityPeriodsList(periodFrom, periodTo, random);

        testFindPriorityPeriodsList.add(testObject);

​

        LinkedList<FindPriorityPeriodsList> resultOfTest = priorityPeriodsList(testFindPriorityPeriodsList);

        System.out.println("result");

    }

​

    public static int randomNumber(int min, int max) {

​

        return min + (int) (Math.random() * ((max - min) + 1));

    }

​

    public static Date randomDate(int min, int max) {

​

        int year = randomNumber(min, max); // generate a year between 1900 and 2010;

        int dayOfYear = randomNumber(1, 10);// generate a number between 1 and 365 (or 366 if you need to handle leap year);

        Calendar calendar = Calendar.getInstance();

        calendar.set(Calendar.YEAR, year);

        calendar.set(Calendar.DAY_OF_YEAR, dayOfYear);

        return calendar.getTime();

​

    }

​

    private static LinkedList<FindPriorityPeriodsList> priorityPeriodsList(List<FindPriorityPeriodsList> listOfPeriods) {

​

        LinkedList<FindPriorityPeriodsList> result = new LinkedList<>();

​

        Collections.sort(listOfPeriods, new Comparator<FindPriorityPeriodsList>() {

            @Override

            public int compare(FindPriorityPeriodsList o1, FindPriorityPeriodsList o2) {

                return o2.priority.compareTo(o1.priority);

            }

        });

        if (listOfPeriods.isEmpty()) {

            return result;

        }

        result.add(listOfPeriods.get(0));

        listOfPeriods.remove(0);

        FindPriorityPeriodsList c;

        for (FindPriorityPeriodsList cip : listOfPeriods) {

            FindPriorityPeriodsList first = result.getFirst();

            if (cip.periodFrom.before(first.periodFrom)) {

                 c = new FindPriorityPeriodsList(cip);

                if (cip.periodTo.before(first.periodFrom)) {

                    result.addFirst(c);

                    continue;

​

                } else {

                    c.periodFrom = cip.periodFrom;

                    c.periodTo= cip.periodTo;

​