How to insert a new element into a ordered list and shift all other objects in Java?

Suppose I have this simple class:

public class User implements Comparable<User> {

  private String name;
  private Integer order;

  public User(String name, Integer order) {
    this.name = name;
    this.order = order;
  }

  //...Getters and Setters ommited
  
  @Override
  public int compareTo(User user) {
    return this.order.compareTo(user.getOrder());
  }
}

Just two attributes, the name of the user and the order. This attribute order will be used to know the position of the user inside a list. Then, I will create an unordered LinkedList() of them:

private static List<User> unorderedList() {
    final List<User> users = new LinkedList<>();
    
    users.add(new User("Joe", 5));
    users.add(new User("John", 2));
    users.add(new User("Maria", 8));
    users.add(new User("Kevin", 7));
    users.add(new User("Sophia", 9));
    users.add(new User("James", 1));
    users.add(new User("Adrian", 3));
    
    return users;
}

Now, I need to create and insert a new User in my list.

User u = new User("David", 2);

But, before I call the add() method, I have to do somethings.

I have to order this list (that's why I implemented Comparable on User class) and I have to update the attribute order to be sequential. So when I insert my new User in List, I need to have a final result like this:

1 - James    // No Change
2 - David    // New user inserted
3 - John     // Was order 2, become 3
4 - Adrian   // Was order 3, become 4
5 - Joe      // No Change
6 - Kevin    // There was no 6. Kevin was 7 so he become 6
7 - Maria    // Was 8
8 - Sophia - // Was 9

EDIT 1: What I tried

I tried to loop the list and compare the users order in list with new users order. The newUser have priority in position inside list.

final List<User> unorderedUsers = MainApp.unorderedList();
final AtomicInteger currentOrder = new AtomicInteger(1);
final User newUser = new User("David", 2);
Collections.sort(unorderedUsers);

unorderedUsers.forEach(user -> {
    if (user.getOrder().equals(newUser.getOrder())) {
        user.setOrder(user.getOrder() + 1);
    } else {
        user.setOrder(currentOrder.get());
    }

    currentOrder.incrementAndGet();
});

unorderedUsers.add(newUser);
Collections.sort(unorderedUsers);
System.out.println(String.format("Ordered with new User List -> %s", unorderedUsers));

However, the new user order is getting duplicated. I'm still trying to solve how to do a new sequential order. The result of my code is:

'James', order=1
'David', order=2
'John', order=3
'Adrian', order=3
'Joe', order=4
'Kevin', order=5
'Maria', order=6
'Sophia', order=7

EDIT 2 - Possible Found Solution
I don't know if this solution covers all scenarios, but I separate in two steps. I know it's a bit expensive, but it's what I got.

private void insertNewUser(final List <User> usersList, final User newUser) {
  final AtomicBoolean canShift = new AtomicBoolean(false);
  usersList.forEach(user ->{
    if (user.getOrder().equals(newUser.getOrder()) || canShift.get()) {
      user.shiftOrder();
      canShift.set(true);
    }
  });

  usersList.add(newUser);
  Collections.sort(usersList);
}

private void organizeOrder(final List <User> usersList) {
  final AtomicInteger currentOrder = new AtomicInteger(1);
  usersList.forEach(user -> user.setOrder(currentOrder.getAndIncrement()));
}

Then just call:

this.insertNewUser(...)
this.organizeOrder(...)

You are not updating Users having order higher than order (2) of new user. Sorting does not update your objects value. You can try that.

Collections.sort(users);
users.add( newUser.getOrder()-1 , newUser );
AtomicInteger index = new AtomicInteger(1);
users.forEach(
   user ->  user.setOrder( index.getAndIncrement() )
);

You don't have to implement the Comparable interface. You can sort using a Comparator:

users.addFirst(newUser);
// We're using addFirst here, because we want to make sure
// that the new user comes BEFORE possible users with the
// same order

AtomicInteger inc = new AtomicInteger();
users.stream()
    .sorted(Comparator.comparing(User::getOrder))
    .map(user -> {
        user.setOrder(inc.incrementAndGet());
        return user;
    })
    .collect(Collectors.toList();

In the above code, this is what happens: first, an AtomicInteger is created, which helps us to provide the users with new order numbers. Then, we sort the stream by the sequence number of the User. Then, we get a new sequence number from the AtomicInteger, and we set the order property with this number. Finally, we collect this into a list.

addFirst() makes sure that the new user is added at the beginning of the list. This is because in the finally sorted list, we want the new user to appear before any other user with the same order. Because the sorting is a stable sort, elements with equal sequence numbers appear in the same order as the unsorted stream.

As an alternative, instead of addFirst(), you could use

newUser.setOrder(newUser.getOrder() - 1);
users.add(newUser);

instead.