CompareTo method in two separate methods

I have a class that implements the Comparable interface.
I want to sort objects by their id and by their name, but in two seperate methods.
For example, sorting by id:

 public int compareTo(Metro m1) {
       return this.id - m1.id;
    }

I also want to sort by name, which means that I have to do something like this:

public int compareTo(Metro m1) {
       return this.name.compareTo(m1.name);
}

The problem is that I can't write the same function with the same name and the same parameters, how do I do to fix this?
When I will call Collections.sort(this.list); on a list of objects, how is it going to identify that I want to sort my list by id or by name?

implementing Comparable is appropriate if an type has a so-called 'natural order'. That'd be an order that is the slam dunk answer to 'without any further context, how do you think these objects would be ordered'?

For example, if I ask you to order '1, 9, and 7', without further context, surely you'd go: Well, uh, I guess 1,7,9? If then later I tell you: Actually I wanted you to spell those digits out in english and then sort on the length of that, so, 1,9,7 - okay, but that's quite unexpected.

In your case, both 'by name' and 'by id' sound equally plausible.

This means that a Metro type has no natural order at all, and therefore should not implement Comparable.

So, how do you sort em? Fortunately, sort() has an overload: You can supply a Comparator object. That's how you solve this problem:

// requires getId() to exist as a method:
Comparator<Metro> byUnid = comparingInt(Metro::getId);
this.list.sort(byUnid);

// Works because strings do have natural order
Comparator<Metro> byName = comparing(Metro::getName)

It's that simple. Note that your compareTo by id method is broken - it fails for very large numbers. You should endeavour to use the comparing, comparingInt, and chaining solutions in the Comparator interface.

You can use java.util.Comparator:

Comparator<MyClass> comparatorByName = Comparator.comparing(a -> a.name);
Comparator<MyClass> comparatorById = Comparator.comparing(a -> a.id);
List<MyClass> list = new ArrayList<>();
// ...
Collections.sort(list, comparatorByName);
Collections.sort(list, comparatorById);

So long as you don't have your Comparable object in a sorted collection (TreeSet, etc)
you can just provide an instance Comparator for a single sort.

Sorting by Y coord

List<Point2D> points = new ArrayList();        
Collections.sort(points, new Comparator<>() {
        @Override
        public int compare(Point2D o1, Point2D o2) {
            return Double.compare(o1.getY(), o2.getY());
        }
 });

Sorting by X coord

 Collections.sort(points, new Comparator<>() {
            @Override
            public int compare(Point2D o1, Point2D o2) {
                return Double.compare(o1.getX(), o2.getX());
            }
     });

import java.util.ArrayList;
import java.util.Comparator;
public class Test {
public static void main(String[] args) {
ArrayList<Metro> l = new ArrayList<>();
l.add(new Metro(5, "aziz"));
l.add(new Metro(1, "zied"));
l.add(new Metro(2, "ahmed"));
Comparator<Metro> byId = new Comparator<Metro>() {
@Override
public int compare(Metro o1, Metro o2) {
return o1.getId() - o2.getId();
}
};
l.sort(byId);
System.out.println("by id :" + l);
Comparator<Metro> byName = new Comparator<Metro>() {
@Override
public int compare(Metro o1, Metro o2) {
return o1.getName().compareTo(o2.getName());
}
};
l.sort(byName);
System.out.println("by name :" + l);
}
}
class Metro {
private String name;
private int id;
Metro(int id, String name) {
this.id = id;
this.name = name;
}
public String getName() {
return name;
}
public int getId() {
return id;
}
@Override
public String toString() {
return "{" + id + "," + name + "}";
}
}

output :

by id :[{1,zied}, {2,ahmed}, {5,aziz}]
by name :[{2,ahmed}, {5,aziz}, {1,zied}]