Issue with Time Calculation in Java

In a screening test I've been asked to write a program to get the maximum free time available during a day.

For example :
>Input: "10:00AM-12:30PM","02:00PM-02:45PM","09:10AM-09:50AM"
<br>Expected Output: 01:30

These time ranges may not be in increasing order.

For this issue I've tried to write a small code in java as :

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.time.Duration;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
public class TimeDiff {
public static void main(String[] args) throws NullPointerException {
String accStr = null;
System.out.println("Enter day time entries : ");
try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
accStr = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
String unQuoted = accStr.replace("\"", "");
String[] inputSplit = unQuoted.split(",");
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("hh:mma");
Map<LocalTime, LocalTime> timeMap = new TreeMap<>();
for (String x : inputSplit) {
String[] furtherSplit = x.split("-");
timeMap.put(LocalTime.parse(furtherSplit[0], dateTimeFormatter), LocalTime.parse(furtherSplit[1], dateTimeFormatter));
}
Iterator iterator = timeMap.entrySet().iterator();
List<Long> duration = new ArrayList<Long>();
LocalTime[][] convertedMaptoArray = new LocalTime[timeMap.size()][2];
int rowIndex = 0;
while (iterator.hasNext()) {
int colIndex = 0;
Map.Entry pair = (Map.Entry) iterator.next();
//System.out.println(pair.getKey() + " " + pair.getValue());
convertedMaptoArray[rowIndex][colIndex] = (LocalTime) pair.getKey();
convertedMaptoArray[rowIndex][colIndex+1]=(LocalTime)pair.getValue();
rowIndex++;
}
LocalTime previousRecordEndTime = null;
LocalTime currentRecordStartTime = null;
for(int i= 0; i<=convertedMaptoArray.length-1;i++)
{
currentRecordStartTime = convertedMaptoArray[i][0];
//System.out.println("current :" +currentRecordStartTime);
if(i>0){
previousRecordEndTime = convertedMaptoArray[i-1][1];
//System.out.println("Previous : " + previousRecordEndTime);
duration.add(ChronoUnit.MINUTES.between(previousRecordEndTime, currentRecordStartTime));
}
}
System.out.println("Longest duration : " + LocalTime.MIN.plus(Duration.ofMinutes(Collections.max(duration))).toString());
}
}

I was screened out but I've few questions regarding above code :

1. How this code can be optimized more?
2. Is there any coding rule which above code is breaking?
3. What should be better approach to calculate time in Java?

Please help. Thanks in advance.

I would argue that you are breaking KISS (overcomplicating things) and, at the same time, mixing 2 very different responsibilities: that of parsing the input, and that of calculating intervals - of which you are only interested in the shortest, so storing everything is not necessary.

Is the input assumed to be a string entered through the console?

I have broken it up into the following methods:

// 01:00AM -> 60
private static int timeStringToMinutesFromMidnight(String time)
// 60 -> 01:00
private static String minutesToHoursAndMinutes(int minutes)
// 11:00AM-11:30AM -> 660 690 added to list
private static void parseInterval(String interval, List<Integer> minutes)

(in a previous edit, I had timeStringIntervalToMinutes, but I had misread the question and was calculating the wrong output).

You do not need any complicated data-structure here: a simple List allows you to do everything required. Sorting it is easier than working with a TreeMap or a TreeSet- yes, they do their own sorting, but are also much heavier in terms of footprint and access speed.

Complete code (imports java.util.* and java.io.*):

// 01:00AM -> 60
private static int timeStringToMinutesFromMidnight(String time) {
int hours = Integer.parseInt(time.substring(0,"hh".length()));
int minutes = Integer.parseInt(time.substring("hh:".length(), "hh:mm".length()));
boolean afternoon = time.substring("hh:mm".length()).equalsIgnoreCase("PM");
if (afternoon && hours != 12) {
hours += 12;
}
return hours * 60 + minutes;
}
// 60 -> 01:00
private static String minutesToHoursAndMinutes(int minutes) {
int hours = minutes / 60;
minutes = minutes % 60;
return String.format("%02d:%02d", hours, minutes);
}
// 11:00AM-11:30AM -> 660 690 added to list
private static void parseInterval(String interval, List<Integer> minutes) {
String[] parts = interval.split("-");
int start = timeStringToMinutesFromMidnight(parts[0]);
int end = timeStringToMinutesFromMidnight(parts[1]);
if (end < start) {
throw new IllegalArgumentException("interval " + interval + " has end<start");
}
minutes.add(start);
minutes.add(end);
} 
// Input: "10:00AM-12:30PM","02:00PM-02:45PM","09:10AM-09:50AM"
// Expected Output: 01:30
public static void main(String ... args) {
List<Integer> endpoints = new ArrayList<>();
try (Scanner sc = new Scanner(System.in).useDelimiter("[,\"]+")) {
while (sc.hasNext()) {
parseInterval(sc.next(), endpoints);
}
}
if (endpoints.isEmpty()) {
System.out.println("No intervals found");
return;
}
// sort the endpoints (assuming that no intervals overlap, intervals will not be broken)
Collections.sort(endpoints);
int largest = -1;
for (int i=1; i<endpoints.size()-1; i+=2) {
largest = Math.max(largest,  endpoints.get(i+1) - endpoints.get(i));
}        
System.out.println(minutesToHoursAndMinutes(largest));
}

I suggest:

• Don’t use a Map for your entries. Use a pair class or define a TimeRange class that can hold two LocalTime objects. And then make a collection of those.
• Even if you want to use a Map, don’t use a raw Map.Entry. Parameterize as Map.Entry<LocalTIme, LocalTime>. Similarly parameterize your iterator. (On the other hand the type parameter in new ArrayList<Long>() is redundant; just new ArrayList<>() would be conventional.)
• Don’t use Long for durations. Just use the Duration class throughout. Use its compareTo method for comparison.
• I’d split the string into time ranges first and then remove only leading and trailing quotes. This gives a degree of input validation.
• For finding the max free duration I would use a built-in max method, for example the two-arg Collections.max(). I’d pass a list obtained from Arrays.asList(), or even better, avoid arrays and keep the durations in a list exclusively. And then of course an appropriate Comparator implementation.