regex – Java; ¿Reemplazo de cadena (usando expresiones regulares)?

str.replaceAll("\^([0-9]+)", "<sup>$1</sup>");

private String removeScript(String content) {
    Pattern p = Pattern.compile("<script[^>]*>(.*?)</script>",
            Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
    return p.matcher(content).replaceAll("");
}

String input = "hello I'm a java dev" +
"no job experience needed" +
"senior software engineer" +
"java job available for senior software engineer";

String fixedInput = input.replaceAll("(java|job|senior)", "<b>$1</b>");

"5 * x^3 - 6 * x^1 + 1".replaceAll("\W*\*\W*","").replaceAll("\^(\d+)","<sup>$1</sup>");

tenga en cuenta que unir ambos reemplazos en una sola expresión regular / reemplazo sería una mala elección porque expresiones más generales como x^3 - 6 * x fallaría.

import java.util.regex.PatternSyntaxException;

// (:?d+) * x^(:?d+)
// 
// Options: ^ and $ match at line breaks
// 
// Match the regular expression below and capture its match into backreference number 1 «(:?d+)»
//    Match the character “:” literally «:?»
//       Between zero and one times, as many times as possible, giving back as needed (greedy) «?»
//    Match a single digit 0..9 «d+»
//       Between one and unlimited times, as many times as possible, giving back as needed (greedy) «+»
// Match the character “ ” literally « »
// Match the character “*” literally «*»
// Match the characters “ x” literally « x»
// Match the character “^” literally «^»
// Match the regular expression below and capture its match into backreference number 2 «(:?d+)»
//    Match the character “:” literally «:?»
//       Between zero and one times, as many times as possible, giving back as needed (greedy) «?»
//    Match a single digit 0..9 «d+»
//       Between one and unlimited times, as many times as possible, giving back as needed (greedy) «+»
try {
    String resultString = subjectString.replaceAll("(?m)(:?\d+) \* x\^(:?\d+)", "$1x<sup>$2</sup>");
} catch (PatternSyntaxException ex) {
    // Syntax error in the regular expression
} catch (IllegalArgumentException ex) {
    // Syntax error in the replacement text (unescaped $ signs?)
} catch (IndexOutOfBoundsException ex) {
    // Non-existent backreference used the replacement text
}

Si esto es para cualquier expresión matemática general y se permiten expresiones entre paréntesis, será muy difícil (quizás imposible) hacer esto con expresiones regulares.

Si los únicos reemplazos son los que mostró, no es tan difícil de hacer. Primera tira *‘s, luego use la captura como Can Berk Güder mostró para manejar el ^‘s.

¿Cuál es tu polinomio? Si lo está «procesando», estoy imaginando algún tipo de árbol de subexpresiones que se generará en algún momento, y pensaría que sería mucho más sencillo usarlo para generar su cadena que volver a analizar el crudo. expresión con una expresión regular.

Simplemente lanzando una forma diferente de pensar. No estoy seguro de qué más está sucediendo en su aplicación.

Prueba esto:

String str = "5 * x^3 - 6 * x^1 + 1";
String replacedStr = str.replaceAll("\^(\d+)", "<sup>$1</sup>");

Asegúrese de importar java.util.regex.

class Replacement 
{
    public static void main(String args[])
    {
        String Main = "5 * x^3 - 6 * x^1 + 1";
        String replaced = Main.replaceAll("(?m)(:?\d+) \* x\^(:?\d+)", "$1x<sup>$2</sup>");
        System.out.println(replaced);
    }
}

Querrá considerar la captura en expresiones regulares para manejar el ajuste de 3 en ^ 3.

Pruebe esto, puede que no sea la mejor manera. pero funciona

String str = "5 * x^3 - 6 * x^1 + 1";
str = str.replaceAll("(?x)(\d+)(\s+?\*?\s+?)(\w+?)(\^+?)(\d+?)", "$1$3<sup>$5</sup>");
System.out.println(str);

Eche un vistazo a antlr4. Le llevará mucho más lejos en la creación de una estructura de árbol que las expresiones regulares por sí solas.

https://github.com/antlr/grammars-v4/tree/master/calculator (calculator.g4 contiene la gramática que necesita)

En pocas palabras, define la gramática para analizar una expresión, usa antlr para generar código java y agrega devoluciones de llamada para manejar la evaluación cuando se está construyendo el árbol.