Star Elements implementation in Java
How can I further improve my approach?
  
  Is there a better way to solve this question?


Let's start by making some observations about the problem description and the possible inputs:


The star elements will always be a strictly decreasing sequence
There will always be one star element: the rightmost one
The leftmost star may or may not be a super star


The posted code uses a map to find the star elements.
This is unnecessary, a list would be fine.
The loop you already have going from right to left could prepend the found star element to the list of stars.

After finding the stars, you need to check if the first star is a super star or not.
This is easy to verify, for example by a second scan of the array,
checking that precisely one element is equal,
and all other elements are strictly less than the leftmost star.

In this verification step,
you could avoid scanning the entire array if you know the index of the leftmost star, but such optimization is not really important,
because the order of time complexity of the solution will be the same.

This proposed solution uses fewer redundant data structures (a single list instead of a map and a set), and performs faster (no sorting).


  Are there any grave code violations that I have committed?


The findElems method does too many things.
It finds the stars and super stars and prints them.
It would be better to organize programs in a way that one method does one thing.
Following the suggested sketch above,
there could be one function to find the stars,
one to verify if an element is a super star,
and one to print.
When organized that way,
the logical steps will be easier to understand,
and the solution will be much easier to test.


  Can space and time complexity be further improved?


The suggested sketch above is better because it eliminates the sorting of the stars. That would be a significant improvement when the input set is a strictly decreasing sequence, where all elements are stars. In this extreme case the time complexity would be reduced from \$O(n \log n)\$ to \$O(n)\$.
However, since the problem description says there are maximum 106 elements, this improvement would be hardly measurable, insignificant.


  Is my code very redundant?


As mentioned earlier, the map and set can be replaced with a single list,
if you change the approach as I outlined.