Java split cant make it work for negative numbers

My professor asked us to make a simple calculator for addition and subtraction but the input has to be the whole expression like "5-5", "60+70" or "-8+10".

Scanner console = new Scanner(System.in);

int sum;

String expression = console.nextLine();
String[] split = expression.split("(?<=\\d)(?=\\D)|(?<=\\D)(?=\\d)");

int a = Integer.parseInt(split[0]);
int b = Integer.parseInt(split[2]);

String operator = split[1];

switch (operator) {

    case "+":
        sum = a + b;
        System.out.println(sum);
        break;

    case "-":
        sum = a - b;
        System.out.println(sum);
        break;
}

This is my code, and it works for the first two examples but not the last one where the first integer is a negative, e.g. "-8+10", and no I cannot do it any other way. I have to input the whole expression in the single string.

You can replace your regex by (?<=\\d)(?=\\D). This is looking for occurences of (non digit)(digit) pairs.<br><br>For yours examples:<br>
5-5 => "5" and "-5"<br>
60+70 => "60" and "+70"<br>
-8+10 => "-8" and "+10"<br>

    int sum;
    Scanner console = new Scanner(System.in);

    String expression = console.nextLine();
    String[] split = expression.split("(?<=\\d)(?=\\D)"); //split by signed numers

    int a = Integer.parseInt(split[0]); //First numer at index 0
    int b = Integer.parseInt(split[1]); //Second numer at index 1

    sum = a + b; //You don't need operator. Instead just add a and b
    System.out.println(sum);

You can get rid of operator. Notice, if a or b will be negative, you still can just add them to get the correct result.

You can fix this by always starting with 0 and applying each 'part' as a number or an operator. This solution also allows an arbitrary length, so you are not limited to only 2 numbers.

import java.util.*;
import java.util.stream.*;

public class Main {
  public static void main(String[] args) {
    System.out.println(new Expression("-8+12").evaluate());
  }
}

class Expression {

  public List<Part> parts;

  public Expression(String expression) {
    String[] split = expression.split("(?<=\\d)(?=\\D)|(?<=\\D)(?=\\d)");
    this.parts = Stream.of(split).map(Part::new).collect(Collectors.toList());

  }

  public Double evaluate() {
    double total = 0;
    Operator currentOperator = new Operator("+");
    
    for (Part currentPart : parts) {
      if (currentPart.isNumber()) {
        total = currentOperator.apply(total, currentPart.getNumberValue());
      } else {
        currentOperator = new Operator(currentPart.value);
      }
    }
    
    return total;
  }

}

class Part {

  public String value;

  public Part(String value) {
    this.value = value;
  }

  public double getNumberValue() {
    return Double.parseDouble(this.value);
  }

  public boolean isNumber() {
    try {
      double number = Double.parseDouble(this.value);
      return true;
    } catch (Exception e) {
      return false;
    }
  }
}

class Operator {
  public String value;

  public Operator(String value) {
    this.value = value;
  }

  public double apply(double first, double second) {
    switch(this.value) {
      case "+":
        return first + second;
      case "-":
        return first - second;
      default:
        throw new RuntimeException("Not a valid operator");
    }
  }
}

You can play around with this solution here.