¿Cuáles son las ventajas y desventajas de tener un tipo CaseInsensitiveString en Java? [cerrado]

Estoy tentado a crear un final class CaseInsensitiveString implements CharSequence.

Esto nos permitiría definir variables y campos de este tipo, en lugar de usar un regular String. También podemos tener, por ejemplo Map<CaseInsensitiveString, ?>, a Set<CaseInsensitiveString>, a , etc.

¿Cuáles son algunos de los pros y los contras de este enfoque?

La insensibilidad a mayúsculas y minúsculas es una propiedad de la comparación, no del objeto (*). Querrá comparar la misma cadena independientemente del caso o no dependiendo del contexto.

(Y tiene todo un tipo de gusanos, ya que la comparación entre mayúsculas y minúsculas depende del idioma, i está en mayúsculas como İ en turco, e incluso del contexto, dependiendo de la palabra y el dialecto ß puede ser mayúscula como SS o SZ en alemán.)

(*) Puede ser una propiedad del objeto que contiene la cadena, pero eso es algo diferente de ser una propiedad de la cadena en sí. Y puede tener una clase que no tenga estado excepto una cadena, y al comparar dos instancias de esa clase se usará una comparación de la cadena que no distingue entre mayúsculas y minúsculas. Pero esa clase no será una cadena de propósito general, ya que no proporcionará los métodos esperados para las cadenas de propósito general y proporcionará métodos que no lo son. Esta clase no se llamará CaseInsensitiveString sino PascalIdentifier o lo que sea pertinente para describirlo. Y, por cierto, el algoritmo de comparación independiente del caso probablemente será proporcionado por su propósito y será independiente de la configuración regional.

Justo al lado de la parte superior de mi cabeza:

Pros:

• Hace que muchos documentos se auto documenten, por ejemplo:
  • bool UserIsRegistered(CaseInsensitiveString Username)
• Puede agilizar las comparaciones
• Puede eliminar la posibilidad de errores de comparación

Contras:

• Podría ser una pérdida de tiempo
  • las personas pueden convertir cadenas regulares a minúsculas si necesitan comparaciones entre mayúsculas y minúsculas
• Usarlo para código front-end causará problemas de capitalización
  • Por ejemplo, si usa CaseInsensitiveStringpara almacenar un nombre de usuario, aunque tenga sentido tener comparaciones de fondo que no distingan entre mayúsculas y minúsculas, el código de front-end mostrará el nombre del usuario como "bob smith" o "BOB SMITH"
• Si su base de código ya usa cadenas regulares, tendrá que regresar y cambiarlas o vivir con inconsistencia

CaseInsensitiveString no es una mala idea, depende de su uso, siempre que no espere que funcione junto con String.

Puede convertir un CaseInsensitiveString en un String, o viceversa, y eso es todo lo que debe hacer.

El problema ocurrirá si intentas hacer algo como

class CaseInsensitiveString {
  private String value;

  public boolean equals(Object o) {
    // .....
    if (o instanceof String) {
      return value.equalsIgnoreCase((String) o);
    }
  }
}

Está condenado al fracaso si va a hacer que su CaseInsensitiveString sea corporativa con String normal, porque violará la simétrica y la transitiva para equals () (y otros contratos)

Sin embargo, pregúntese, ¿en qué caso realmente necesita este CaseInsensitiveString que no es adecuado para usar String.CASE_INSENSITIVE_ORDER? Apuesto a que no hay muchos casos. Estoy seguro de que habrá un caso que vale la pena tener esta clase especial, pero pregúntese primero.

Crear explícitamente tipos en su dominio / modelo es una muy buena práctica. Como dijo Maxpm, es autodocumentado. También una gran ventaja: la gente no puede (por accidente) usar una entrada incorrecta. Lo único negativo que tiene es que asustará a los programadores junior (e incluso a algunos medianos).

Una clase CaseInsensitiveString y sus ayudantes agregan mucho código y harán que todo sea menos legible que el método String.toLoweCase ().

CaseInsensitiveString vaName1 = new CaseInsensitiveString('HeLLo');
//... a lot of lines here
CaseInsensitiveString vaName2 = new CaseInsensitiveString('Hello');
//... a lot of lines here
if (varName1.equals(varName2)) ...

es más complejo, menos autodocumentado y menos flexible que

String vaName1 = 'HeLLo';
//... a lot of lines here
String vaName2 = 'Hello';
//... a lot of lines here
if (varName1.toLowerCase().equals(varName2.toLowerCase())) ...

Las implementaciones más utilizadas en la web distinguen entre mayúsculas y minúsculas: XML, JavaScript. En términos de rendimiento, siempre es mejor usar la función / propiedad / objeto más apropiado para cada caso.

Si se trata de estructuras: XML o JS o similar, la distinción entre mayúsculas y minúsculas es importante. Es mucho más rápido usar bibliotecas del sistema.

Si se trata de datos en una base de datos, como se mencionó anteriormente, la indexación de la base de datos se utilizará para cadenas sensibles a mayúsculas / minúsculas.

Si está manejando datos sobre la marcha, es importante hacer el cálculo del costo de conversión necesario para cada cadena. Es probable que las cadenas se comparen o clasifiquen de alguna manera.