Sorting order

[C Kushtawar]

Can someone explain me how does sorting work here.When -1 is returned from compareTo then the elements are arranged in insertion order but when a 1 is returned then the elements are arranged in reverse of the insertion order.How does it actually work.I get confused sometimes.Is there any clue on the basis of which we can decide the sorting order.
Thanks in advance.Below is the code for reference.

import java.util.Arrays;

class Ques02 {
public static void main(String[] args) {
Object[] persons = {new Person(20), new Person(30),
new Person(10)};
Arrays.sort(persons);
System.out.println(((Person)persons[0]).getAge());
System.out.println(((Person)persons[1]).getAge());
System.out.println(((Person)persons[2]).getAge());
}
}
class Person implements Comparable<Person>{
int age;
public Person(int age){
this.age = age;
}
public int getAge(){
return age;
}
@Override
public int compareTo(Person o) {
return 1;
}
}

[Ruben Soto]

Please, give the source of this question (according to JavaRanch policy.)

Thanks.

[raghuram vadlamani]

well compareTo of comparable interface returns int as you know in that -1 is if the passed object is greater than the invoking object meaningfully(this one depends on your parameter), in the above specified one i think you want to sort based on age .Wrapper classes and String has already implemented Comparable based on natural ordering so if you change the age into Integer and return type of getAge as Integer then person[0].getAge().compareTo(person[1].getAge) will give you -1 as 20 is < 30 so for descending order just interchange the above ,

hope that you understood

[C Kushtawar]

Ok this question is from javaBeats forum.

Hi vadlamani ,

I think here the only sorting is bing done on the insertion oder not on age.
Can you explain this?
Thanks.

[raghuram vadlamani]

Hai Kushtwar,

Arrays.sort uses Modified MergeSort algorithm for sorting and API says that it does it in natural ordering of the element and ordering means it has to make some sense rather than random arrangement and the API specifys that it arranges it in ascending order so based on this best way to understand it is using bubble sort as it is the simplest sorting algorithm useful for small list

{person[0],person[1],person[2]} well with natural ordering i.e least will be first so

person[0].compareTo(person[1]) which returns 1 think like >0,0,<0 rather than 1 , 0, -1 as you will get the same output if you return 1,11,11121.... any postive number greater than 0(ofcourse has to be compatible with int )

so person[0] is greater than person[1] now according to bubble sort swap them

then you will have
{person[1],person[0],person[2]}

now person[0].compareTo(person[2]) which is also positive so person[0] is greatest of three so now list will be {person[1],person[2],person[0]}

now person[1].compareTo(person[2]) and person[1] is greater than person[2] so the least is person[2] and obviously the list will be
{person[2],person[1],person[0]}

now using the same least will be first principle if negative number is returned from compareTo then person[0] will be the least then successive comparasion will be same and thus no effect it is the same with 0

I hope you understood

[C Kushtawar]

Hi Vandlamani,


Can you make me understand the following code.Could you crosscheck my below understanding.

 
public static void main(String[]args){
String[]words={"Good","Bad"};
Comparator<Strings>best=new Comparator<String>(){
public int compare(String s1,String s2){
return s2.charAt(1)-s1.charAt(1);
}
};
Arrays.sort(words,best);
System.out.println(words[0]);
}
}

My understanding:

Here s1=Good
s2=Bad
s2.charAt(1)-s1.charAt(1) will return negative number then s2<s1 then the order should be Bad,Good which means words[0] Bad
but that is not the correct answer. I know I am wrong but where ;please help me clearing this concept.

Regards,
Chandan

Hi team,request to provide some response to it.