Apply calculator operations to Strings

there is an option which eliminates the need for switch: use of enum. java enum has the capabilities of any java class, including instance variables and methods. the solution I propose has the following design:

1. create an enum with values per the symbols that perform calculation: EQUAL, PLUS, MINUS.
2. every enum value will have a property (instance variable) with the relevant character value. for example, EQUALS will have property '=' . a static method of the enum will receive the user input, iterate over the enum values() and return Optional populated if match was found
3. every enum value will implement a method that does the calculation. the method will choose between numberone and numbertwo, perform the math calculation and return string value.
4. with the all the above imlpemented, it is straightforward to do calculation from user input

this solution will likely add more lines of code compared to solution using switch (depends on formatting...) however, it is build for robustness: adding a new symbol requires only adding a new enum value with implementation of calculate.

here is the enum class, with symbol property, calculate method and static method to get value from user input

public enum Symbol {

    EQUAL('=') {
        @Override
        public String calculate(String originalstring, long numberone, long numbertwo) {
            // return chosen number as is
            return String.valueOf(getNumberToCalcaulte(originalstring, numberone, numbertwo));
        }
    },

    PLUS('+') {
        @Override
        public String calculate(String originalstring, long numberone, long numbertwo) {
            // return original + chosen number
            return String.valueOf(
                Long.parseLong(originalstring) +
                getNumberToCalcaulte(originalstring, numberone, numbertwo)
            );
        }
    },

    MINUS('-') {
        @Override
        public String calculate(String originalstring, long numberone, long numbertwo) {
            // return original - chosen number
            return String.valueOf(
                Long.parseLong(originalstring) -
                getNumberToCalcaulte(originalstring, numberone, numbertwo)
            );
        }
    };

    // property char symbol
    private char symbol;

    /**
     * iterate over enum values, 
     * return first value with property matching user input, otherwise empty
     */
    public static Optional<Symbol> getSymbol(char userInput) {
        // values() produces an array, thus need for Arrays to stream
        return Arrays.stream(values())
            .filter(val -> val.symbol == userInput)
            .findFirst();
    }

    Symbol(char symbol) {
        this.symbol = symbol;
    }

    /**
     * signature of calculate method, implemented in each value
     */
    public abstract String calculate(String originalstring, long numberone, long numbertwo);

    /**
     * choose number to calculate based on first char of original 
     */
    private static long getNumberToCalcaulte(String originalstring, long numberone, long numbertwo) {
        return (originalstring.charAt(0) == '-') ? numberone : numbertwo;
    }
}

usage of the enum to do the calculation

    String originalstring = "-1000"; //read from a file
    char symbol = '+'; //depends on user input
    long numberone = 1000; //-"-
    long numbertwo = 2000; //-"-

    String newstring = Symbol.getSymbol(symbol)
        .map(matchedSymbol -> matchedSymbol.calculate(originalstring, numberone, numbertwo))
        .orElse("");

Your current implementation has duplicate logic, which is bad because it means you'll need to change it in two places if it ever needs to change.

First determine the value of numberValue:

long numberValue = originalstring.charAt(0)=='-'
    ? 1000
    : 2000;

and then use one switch:

switch(symbol) {
    case '=':
        newstring = numberValue + "";
        break;
    case '+':
        newstring = (Long.parseLong(originalstring) + numberValue) + "";
        break;
    case '-':
        newstring = (Long.parseLong(originalstring) - numberValue) + "";
        break;
    }

How it would be done here

First the current case.

The use case looks like an interactive calculator, some state machine. That would look best (in the latest switch syntax) like:

long number = originalstring.startsWith("-") ? numberone : numbertwo;

String message = "";   
long register = Long.parseLong(originalstring);
switch (symbol) {
    case '=' ->
        register = number;
    case '+' ->
        register += number;
    case '-' ->
        register -= number;
    default ->
        message = "";
}
if (message.isEmpty()) {
    message = Long.toString(register);
}

The precise question

Concerning nesting one within another of if and switch. If the switches are longer and vary, it probably is more readable to understand one if-branch when the switch-branch is inside: shorter text, following a consistent line across the cases.

if
    switch
    case ...
    case ...
    case ...
    case ...
    case ...
else
    switch
    case ...
    case ...

than:

switch
case ...
    if ...
    else ...
case ...
    if ...
    else ...
case ...
    if ...
    else ...
case ...
    if ...
    else ...
case ...
    if ...
    else ...

The context of processing many cases

The last remark. So many cross-concerns, matrix like processing, would benefit from a declarative solution. Where you have a tabular structure of data. You can then iterate over the defined data, and even log how you arrived to the solution. This makes for traceable and verifiable results. If the result are 2x8 PDF reports, you can use metadata in the PDF indicating the followed data branch.

For the particular case described the optimal option is the one in the code snippet from description, of course with a default case for every switch, because...

An alternative would be to use switch on the outside and use the if statement in every case (possibly with the ternary operator to shorten it a little bit).

A shorter version would be to use ternary operator to choose between the numberone and numbertwo...

String originalstring = "-1000"; //read from a file
char symbol = '+'; //depends on user input
long numberone = 1000; //-"-
long numbertwo = 2000; //-"-
String newstring = "";
long number = (originalstring.charAt(0) == '-') ? numberone : numbertwo;

switch(symbol) {
    case '=':
        newstring = number + "";
        break;
    case '+':
        newstring = (Long.parseLong(originalstring) + number) + "";
        break;
    case '-':
        newstring = (Long.parseLong(originalstring) - number) + "";
        break;
    default:
        newstring = "";
        break;
}

Best practice is something that best fits each and every case it is used for, it is possible but not probable that's why sometimes better practice is preferred. Speaking about efficiency between if statement and switch statement the if statement is the efficient one, switch statement uses a lookup table, so in case of an if statement with a switch statement just for one of the possible results (false or true) switch statement inside if statement should be preferred since it is efficient. For the described case either way is equally efficient, all it can be done about it is to rewrite it differently for instance avoiding the switch statement using couple of times the ternary operator...

String originalstring = "-1000"; //read from the file
char symbol = '+'; //depends on user input
long numberone = 1000; //-"-
long numbertwo = 2000; //-"-
long number = Long.parseLong(originalString);
long offset = (originalstring.charAt(0)=='-') ? numberone : numbertwo;
String newstring = (symbol == '=') ? number + "" : (number + offset) + "";