It looks like there is no auto unboxing to Character.

To be precise, primitive to object conversion at compile time is called boxing. Unboxing is the reverse way.
And yes Character/char provides an autoboxing feature but it doesn't work in this way. Here the primitives/wrapper counterparts are in an array or a list : so no boxing possible here.

That compiles :

char a = Character.valueOf('a'); // compile
Character aa  = 'a'; // compile

But that does not :

List<Character> charList = ...;
char[] charArray= ...;
charList = charArray; // doesn't compile
charArray = charList; // doesn't compile

How can I make this work?

Sorting an array of char with a specific Comparator is not conventional.
So not surprising that the Arrays API doesn't provide such a method.
Generally, Comparator and Comparable implementations rely only on the state of the compared objects to return the result, not on an external variable as in your example.
Similarly the Arrays API doesn't provide any method to create a Stream of char because streaming characters is also not a very conventional need.
So you don't have a straight built-in way to solve your issue.

In your situation, I would rely onArrays.stream(String.split()) to get a String for each character of the original String and I would apply the sort and finish with a joining :

String originalValue = "...";
String afterSortValue =
    Arrays.stream(originalValue.split(""))
          .sorted((o1, o2) -> {
                    Integer aPos = poses.get(o1);
                    Integer bPos = poses.get(o2);
                    if (aPos == null || bPos == null)
                      return 0;
                    return Integer.compare(aPos, bPos);
                  }
          )
         .collect(Collectors.joining());

This should be the most direct way without using external libraries.

Using bubble sort or something?

Yes, a bubble sort would work. Or you could use any one of the other well-known sort algorithms; e.g. as listed in this Wikipedia page ... or any good textbook on data structures and algorithms.

(But no, I'm not going to code this for you.)

You can sort a String in Java 8 using Stream as below:

String sortedString =
    Stream.of("hello".split(""))
    .sorted()
    .collect(Collectors.joining());

You can add System.out.println() to understand how it work:

Code

import java.util.Arrays;
import java.util.Comparator;

public class Main {

    public static void main(String[] args) {
        String s = "abracadabra";
        int n = s.length();
        
        System.out.println("X Y\tX Y\t[if] VALUE");
        System.out.println();
        
        Character[] res = new Character[n];
        for (int i = 0; i < n; i++) {
            res[i] = s.charAt(i);
        }
        
        int min = 'a';
        
        Arrays.sort(res, new Comparator<Character>() {

            @Override
            public int compare(Character x, Character y) {
                System.out.print(y + " " + x + "\t" + (x-min) + " " + (y-min) + "\t");
                if(x == 'c' && y == 'b') {
                    System.out.println("true " + (y - x));
                    return y - x;
                }
                System.out.println("     " + (x - y));
                return x - y;
            }
        });
        System.out.println("#################################\nResult:\n" + Arrays.toString(res));
    }
}

Console:

X Y X Y   [if] VALUE

a b 1 0        1
b r 17 1       16
r a 0 17       -17
b a 0 1        -1
a a 0 0        0
b c 2 1   true -1
a c 2 0        2
c a 0 2        -2
a a 0 0        0
c d 3 2        1
r d 3 17       -14
b d 3 1        2
c a 0 2        -2
a a 0 0        0
a a 0 0        0
c b 1 2        -1
a b 1 0        1
a b 1 0        1
b r 17 1       16
d r 17 3       14
r r 17 17      0
c a 0 2        -2
a a 0 0        0
b a 0 1        -1
a a 0 0        0
#################################
Result:
[a, a, a, a, a, b, c, b, d, r, r]

Much cleaner way of doing it :

Java 8 +

Arrays.sort(characters, (c1, c2) -> Character.toLowerCase(c1) - Character.toLowerCase(c2));

Java 7 and below

Arrays.sort(characters, new Comparator<Character>() {

    @Override
    public int compare(Character c1, Character c2) {
        return Character.toLowerCase(c1) - Character.toLowerCase(c2);
    }

});