java8 rules

+1 for using Java 8 features.

I think it's better to use the primitive specializations of Comparator.comparing() for primitive keys, that is comparingDouble() for the CGPA and comparingInt() for the ID. This way we can avoid unneccessary boxing.

My next thaught: "Consider implementing Comparable" (check Joshua Bloch's "Effective Java")?

Finally, using Java 8 we could even read the input data and generate a sorted list in one go:

class Student implements Comparable<Student> {
  // ...
  private static final Comparator<Student> comp =
    Comparator.comparingDouble(Student::getCgpa).reversed()
              .thenComparing(Student::getFname)
              .thenComparingInt(Student::getId);
  // ...
  @Override
  public int compareTo(final Student other) {
    return comp.compare(this, other);
  }
}

public class Solution {
  public static void main(final String[] args) {
    final Scanner in = new Scanner(System.in);
    final int numTestCases = in.nextInt();
    in.nextLine();
    
    final List<Student> students = Stream.generate(() ->
        new Student(in.nextInt(),
                    in.next(),
                    in.nextDouble())
      ).limit(numTestCases).sorted().collect(toList());
        
    for (Student student : students) {
      System.out.println(student.getFname());
    }
  }
}

Here is my solution:

studentList.stream().sorted(Comparator.comparingDouble(Student::getCgpa).reversed().thenComparing(Comparator.comparing(Student::getFname)).thenComparing(Comparator.comparingInt(Student::getId))).map(Student::getFname).forEach(System.out::println);

Comparator.comparing basically takes place of overriding the compareTo method, correct?

Hi, Comparator.comparing(Student :: getCgpa).reversed().

Why are you using reversed() for only Cgpa comparison?

How to do the same thing in Java 7? It is showing some erros in java 7

   Collections.sort(studentList,  Comparator.comparing(Student :: getCgpa).reversed().

         what is the use of reveresed here???

May as well go all the way and use a stream

public class Solution
{
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		int testCases = Integer.parseInt(in.nextLine());
		
		List<Student> studentList = new LinkedList<Student>();
		while(testCases>0){
			int id = in.nextInt();
			String fname = in.next();
			double cgpa = in.nextDouble();
			
			Student st = new Student(id, fname, cgpa);
			studentList.add(st);
			
			testCases--;
		}
        studentList.stream().sorted(
            Comparator.comparing(Student::getCgpa).reversed()
            .thenComparing(Student::getFname)
            .thenComparing(Student::getId))
            .map(Student::getFname).forEach(System.out::println);
	}

Issue solved..really silly from my end!!!

Amazing

I implemented in a basic way.

    Comparator<Student> com=new Comparator<Student>()
    {
        public int compare(Student s1, Student s2){
            if(s1.getCgpa()>s2.getCgpa())
                return -1;
            else if(s1.getCgpa()<s2.getCgpa())
                return 1;
            else{
                if(s1.getFname().compareTo(s2.getFname())>0)
                    return 1;
                else
                    return -1 ;   
            }        
        }
    };

    Collections.sort(studentList, com);

int testCases = Integer.parseInt(in.nextLine());

  List<Student> studentList = new ArrayList<Student>();

        i am not getting this 

Can you explain this solution Collection.sort() line

instead of while loop if i try for loop i got wrong answer. can anyone help me to write for loop for program.

Nice - but how would you write unit tests that exercise all the combinations of the sorting? Making the Student class Comparable, or at least having a separate Comparator, would help greatly with testing.

This solution shows wrong answer.

It makes compilation error as I tried. It seems that this code has no syntax error, maybe hackerrank system has a problem.