Intenté usar esto pero no funcionó

return value.replaceAll("/[^A-Za-z0-9 ]/", "");

Uso [^A-Za-z0-9].

Nota: se eliminó el espacio, ya que eso no suele considerarse alfanumérico.

Tratar

return value.replaceAll("[^A-Za-z0-9]", "");

o

return value.replaceAll("[\\W]|_", "");

Debe tener en cuenta que [^a-zA-Z]reemplazará los caracteres que no se encuentren en el rango de caracteres AZ / az. Eso significa caracteres especiales como é, ßetc. o caracteres cirílicos y tales serán eliminados.

Si no se desea reemplazar estos caracteres, utilice clases de caracteres predefinidas en su lugar:

 str.replaceAll("[^\\p{IsAlphabetic}\\p{IsDigit}]", "");

PD: \p{Alnum}no logra este efecto, actúa igual que [A-Za-z0-9].

return value.replaceAll("[^A-Za-z0-9 ]", "");

Esto dejará espacios intactos. Supongo que eso es lo que quieres. De lo contrario, elimine el espacio de la expresión regular.

También puedes probar esta expresión regular más simple:

 str = str.replaceAll("\\P{Alnum}", "");

Las expresiones regulares de Java no requieren que coloque una barra diagonal ( /) o cualquier otro delimitador alrededor de la expresión regular, a diferencia de otros lenguajes como Perl, por ejemplo.

Hice este método para crear nombres de archivo:

public static String safeChar(String input)
{
    char[] allowed = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_".toCharArray();
    char[] charArray = input.toString().toCharArray();
    StringBuilder result = new StringBuilder();
    for (char c : charArray)
    {
        for (char a : allowed)
        {
            if(c==a) result.append(a);
        }
    }
    return result.toString();
}

Solución:

value.replaceAll("[^A-Za-z0-9]", "")

Explicación:

[^abc] Cuando un cursor ^aparece como el primer carácter entre corchetes, niega el patrón. Este patrón coincide con cualquier carácter excepto a o b o c.

Mirando la palabra clave como dos funciones:

• [(Pattern)] = match(Pattern)
• [^(Pattern)] = notMatch(Pattern)

Además con respecto a un patrón:

• A-Z = all characters included from A to Z

• a-z = all characters included from a to z

• 0=9 = all characters included from 0 to 9

Por lo tanto, sustituirá todos los caracteres NO incluidos en el patrón

Si desea permitir también caracteres alfanuméricos que no pertenecen al conjunto de caracteres ascii, como por ejemplo, diéresis alemana, puede considerar usar la siguiente solución:

 String value = "your value";

 // this could be placed as a static final constant, so the compiling is only done once
 Pattern pattern = Pattern.compile("[^\\w]", Pattern.UNICODE_CHARACTER_CLASS);

 value = pattern.matcher(value).replaceAll("");

Tenga en cuenta que el uso del indicador UNICODE_CHARACTER_CLASS podría imponer una penalización de rendimiento (consulte javadoc de este indicador)

Método simple:

public boolean isBlank(String value) {
    return (value == null || value.equals("") || value.equals("null") || value.trim().equals(""));
}

public String normalizeOnlyLettersNumbers(String str) {
    if (!isBlank(str)) {
        return str.replaceAll("[^\\p{L}\\p{Nd}]+", "");
    } else {
        return "";
    }
}

public static void main(String[] args) {
    String value = " Chlamydia_spp. IgG, IgM & IgA Abs (8006) ";

    System.out.println(value.replaceAll("[^A-Za-z0-9]", ""));

}

salida: ChlamydiasppIgGIgMIgAAbs8006

Github: https://github.com/AlbinViju/Learning/blob/master/StripNonAlphaNumericFromString.java

Usando Guava puedes combinar fácilmente diferentes tipos de criterios. Para su solución específica puede usar:

value = CharMatcher.inRange('0', '9')
        .or(CharMatcher.inRange('a', 'z')
        .or(CharMatcher.inRange('A', 'Z'))).retainFrom(value)

CharMatcher de Guava proporciona una solución concisa:

output = CharMatcher.javaLetterOrDigit().retainFrom(input);