Java program to sort a list of date which is in format dd MMM yyyy

Question

Input is a list containing date in String format. I have solution as below. But i feel it can be made more efficient. Any help would be appreciated.

//Map to store month data

HashMap<String,String> month = new HashMap<String,String>();
        month.put("Jan","01");
        month.put("Feb","02");
        month.put("Mar","03");
        month.put("Apr","04");
        month.put("May","05");
        month.put("Jun","06");
        month.put("Jul","07");
        month.put("Aug","08");
        month.put("Sep","09");
        month.put("Oct","10");
        month.put("Nov","11");
        month.put("Dec","12");

You can consider this as input

    String[] input = {"20 Oct 2052",
    "26 May 1960",
    "06 Jun 1933",
    "06 Jun 1933",
    "06 Jun 1933",
};


    ArrayList<Long> temp1 = new ArrayList<Long>();

To compare result

    HashMap<Long,String> temp2 = new HashMap<Long,String>();

    ArrayList<String> result = new ArrayList<String>();
    for(int i = 0 ; i< input.length ; i++){
        String j = "";
        if(input[i].length() == 11){

            j+= input[i].substring(7,11);
            j+= month.get(input[i].substring(3,6));
            j+=input[i].substring(0,2);

            temp1.add(Long.parseLong(j));
            temp2.put(Long.parseLong(j), input[i]);   
        }
    }

Sorting the result

Collections.sort(temp1);

Printing the result

System.out.println(temp1.toString());

Answer 1

Radix Sort is your friend. Just sort strings with this algorithm. This is optimal solution.

Answer 2

Firstly I would parse the date strings into a Date Object

DateFormat format = new SimpleDateFormat("dd MMM yyyy", Locale.ENGLISH);
Date date = format.parse("26 May 1960");

You could create an object that holds a Date object then make it comparable.

public class DateContainer implements Comparable<DateContainer > {
 private Date dateTime;

 public DateContainer (Date date){
  this.dateTime = date;
 }

 public Date getDateTime() {
  return dateTime;
 }

 public void setDateTime(Date datetime) {
  this.dateTime = datetime;
 }

 @Override
 public int compareTo(DateContainer o) {
   return getDateTime().compareTo(o.getDateTime());
 }
}

Then you could create a list of the Object above then use Collections to sort it

Collections.sort(myList);

Answer 3

public static void main(String[] args) {
    SimpleDateFormat f = new SimpleDateFormat("dd MMM yyyy");
    String[] input = {"20 Oct 2052",
            "26 May 1960",
            "06 Jun 1933",
            "06 Jun 1933",
            "06 Jun 1933",
    };
    Map<Long, String> result = new TreeMap<>();
    Stream.of(input)
            .filter(s -> s.length() == 11)
            .forEach(s -> {
                try {
                    result.put(f.parse(s).getTime(), s);
                } catch (ParseException e) {
                    System.out.println("Wrong Format: " + s);
                }
            });
    System.out.println(result); // {-1154156400000=06 Jun 1933, -303033600000=26 May 1960, 2612970000000=20 Oct 2052}
}

Use SimpleDateFormat to get Date value and TreeMap to sorted elements in the map.

Hope that help you!!!!

Answer 4

This should do the trick

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd MMM yyyy");

List<Date> dates = Arrays.stream(input).map(dateString -> {
try {
    return simpleDateFormat.parse(dateString);
} catch (ParseException e) {
    e.printStackTrace();
}
    return null;
}).collect(Collectors.toList());
dates.sort(Comparator.naturalOrder());

dates.forEach(date -> System.out.println(simpleDateFormat.format(date)));

this is a 2 step process

1. Convert to java.util.Date
2. Sort the Date list and Print

Hope this helps!

Good luck!

Answer 5

tl;dr

This is a one-liner using modern java.time classes and lambda syntax.

Parse each string into a LocalDate, collect, sort, and regenerate strings as output.

Arrays.stream(
        new String[] { "20 Oct 2052" , "26 May 1960" , "06 Jun 1933" , "06 Jun 1933" , "06 Jun 1933" }
)
        .map( input -> LocalDate.parse( input , DateTimeFormatter.ofPattern( "dd MMM uuuu" , Locale.US ) ) )
        .sorted()
        .map( date -> date.format( DateTimeFormatter.ofPattern( "dd MMM uuuu" , Locale.US ) ) )
        .collect( Collectors.toList() )
        .toString()

[06 Jun 1933, 06 Jun 1933, 06 Jun 1933, 26 May 1960, 20 Oct 2052]

Steps:

• Generate a stream of your array's elements (the string inputs).
• Process each input, parsing to get a LocalDate
• Sort the LocalDate objects
• On each LocalDate, generate text representing its value.
• Collect each of those generated strings into a List.
• Generate text representing the list of strings, now sorted in chronological order.

Smart objects, not dumb strings

Use appropriate data types rather than mere strings.

For a date-only value without time-of-day and without time zone, use LocalDate class.

Define a formatting pattern to match your inputs.

DateTimeFormatter f = DateTimeFormatter.ofPattern( "dd MMM uuuu" , Locale.US );

Loop the inputs, parsing each into a LocalDate. Collect each resulting LocalDate into a List.

    List < LocalDate > dates = new ArrayList <>( inputs.length );
    for ( String input : inputs ) {
        LocalDate ld = LocalDate.parse( input , f );
        dates.add( ld );
    }

Or instead, use the short and sweet lambda syntax.

List < LocalDate > dates = Arrays.stream( inputs ).map( input -> LocalDate.parse( input , f ) ).collect( Collectors.toList() );

Sort the list of LocalDate objects.

Collections.sort( dates );

Report your sorted dates in standard ISO 8601 format.

String outputs = dates.toString() ;

[1933-06-06, 1933-06-06, 1933-06-06, 1960-05-26, 2052-10-20]

Report your sorted dates in any desired format.

   List < String > outputs = new ArrayList <>( dates.size() );
    for ( LocalDate date : dates ) {
        outputs.add( date.format( f ) );
    }

[06 Jun 1933, 06 Jun 1933, 06 Jun 1933, 26 May 1960, 20 Oct 2052]

---

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.

The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.

You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes.

Where to obtain the java.time classes?

• Java SE 8, Java SE 9, Java SE 10, Java SE 11, and later - Part of the standard Java API with a bundled implementation.
  • Java 9 adds some minor features and fixes.
• Java SE 6 and Java SE 7
  • Most of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
• Android
  • Later versions of Android bundle implementations of the java.time classes.
  • For earlier Android (<26), the ThreeTenABP project adapts ThreeTen-Backport (mentioned above). See How to use ThreeTenABP….

The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval, YearWeek, YearQuarter, and more.