@Retention(value=RUNTIME)
 @Target(value=TYPE)
public @interface Sortable
  @Sortable class Person {
     String first
     String last
     Integer born
 }
 
 The generated Groovy class will:
 Comparable interfacecompareTo method based on the first,
     last and born properties (priority ordering will be according
     to the ordering of property definition, highest first, unless 'includes' is used; in which case,
     priority will be according to the order given in the includes list)Comparator methods named comparatorByFirst,
     comparatorByLast and comparatorByBornComparable or @Sortable.
 More examples:
 //--------------------------------------------------------------------------
 import groovy.transform.Sortable
 import groovy.transform.ToString
 @Sortable
 @ToString
 class Course {
     // Order of properties determines priority when sorting
     String title
     Date beginDate
     Integer maxAttendees  // int doesn't implement Comparable, so use Integer
 }
 final Course groovy = new Course(
         title: 'Groovy', beginDate: new Date() + 7, maxAttendees: 40)
 final Course groovy2 = new Course(
         title: 'Groovy', beginDate: new Date() + 2, maxAttendees: 50)
 final Course grails = new Course(
         title: 'Grails', beginDate: new Date() + 1, maxAttendees: 20)
 final List<Course> courses = [groovy, groovy2, grails]
 assert courses.last().title == 'Grails'
 // Use toSorted() method to sort
 final List<Course> sorted = courses.toSorted()
 assert sorted.first().title == 'Grails'
 assert sorted.last().title == 'Groovy'
 assert sorted.maxAttendees == [20, 50, 40]
 
 
 //--------------------------------------------------------------------------
 // Order of fields for includes determines priority when sorting
 import groovy.transform.Sortable
 import groovy.transform.ToString
 @Sortable(includes = ['title', 'maxAttendees'])
 // Or @Sortable(excludes = ['beginDate'])
 @ToString
 class Course {
     String title
     Date beginDate
     Integer maxAttendees
 }
 final Course groovy = new Course(
         title: 'Groovy', beginDate: new Date() + 7, maxAttendees: 40)
 final Course groovy2 = new Course(
         title: 'Groovy', beginDate: new Date() + 2, maxAttendees: 50)
 final Course grails = new Course(
         title: 'Grails', beginDate: new Date() + 1, maxAttendees: 20)
 final List<Course> courses = [groovy, groovy2, grails]
 // Use toSorted() method to sort
 final List<Course> sorted = courses.toSorted()
 assert sorted.first().title == 'Grails'
 assert sorted.last().title == 'Groovy'
 assert sorted.maxAttendees == [20, 40, 50]
 //--------------------------------------------------------------------------
 // Static methods to create comparators.
 final Comparator byMaxAttendees = Course.comparatorByMaxAttendees()
 final List<Course> sortedByMaxAttendees = courses.sort(false, byMaxAttendees)
 assert sortedByMaxAttendees.maxAttendees == [20, 40, 50]
 // beginDate is not used for sorting
 assert sortedByMaxAttendees[2].beginDate < sortedByMaxAttendees[1].beginDate
 assert Course.declaredMethods.name.findAll { it.startsWith('comparatorBy') }.toSorted() == ['comparatorByMaxAttendees', 'comparatorByTitle']
 //--------------------------------------------------------------------------
 // Sorting by max attendees using reversed order
 import groovy.transform.Sortable
 import groovy.transform.ToString
 @Sortable(includes = ['points'], reversed = true)
 @ToString
 class LeaderBoardEntry {
     String team
     int points
 }
 final LeaderBoardEntry teamA = new LeaderBoardEntry(team: "Team A", points: 30)
 final LeaderBoardEntry teamB = new LeaderBoardEntry(team: "Team B", points: 80)
 final LeaderBoardEntry teamC = new LeaderBoardEntry(team: "Team C", points: 50)
 final List<LeaderBoardEntry> leaderBoard = [teamA, teamB, teamC].toSorted()
 assert leaderBoard.first().team == 'Team B'
 assert leaderBoard.last().team == 'Team A'
 assert leaderBoard.points == [80, 50, 30]
 | Modifier and Type | Optional Element and Description | 
|---|---|
| java.lang.String[] | excludesProperty names to exclude in the comparison algorithm. | 
| java.lang.String[] | includesProperty names to include in the comparison algorithm. | 
| boolean | reversedSet to true so that comparator uses reversed natural order. | 
public abstract java.lang.String[] includes