Diferença entre os métodos String trim () e strip () em Java 11

Entre outras mudanças, o JDK 11 introduz 6 novos métodos para a classe java.lang.String:

• repeat(int)- Repete a string quantas vezes forem fornecidas pelo intparâmetro
• lines() - Usa um divisor para fornecer linhas preguiçosamente da string de origem
• isBlank() - Indica se a string está vazia ou contém apenas caracteres de espaço em branco
• stripLeading() - Remove o espaço em branco do início
• stripTrailing() - Remove o espaço em branco do final
• strip() - Remove o espaço em branco de ambos, início e fim da string

Em particular, strip()é muito semelhante a trim(). De acordo com este artigo, os strip*() métodos são projetados para:

Os métodos String.strip (), String.stripLeading () e String.stripTrailing () cortam o espaço em branco [conforme determinado por Character.isWhiteSpace ()] na frente, no verso ou na frente e atrás da String de destino.

String.trim() Estados JavaDoc:

/**
  * Returns a string whose value is this string, with any leading and trailing
  * whitespace removed.
  * ...
  */

O que é quase idêntico à citação acima.

Qual é exatamente a diferença entre String.trim()e String.strip()desde o Java 11?

Resumindo: strip()é a evolução "ciente do Unicode" de trim().

CSR: JDK-8200378

Problema

String :: trim existe desde os primeiros dias do Java, quando o Unicode não tinha evoluído totalmente para o padrão que usamos amplamente hoje.

A definição de espaço usada por String :: trim é qualquer ponto de código menor ou igual ao ponto de código de espaço (\ u0020), comumente referido como caracteres de controle ASCII ou ISO.

Rotinas de corte compatíveis com Unicode devem usar Character :: isWhitespace (int).

Além disso, os desenvolvedores não foram capazes de remover especificamente o espaço em branco de indentação ou remover especificamente o espaço em branco à direita.

Solução

Introduzir métodos de corte que reconhecem o espaço em branco Unicode e fornecem controle adicional de apenas à esquerda ou apenas à direita.

Uma característica comum desses novos métodos é que eles usam uma definição de "espaço em branco" diferente (mais recente) do que os métodos antigos, como String.trim(). Bug JDK-8200373 .

O JavaDoc atual para String :: trim não deixa claro qual definição de "espaço" está sendo usada no código. Com métodos de corte adicionais chegando em um futuro próximo que usam uma definição diferente de espaço, o esclarecimento é fundamental. String :: trim usa a definição de espaço como qualquer ponto de código menor ou igual ao ponto de código do caractere de espaço (\ u0020.) Os métodos de corte mais recentes usarão a definição de espaço (em branco) como qualquer ponto de código que retorna verdadeiro quando passado para o Predicado Character :: isWhitespace.

O método isWhitespace(char)foi adicionado Charactercom o JDK 1.1, mas o método isWhitespace(int)não foi apresentado à Characterclasse até o JDK 1.5. O último método (aquele que aceita um parâmetro de tipo int) foi adicionado para oferecer suporte a caracteres suplementares. Os comentários Javadoc para a Characterclasse definem caracteres suplementares (normalmente modelados com "ponto de código" baseado em int) versus caracteres BMP (normalmente modelados com um único caractere):

O conjunto de caracteres de U + 0000 a U + FFFF às vezes é chamado de Plano multilíngue básico (BMP). Os caracteres cujos pontos de código são maiores que U + FFFF são chamados de caracteres suplementares. A plataforma Java usa a representação UTF-16 em arrays char e nas classes String e StringBuffer. Nesta representação, caracteres suplementares são representados como um par de valores char ... Um valor char, portanto, representa pontos de código Basic Multilingual Plane (BMP), incluindo os pontos de código substitutos ou unidades de código da codificação UTF-16. Um valor int representa todos os pontos de código Unicode, incluindo pontos de código suplementares. ... Os métodos que aceitam apenas um valor char não podem suportar caracteres suplementares. ... Os métodos que aceitam um valor int oferecem suporte a todos os caracteres Unicode, incluindo caracteres suplementares.

Conjunto de alterações do OpenJDK .

Comparação de benchmark entre trim()e strip()- Por que String.strip () é 5 vezes mais rápido que String.trim () para string em branco em Java 11

Aqui está um teste de unidade que ilustra a resposta de @MikhailKholodkov, usando Java 11.

(Observe que \u2000está acima \u0020e não é considerado espaço em branco por trim())

public class StringTestCase {
    @Test
    public void testSame() {
        String s = "\t abc \n";

        assertEquals("abc", s.trim());
        assertEquals("abc", s.strip());
    }

    @Test
    public void testDifferent() {
        Character c = '\u2000';
        String s = c + "abc" + c;

        assertTrue(Character.isWhitespace(c));
        assertEquals(s, s.trim());
        assertEquals("abc", s.strip());
    }
}

Em geral, ambos os métodos removem os espaços iniciais e finais da string. No entanto, a diferença surge quando trabalhamos com caracteres Unicode ou recursos multilíngues.

trim () remove todos os caracteres iniciais e finais cujo valor ASCII seja menor ou igual a 32 ('U + 0020' ou espaço).

De acordo com os padrões Unicode, existem vários caracteres de espaço com valor ASCII superior a 32 ('U + 0020'). Ex: 8193 (U + 2001).

Para identificar esses caracteres de espaço, o novo método isWhitespace (int) foi adicionado do Java 1.5 na classe Character. Este método usa Unicode para identificar caracteres de espaço. Você pode ler mais sobre caracteres de espaço Unicode aqui .

A nova faixa de método que é adicionada no java 11 usa esse método Character.isWhitespace (int) para cobrir uma ampla gama de caracteres de espaço em branco e removê-los.

exemplo

public class StringTrimVsStripTest {
    public static void main(String[] args) {
        String string = '\u2001'+"String    with    space"+ '\u2001';
        System.out.println("Before: \"" + string+"\"");
        System.out.println("After trim: \"" + string.trim()+"\"");
        System.out.println("After strip: \"" + string.strip()+"\"");
   }
}

Resultado

Before: "  String    with    space  "
After trim: " String    with    space "
After strip: "String    with    space"

Observação: se você estiver executando em uma máquina Windows, pode não ser capaz de ver uma saída semelhante devido ao conjunto limitado de Unicode. você pode tentar alguns compiladores online para testar este código.

referência: diferença entre o método trim e strip java