The other mathematical shorthand operators which Java provides are the += (a = a + number), *=, and so on.

The complete list of operators can be obtained from here.

No, you can't do that in Java. The compiler needs to know what your operator is doing. What you could do instead is an enum:

public enum Operator
{
    ADDITION("+") {
        @Override public double apply(double x1, double x2) {
            return x1 + x2;
        }
    },
    SUBTRACTION("-") {
        @Override public double apply(double x1, double x2) {
            return x1 - x2;
        }
    };
    // You'd include other operators too...

    private final String text;

    private Operator(String text) {
        this.text = text;
    }

    // Yes, enums *can* have abstract methods. This code compiles...
    public abstract double apply(double x1, double x2);

    @Override public String toString() {
        return text;
    }
}

You can then write a method like this:

public String calculate(Operator op, double x1, double x2)
{
    return String.valueOf(op.apply(x1, x2));
}

And call it like this:

String foo = calculate(Operator.ADDITION, 3.5, 2);
// Or just
String bar = String.valueOf(Operator.ADDITION.apply(3.5, 2));

Create an enumeration that maps the operation character to a function of two ints.

enum Operator {
    ADD('+',(x,y)->x+y),
    SUBTRACT('-',(x,y)->x-y),
    MULTIPLY('*',(x,y)->x*y),
    DIVIDE('/',(x,y)->x/y),
    REMAINDER('%',(x,y)->x%y),
    POW('^',(x,y)->(int)Math.pow(x,y));

    char symbol;
    BiFunction<Integer,Integer,Integer> operation;

    Operator(final char symbol, final BiFunction<Integer,Integer,Integer> operation) {
        this.symbol = symbol;
        this.operation = operation;
    }

    public static Operator representedBy(final char symbol)
    {
        return Stream.of(Operator.values()).filter(operator->operator.symbol==symbol).findFirst().orElse(null);
    }

    public Integer apply(final int x,final int y)
    {
        return operation.apply(x,y);
    }
}

public static void main(final String[] args) {
    final char op = '+';
    final int int1 = 1;
    final int int2 = 2;
    final Operator operator = Operator.representedBy(op);
    if (operator == null)
    {
        // handle bad character
    }
    else
    {
        System.out.println(operator.apply(int1,int2));
    }
}