¿Por qué no hay String.Empty en Java?

Entiendo que cada vez que escribo el literal de cadena "", se hace referencia al mismo objeto de cadena en el grupo de cadenas.

Pero, ¿por qué la API de cadena no incluye a public static final String Empty = "";, por lo que podría usar referencias String.Empty?

Ahorraría tiempo de compilación, como mínimo, ya que el compilador sabría hacer referencia a la Cadena existente y no tendría que verificar si ya se ha creado para su reutilización, ¿verdad? Y personalmente creo que la proliferación de literales de cadena, especialmente los pequeños, en muchos casos es un "olor a código".

Entonces, ¿hubo una Gran razón de diseño detrás de String.Empty, o los creadores del lenguaje simplemente no compartieron mis puntos de vista?

String.EMPTYtiene 12 caracteres y ""dos, y ambos estarían haciendo referencia exactamente a la misma instancia en la memoria en tiempo de ejecución. No estoy completamente seguro de por String.EMPTYqué ahorraría tiempo de compilación, de hecho creo que sería lo último.

Especialmente teniendo en cuenta que los Strings son inmutables, no es como si primero pudieras obtener un String vacío y realizar algunas operaciones en él, lo mejor es usar un StringBuilder(o StringBuffersi quieres ser seguro para subprocesos) y convertirlo en un String.

Actualización de
su comentario a la pregunta:

Lo que inspiró esto es en realidad TextBox.setText("");

Creo que sería totalmente legítimo proporcionar una constante en su clase apropiada:

private static final String EMPTY_STRING = "";

Y luego referencialo como en tu código como

TextBox.setText(EMPTY_STRING);

De esta manera, al menos, es explícito que desea una Cadena vacía, en lugar de haber olvidado completar la Cadena en su IDE o algo similar.

Utilizar org.apache.commons.lang.StringUtils.EMPTY

Si desea comparar con una cadena vacía sin preocuparse por los valores nulos, puede hacer lo siguiente.

if ("".equals(text))

En última instancia, debe hacer lo que cree que es más claro. La mayoría de los programadores asumen que "" significa cadena vacía, no una cadena en la que alguien olvidó poner algo.

Si cree que hay una ventaja de rendimiento, debe probarla. Si no cree que valga la pena probarlo usted mismo, es una buena indicación de que realmente no vale la pena.

Parece que intentas resolver un problema que se resolvió cuando el lenguaje fue diseñado hace más de 15 años.

Si realmente desea una constante String.EMPTY, puede crear una clase final estática de utilidad denominada "Constantes" (por ejemplo) en su proyecto. Esta clase mantendrá sus constantes, incluida la cadena vacía ...

En la misma idea, puede crear ZERO, ONE int constantes ... que no existen en la clase Integer, pero como comenté, sería difícil escribir y leer:

for(int i=Constants.ZERO; ...) {
    if(myArray.length > Constants.ONE) {
        System.out.println("More than one element");
    }
}

Etc.

Apache StringUtils también soluciona este problema.

Fallos de las otras opciones:

• isEmpty () - no es nulo seguro. Si la cadena es nula, arroja un NPE
• length () == 0 - nuevamente no es nulo seguro. Tampoco tiene en cuenta las cadenas de espacios en blanco.
• Comparación con constante VACÍO: puede no ser nulo seguro. Problema de espacios en blanco

Granted StringUtils es otra biblioteca para arrastrar, pero funciona muy bien y ahorra un montón de tiempo y comprobaciones sin problemas para detectar nulos o manejar NPE con gracia.

No solo diga "el conjunto de cadenas de memoria se reutiliza en forma literal, caso cerrado". Lo que hacen los compiladores bajo el capó no es el punto aquí. La pregunta es razonable, especialmente dada la cantidad de votos positivos que recibió.

Se trata de la simetría , sin ella las API son más difíciles de usar para los humanos. Los primeros SDK de Java ignoraron notoriamente la regla y ahora es demasiado tarde. Aquí hay algunos ejemplos sobre mi cabeza, siéntase libre de incluir su ejemplo "favorito":

• BigDecimal.ZERO, pero no AbstractCollection.EMPTY, String.EMPTY
• Array.length pero List.size ()
• List.add (), Set.add () pero Map.put (), ByteBuffer.put () y no olvidemos StringBuilder.append (), Stack.push ()

Todos esos ""literales son el mismo objeto. ¿Por qué hacer toda esa complejidad extra? Es más largo de escribir y menos claro (el costo para el compilador es mínimo). Dado que las cadenas de Java son objetos inmutables, nunca hay necesidad de distinguir entre ellas, excepto posiblemente como una cuestión de eficiencia, pero con el literal de cadena vacío no es gran cosa.

Si realmente quieres una EmptyStringconstante, hazlo tú mismo. Pero todo lo que hará es alentar un código aún más detallado; no habrá nunca más ningún beneficio al hacerlo.

Para agregar a lo que dijo Noel M, puede ver esta pregunta, y esta respuesta muestra que la constante se reutiliza.

http://forums.java.net/jive/message.jspa?messageID=17122

Las cadenas constantes siempre están "internados", por lo que realmente no hay necesidad de tal constante.

String s=""; String t=""; boolean b=s==t; // true

Entiendo que cada vez que escribo el literal de cadena "", se hace referencia al mismo objeto de cadena en el grupo de cadenas.
No hay tal garantía hecha. Y no puede confiar en él en su aplicación, depende completamente de jvm decidir.

¿O los creadores del lenguaje simplemente no compartieron mis puntos de vista?
Sí. Para mí, parece algo de muy baja prioridad.

Respuesta tardía, pero creo que agrega algo nuevo a este tema.

Ninguna de las respuestas anteriores ha respondido a la pregunta original. Algunos han intentado justificar la falta de una constante, mientras que otros han mostrado formas en que podemos lidiar con la falta de la constante. Pero nadie ha brindado una justificación convincente para el beneficio de la constante, por lo que su falta aún no se explica adecuadamente.

Una constante sería útil porque evitaría que ciertos errores de código pasen desapercibidos.

Digamos que tiene una base de código grande con cientos de referencias a "". Alguien modifica uno de estos mientras se desplaza por el código y lo cambia a "". Tal cambio tendría una alta probabilidad de pasar desapercibido en la producción, en cuyo punto podría causar algún problema cuya fuente será difícil de detectar.

OTOH, una constante de biblioteca llamada EMPTY, si está sujeta al mismo error, generaría un error de compilación para algo como EM PTY.

Definir tu propia constante es aún mejor. Alguien aún podría alterar su inicialización por error, pero debido a su amplio uso, el impacto de dicho error sería mucho más difícil pasar desapercibido que un error en un solo caso de uso.

Este es uno de los beneficios generales que obtiene al usar constantes en lugar de valores literales. Las personas generalmente reconocen que el uso de una constante para un valor utilizado en docenas de lugares le permite actualizar fácilmente ese valor en un solo lugar. Lo que se reconoce con menos frecuencia es que esto también evita que ese valor se modifique accidentalmente, porque tal cambio se vería en todas partes. Entonces, sí, "" es más corto que VACÍO, pero VACÍO es más seguro de usar que "".

Entonces, volviendo a la pregunta original, solo podemos especular que los diseñadores de lenguaje probablemente no estaban al tanto de este beneficio de proporcionar constantes para valores literales que se usan con frecuencia. Con suerte, algún día veremos constantes de cadena agregadas en Java.

Para aquellos que reclaman ""y String.Emptyson intercambiables o eso ""es mejor, estás muy equivocado.

Cada vez que haces algo como myVariable = ""; Estás creando una instancia de un objeto. Si el objeto String de Java tuviera una constante pública VACÍA, solo habría 1 instancia del objeto ""

P.ej: -

String.EMPTY = ""; //Simply demonstrating. I realize this is invalid syntax

myVar0 = String.EMPTY;
myVar1 = String.EMPTY;
myVar2 = String.EMPTY;
myVar3 = String.EMPTY;
myVar4 = String.EMPTY;
myVar5 = String.EMPTY;
myVar6 = String.EMPTY;
myVar7 = String.EMPTY;
myVar8 = String.EMPTY;
myVar9 = String.EMPTY;

10 (11 incluyendo String.EMPTY) Punteros a 1 objeto

O: -

myVar0 = "";
myVar1 = "";
myVar2 = "";
myVar3 = "";
myVar4 = "";
myVar5 = "";
myVar6 = "";
myVar7 = "";
myVar8 = "";
myVar9 = "";

10 punteros a 10 objetos

Esto es ineficiente y, a lo largo de una aplicación grande, puede ser significativo.

Quizás el compilador de Java o el tiempo de ejecución sea lo suficientemente eficiente como para apuntar automáticamente todas las instancias de "" a la misma instancia, pero podría no serlo y requiere un procesamiento adicional para tomar esa determinación.