I found the solution using Comparator, but not using comparable

package Package1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Cricketer {
    int runs;
    String name;

    public Cricketer(String name, int runs) {
        super();
        this.name = name;
        this.runs = runs;
    }

    @Override
    public String toString() {
        return name + "    " + runs;
    }

    public static void main(String[] args) {
        Comparator<Cricketer> comp = Comparator.comparingInt(i -> i.runs);
//        Comparator<Cricketer> comp = (I1, I2) -> Integer.compare(I1.runs, I2.runs);
        List<Cricketer> cricketers = new ArrayList<Cricketer>();
        cricketers.add(new Cricketer("Bradman", 9996));
        cricketers.add(new Cricketer("Sachin", 14000));
        cricketers.add(new Cricketer("Dravid", 12000));
        cricketers.add(new Cricketer("Ponting", 11000));
        System.out.println(cricketers); //[Bradman 9996,   Sachin 14000,  Dravid 12000,  Ponting 11000]
        Collections.sort(cricketers, comp);
        System.out.println(cricketers); //[Bradman 9996,   Ponting 11000, Dravid 12000,  Sachin 14000]
    }
}

Can anyone please help me find a solution using comparable?

This is using Comparator interface using Lambda Expressions in Core Java

package com.programming.class21;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Cricketer2 {

int runs;
/**
* @return the runs
*/
public int getRuns() {
return runs;
}

/**
* @param runs the runs to set
*/
public void setRuns(int runs) {
this.runs = runs;
}

String name;

public Cricketer2(String name, int runs) {
super();
this.name = name;
this.runs = runs;
}

@Override
public String toString() {
return name + " " + runs;
}

//Comparator<Cricketer2> comp = (that) -> this.runs > that.runs ? 1 : this.runs < that.runs ? -1 : 0; //
// 'Cricketer.this' cannot be referenced from a static context

static Comparator<Cricketer2> comp2 = (h1, h2) -> (h1.getRuns() - h2.getRuns());


public static void main(String[] args) {
List<Cricketer2> cricketers = new ArrayList<>();
cricketers.add(new Cricketer2("Bradman", 9996));
cricketers.add(new Cricketer2("Sachin", 14000));
cricketers.add(new Cricketer2("Dravid", 12000));
cricketers.add(new Cricketer2("Ponting", 11000));
System.out.println(cricketers);
Collections.sort(cricketers, comp2);
System.out.println(cricketers);
}

}

Using Comparable interface, we can do it simply like this:

package com.programming.class21;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Cricketer2 implements Comparable<Cricketer2>{

int runs;
/**
* @return the runs
*/
public int getRuns() {
return runs;
}

/**
* @param runs the runs to set
*/
public void setRuns(int runs) {
this.runs = runs;
}

String name;

public Cricketer2(String name, int runs) {
super();
this.name = name;
this.runs = runs;
}

@Override
public String toString() {
return name + " " + runs;
}

@Override
public int compareTo(Cricketer2 that) {
if (this.runs > that.runs) {
return 1;
}
if (this.runs < that.runs) {
return -1;
}
return 0;
}

//Comparator<Cricketer2> comp = (that) -> this.runs > that.runs ? 1 : this.runs < that.runs ? -1 : 0; //
// 'Cricketer.this' cannot be referenced from a static context

//static Comparator<Cricketer2> comp2 = (h1, h2) -> (h1.getRuns() - h2.getRuns());


public static void main(String[] args) {
List<Cricketer2> cricketers = new ArrayList<>();
cricketers.add(new Cricketer2("Bradman", 9996));
cricketers.add(new Cricketer2("Sachin", 14000));
cricketers.add(new Cricketer2("Dravid", 12000));
cricketers.add(new Cricketer2("Ponting", 11000));
System.out.println(cricketers);
Collections.sort(cricketers); // reason: no instance(s) of type variable(s) T exist so that Comparable<Cricketer> conforms to Comparator<? super T>
// conforms to Comparable<? super T
System.out.println(cricketers);
}

}