Is there any way to sort an arraylist which have 2 classes by stream or whatever?

I know this question might be ridiculous complicated but this is something I must achieve...
Assume I have a list of 'entities':

  //they are all in the PlayGround class
  public static interface Entity{
    void turn(PlayGround g);
    int x();
    int y();
    int radius();
    }
 
  public ArrayList<Entity> entities(){return entities;}
  ArrayList<Entity> entities=new ArrayList<>();

Then I have two subclasses rock and miner extends from Entity:

//Record is a new feature in Java14 which similar to create a new class with fields
@SuppressWarnings("preview")
record Rock(int x,int y, int radius) implements Entity, Comparable<Rock>{
  ...
  public int compareTo(Rock o) {return Integer.compare(radius,o.radius);}
  public int getRadius() {return radius;};
}

class Miner implements Entity{
  int x=100;int y=100;
  public int x(){return x;}
  public int y(){return y;}
  public int radius(){return 15;}
...
}

In that case, we can add elements like this:

    var mg=new PlayGround();
    mg.entities().add(new Rock(200,200,50));
    mg.entities().add(new Rock(250,100,40));
    mg.entities().add(new Rock(200,350,80));
    mg.entities().add(new Miner()); 

However, I want to sort the Rock class in the Arraylist<Entity> by the number of radius, in the example, the ArrayList will from[Rock(50), Rock(40), Rock(80), Miner()] to [Rock(80), Rock(50), Rock(40), Miner()].

From the former query I tried:

    var es = mg.entities();
	@SuppressWarnings("unchecked")
	ArrayList<Entity> ess = es.stream()
     .filter(Rock.class::isInstance)
     .map(Rock.class::cast)
     .sorted(Comparator.comparingInt(Rock::getRadius))
     .collect(Collectors 
             .toCollection(ArrayList::new));

But it only compares the rock class and filter Miner out in the result.
Is there any way to achieve this? Thanks!

There's no need to involve stream API.

Your description of the problem is unclear. As is supposed to happen with unclear tasks, it is not possible to write an unclear task in code, as computers require very specific instructions.

The part that is unclear is: How do miners relate in this sorting algorithm of yours?

Given [rock5,rock2,miner1,rock10], there are many answers possible:

• Leave the miners precisely where they are, and sort the rocks 'around' them. becomes [rock2,rock5,miner1,rock10]. This cannot be done in a short amount of code. It strongly suggests you don't want a single list of entities, but 2 lists (one of miners, one of entities).
• Shift all the miners to the end: [rock2,rock5,rock10,miner1]
• Shift all miners to the beginning: [miner1,rock2,rock5,rock10].

They're really all relatively tricky; you can't do this by chaining a few Comparator::comparingInt and friends together. You can write your own comparator that does the job, but note that technically comparators should remain consistent. If a comparator says that 'a is below b', then if later asked about 'b and a', it MUST answer that 'b is above a', or things break in bizarre ways. That complicates matters, there isn't really a 'eh, whatever, don't try to order these things' option. For sorting arraylists you can return 'I consider these at the same level', but note that TreeMap and TreeSet can't do that (any 2 things at the same level are considered the same key).

That consistency is really a problem here. If you say that all miners are at the same level of all rocks, you can't do that. If rock1 is below rock2, but rock1 is at the same level as miner1, and miner1 is at the same level as miner2, boom, inconsistent.

So, your comparator has to get pretty complicated:

es.sort((a, b) -> {
    // miners are at the same level as each other.
    if (a instanceof Miner && b instanceof Miner) return 0;
    // miners are below all rocks
    if (a instanceof Miner) return -1;
    if (b instanceof Miner) return +1;
    // they're both rocks.
    return Integer.compare(((Rock) a).getRadius(), ((Rock b).getRadius());
});

that one would be consistent, and sorts all miners to the front.

If you want to sort 'around' the miners, I don't think list.sort (or Collections.sort) is capable of that, so fire up your favorite search engine and recreate TIMsort or quicksort or whatnot.