Me gustaría recortar una comilla doble inicial y final (") de una cadena.
¿Cómo puedo lograr eso en Java? ¡Gracias!

Puede usar String#replaceAll()con un patrón de ^\"|\"$para esto.

P.ej

string = string.replaceAll("^\"|\"$", "");

Para obtener más información sobre las expresiones regulares, consulte también http://regular-expression.info .

Dicho esto, esto huele un poco a que estás tratando de inventar un analizador CSV. Si es así, sugeriría buscar bibliotecas existentes, como OpenCSV .

Para eliminar el primer carácter y el último carácter de la cadena, use:

myString = myString.substring(1, myString.length()-1);

También con Apache StringUtils.strip():

 StringUtils.strip(null, *)          = null
 StringUtils.strip("", *)            = ""
 StringUtils.strip("abc", null)      = "abc"
 StringUtils.strip("  abc", null)    = "abc"
 StringUtils.strip("abc  ", null)    = "abc"
 StringUtils.strip(" abc ", null)    = "abc"
 StringUtils.strip("  abcyx", "xyz") = "  abc"

Entonces,

final String SchrodingersQuotedString = "may or may not be quoted";
StringUtils.strip(SchrodingersQuotedString, "\""); //quoted no more

Este método funciona tanto con cadenas entre comillas como sin comillas, como se muestra en mi ejemplo. El único inconveniente es que no buscará estrictamente coincidentes cotizaciones, sólo el ataque y de salida comillas (es decir. No distingue entre "partiallyy "fully"cadenas entre comillas).

Si las comillas dobles solo existen al principio y al final, un código simple como este funcionaría perfectamente:

string = string.replace("\"", "");

Esta es la mejor manera que encontré, para quitar comillas dobles desde el principio y el final de una cadena.

someString.replace (/(^")|("$)/g, '')

Usando guayaba puedes escribir más elegantemente CharMatcher.is('\"').trimFrom(mystring);

Primero, verificamos si la Cadena se duplica entre comillas, y si es así, las eliminamos. Puede omitir el condicional si, de hecho, sabe que está entre comillas dobles.

if (string.length() >= 2 && string.charAt(0) == '"' && string.charAt(string.length() - 1) == '"')
{
    string = string.substring(1, string.length() - 1);
}

Kotlin

En Kotlin puedes usar String.removeSurrounding (delimitador: CharSequence)

P.ej

string.removeSurrounding("\"")

Elimina la cadena de delimitador dada tanto desde el inicio como hasta el final de esta cadena si y solo si comienza y termina con el delimitador . De lo contrario, devuelve esta cadena sin cambios.

El código fuente se ve así:

public fun String.removeSurrounding(delimiter: CharSequence): String = removeSurrounding(delimiter, delimiter)

public fun String.removeSurrounding(prefix: CharSequence, suffix: CharSequence): String {
    if ((length >= prefix.length + suffix.length) && startsWith(prefix) && endsWith(suffix)) {
        return substring(prefix.length, length - suffix.length)
    }
    return this
}

El siguiente patrón, cuando se usa con java.util.regex.Matcher, coincidirá con cualquier cadena entre comillas dobles sin afectar la aparición de comillas dobles dentro de la cadena:

"[^\"][\\p{Print}]*[^\"]"

Modificando un poco la respuesta de @ brcolow

if (string != null && string.length() >= 2 && string.startsWith("\"") && string.endsWith("\"") {
    string = string.substring(1, string.length() - 1);
}

Scala

s.stripPrefix("\"").stripSuffix("\"")

Esto funciona independientemente de si la cadena tiene o no comillas al principio y / o al final.

Editar: Lo siento, solo Scala

Editado: Acabo de darme cuenta de que debo especificar que esto funciona solo si ambos existen. De lo contrario, la cadena no se considera entre comillas. Tal escenario apareció para mí cuando trabajaba con archivos CSV.

org.apache.commons.lang3.StringUtils.unwrap("\"abc\"", "\"")    = "abc"
org.apache.commons.lang3.StringUtils.unwrap("\"abc", "\"")    = "\"abc"
org.apache.commons.lang3.StringUtils.unwrap("abc\"", "\"")    = "abc\""

Matcher m = Pattern.compile("^\"(.*)\"$").matcher(value);
String strUnquoted = value;
if (m.find()) {
    strUnquoted = m.group(1);
}

private static String removeQuotesFromStartAndEndOfString(String inputStr) {
    String result = inputStr;
    int firstQuote = inputStr.indexOf('\"');
    int lastQuote = result.lastIndexOf('\"');
    int strLength = inputStr.length();
    if (firstQuote == 0 && lastQuote == strLength - 1) {
        result = result.substring(1, strLength - 1);
    }
    return result;
}

Para eliminar una o más comillas dobles del inicio y el final de una cadena en Java, debe usar una solución basada en expresiones regulares:

String result = input_str.replaceAll("^\"+|\"+$", "");

Si necesita eliminar también comillas simples:

String result = input_str.replaceAll("^[\"']+|[\"']+$", "");

NOTA : Si su cadena contiene "adentro, este enfoque puede generar problemas (por ejemplo, "Name": "John"=>Name": "John ).

Vea una demostración de Java aquí :

String input_str = "\"'some string'\"";
String result = input_str.replaceAll("^[\"']+|[\"']+$", "");
System.out.println(result); // => some string

encuentre índices de cada comilla doble e inserte una cadena vacía allí.