Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Easy Fine-Grained Sorting With JDK 8

DZone's Guide to

Easy Fine-Grained Sorting With JDK 8

Let's dip back into Java 8's streams and static/default methods to see how we can use those tools on a Comparator interface for simple, powerful sorting.

· Java Zone ·
Free Resource

Distribute microservices between the private and public clusters, yet maintain bi-directional connectivity. Content provided by IBM Developer.

Java 8's introduction of streams and useful static/default methods on the Comparator interface make it easy to compare two objects based on individual fields' values without the need to implement a compare(T,T) method on the class whose objects are being compared.

I'm going to use a simple Song class to help demonstrate this and its Song.java code listing is shown next.

Song.java

package dustin.examples.jdk8;

/**
 * Simple class encapsulating details related to a song
 * and intended to be used for demonstration of JDK 8.
 */
public class Song {
    /** Song title. */
    private final String title;

    /** Album on which song was originally included. */
    private final String album;

    /** Song's artist. */
    private final String artist;

    /** Year song was released. */
    private final int year;

    /**
     * Constructor accepting this instance's title, artist, and release year.
     *
     * @param newTitle Title of song.
     * @param newAlbum Album on which song was originally included.
     * @param newArtist Artist behind this song.
     * @param newYear Year song was released.
     */
    public Song(final String newTitle, final String newAlbum,
        final String newArtist, final int newYear) {
        title = newTitle;
        album = newAlbum;
        artist = newArtist;
        year = newYear;
    }

    public String getTitle() {
        return title;
    }

    public String getAlbum() {
        return album;
    }

    public String getArtist() {
        return artist;
    }

    public int getYear() {
        return year;
    }

    @Override
    public String toString() {
        return "'" + title + "' (" + year + ") from '" + album + "' by " + artist;
    }
}


The Song class whose listing was just shown lacks a compare method, but we can still compare instances of this class in JDK 8 very easily. Based on the class definition of Song just shown, the following code can be used to sort a List of song instances based, in order, on year released, artist, and finally album.

Sorting List of Songs by Year, Artist, and Album (in that order)

/**
 * Returns a sorted version of the provided List of Songs that is
 * sorted first by year of song's release, then sorted by artist,
 * and then sorted by album.
 *
 * @param songsToSort Songs to be sorted.
 * @return Songs sorted, in this order, by year, artist, and album.
 */
private static List < Song > sortedSongsByYearArtistAlbum(
    final List < Song > songsToSort) {
    return songsToSort.stream()
        .sorted(
            Comparator.comparingInt(Song::getYear)
            .thenComparing(Song::getArtist)
            .thenComparing(Song::getAlbum))
        .collect(Collectors.toList());
}


The above code listing would have been slightly less verbose had I statically imported the Comparator and the Collectors, but it's still fairly concise to include those interface and class names in the listing and probably more useful for an introductory blog post on this subject.

In the above code listing, the static default methods Comparator.comparingInt and Comparator.thenComparing are used to sort the stream of Song associated with the underlying List by year, and then by artist, and finally by album. The code is highly readable and allows for comparison of objects (and resulting sorting of those instances) based on arbitrary individual accessor methods without need for an explicitly specified Comparator (natural sorting order used for each compared accessor result). Note that if an explicit Comparator is desired, it can be provided to these static default methods via overloaded methods of the same name that accept a Comparator.

The next code listing is the entire demonstration class. It includes the method just shown and also shows the contrived example constructed of an unsorted List of songs.

FineGrainSortingDemo.java

package dustin.examples.jdk8;

import static java.lang.System.out;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Demonstration of easy fine-grained sorting in JDK 8 via
 * stream support for sorting and Comparator's static and
 * default method implementations.
 */
public class FineGrainSortingDemo {
    /**
     * Construct List of {@code Song}s.
     * 
     * @return Instances of {@code Song}.
     */
    private static List < Song > generateSongs() {
        final ArrayList < Song > songs = new ArrayList < > ();
        songs.add(
            new Song(
                "Photograph",
                "Pyromania",
                "Def Leppard",
                1983));
        songs.add(
            new Song(
                "Hysteria",
                "Hysteria",
                "Def Leppard",
                1987));
        songs.add(
            new Song(
                "Shout",
                "Songs from the Big Chair",
                "Tears for Fears",
                1984));
        songs.add(
            new Song(
                "Everybody Wants to Rule the World",
                "Songs from the Big Chair",
                "Tears for Fears",
                1985));
        songs.add(
            new Song(
                "Head Over Heels",
                "Songs from the Big Chair",
                "Tears for Fears",
                1985
            ));
        songs.add(
            new Song(
                "Enter Sandman",
                "Metallica",
                "Metallica",
                1991
            )
        );
        songs.add(
            new Song(
                "Money for Nothing",
                "Brothers in Arms",
                "Dire Straits",
                1985
            )
        );
        songs.add(
            new Song(
                "Don't You (Forget About Me)",
                "A Brass Band in African Chimes",
                "Simple Minds",
                1985
            )
        );
        return songs;
    }

    /**
     * Returns a sorted version of the provided List of Songs that is
     * sorted first by year of song's release, then sorted by artist,
     * and then sorted by album.
     *
     * @param songsToSort Songs to be sorted.
     * @return Songs sorted, in this order, by year, artist, and album.
     */
    private static List < Song > sortedSongsByYearArtistAlbum(
        final List < Song > songsToSort) {
        return songsToSort.stream()
            .sorted(
                Comparator.comparingInt(Song::getYear)
                .thenComparing(Song::getArtist)
                .thenComparing(Song::getAlbum))
            .collect(Collectors.toList());
    }

    /**
     * Demonstrate fine-grained sorting in JDK 8.
     *
     * @param arguments Command-line arguments; none expected.
     */
    public static void main(final String[] arguments) {
        final List < Song > songs = generateSongs();
        final List < Song > sortedSongs = sortedSongsByYearArtistAlbum(songs);
        out.println("Original Songs:");
        songs.stream().forEach(song - > out.println("\t" + song));
        out.println("Sorted Songs");
        sortedSongs.forEach(song - > out.println("\t" + song));
    }
}


The output from running the above code is shown next and lists the newly ordered Songs after using the sorting code. It's worth noting that this stream.sorted() operation does not change the original List (it acts upon the stream rather than upon the List).

Original Songs:
 'Photograph' (1983) from 'Pyromania' by Def Leppard
 'Hysteria' (1987) from 'Hysteria' by Def Leppard
 'Shout' (1984) from 'Songs from the Big Chair' by Tears for Fears
 'Everybody Wants to Rule the World' (1985) from 'Songs from the Big Chair' by Tears for Fears
 'Head Over Heels' (1985) from 'Songs from the Big Chair' by Tears for Fears
 'Enter Sandman' (1991) from 'Metallica' by Metallica
 'Money for Nothing' (1985) from 'Brothers in Arms' by Dire Straits
 'Don't You (Forget About Me)' (1985) from 'A Brass Band in African Chimes' by Simple Minds
Sorted Songs
 'Photograph' (1983) from 'Pyromania' by Def Leppard
 'Shout' (1984) from 'Songs from the Big Chair' by Tears for Fears
 'Money for Nothing' (1985) from 'Brothers in Arms' by Dire Straits
 'Don't You (Forget About Me)' (1985) from 'A Brass Band in African Chimes' by Simple Minds
 'Everybody Wants to Rule the World' (1985) from 'Songs from the Big Chair' by Tears for Fears
 'Head Over Heels' (1985) from 'Songs from the Big Chair' by Tears for Fears
 'Hysteria' (1987) from 'Hysteria' by Def Leppard
 'Enter Sandman' (1991) from 'Metallica' by Metallica


JDK 8's introduction of streams and default and static methods in interfaces (particularly on Comparator in this case) make it easy to compare two objects field-by-field in a desirable order without any explicit Comparator other than the pre-built static default methods on the Comparator interface if the fields being compared have a desired natural order.

Use this tool to look at the contents of GitHub and classify code based on the programming language used.  Content provided by IBM Developer.

Topics:
java ,sorting ,java 8 ,comparator ,streams ,tutorial

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}