Capítulo 04: Operadores Bitwise, Manipulação Avançada de Strings, Imutabilidade, String Pool e StringBuilder

Especialização em Sistemas com Java 21 LTS • Módulo de Fundamentos

---

🗺️ Mapa Conceitual do Tópico

flowchart TD
    subgraph BITWISE["Operadores Bitwise & Flags"]
        A["Operadores: &, |, ^, ~, <<, >>, >>>"]
        B["Bitmask de Permissões: READ(1), WRITE(2), EXEC(4)"]
        A --> B
    end

    subgraph STRINGS["Internals de java.lang.String"]
        C["Array Imutável: byte[] value"]
        D["Compact Strings (LATIN1 vs UTF16)"]
        E["String Constant Pool & intern()"]
        C & D --> E
    end

    subgraph PERFORMANCE["Construção de Texto de Alta Eficiência"]
        F["Concatenação (+) em Loops: Ineficiente O(N^2)"]
        G["StringBuilder: Buffer Mutável (Single Thread)"]
        H["StringBuffer: Sincronizado Legado"]
        I["Text Blocks e Métodos Modernos (Java 21)"]
        F -->|Otimização| G
        G --> I
    end

    BITWISE --> PERFORMANCE
    STRINGS --> PERFORMANCE

    style A fill:#e1f5fe,stroke:#03a9f4,stroke-width:2px
    style C fill:#ede7f6,stroke:#7e57c2,stroke-width:2px
    style G fill:#e8f5e9,stroke:#4caf50,stroke-width:2px
    style I fill:#fff3e0,stroke:#ff9800,stroke-width:2px

---

⚙️ 1. Operadores Bitwise e Máscaras de Bits (Bitmasks)

Operadores bit a bit manipulam diretamente os bits individuais de tipos inteiros (byte, short, int, long). São largamente utilizados em criptografia, compressão de dados, protocolos de rede e flags de acesso de altíssima performance.

Principais Operadores Bitwise em Java:

• & (AND binário): Retorna 1 apenas se ambos os bits forem 1. Utilizado para testar se uma flag está ativa.
• | (OR binário): Retorna 1 se ao menos um dos bits for 1. Utilizado para combinar permissões.
• ^ (XOR binário): Retorna 1 apenas se os bits forem distintos. Utilizado para alternar estados (toggle).
• ~ (NOT binário): Inverte todos os bits (complemento de dois).
• << (Left Shift): Desloca bits à esquerda preenchendo com zeros (equivale à multiplicação por potências de 2).
• >> (Signed Right Shift): Desloca bits à direita preservando o bit de sinal.
• >>> (Unsigned Right Shift): Desloca bits à direita preenchendo os bits mais significativos sempre com zero.

// Configuração de Permissões usando potências de 2 (Bits 0, 1, 2, 3)
final int PERM_LEITURA  = 1 << 0; // 0001 (1)
final int PERM_ESCRITA  = 1 << 1; // 0010 (2)
final int PERM_EXECUCAO = 1 << 2; // 0100 (4)
final int PERM_ADMIN    = 1 << 3; // 1000 (8)

// Atribuindo Leitura e Escrita
int permissoesUsuario = PERM_LEITURA | PERM_ESCRITA; // 0011 (3)

// Testando se o usuário possui permissão de leitura
boolean podeLer = (permissoesUsuario & PERM_LEITURA) != 0; // true

---

🧵 2. Arquitetura Interna da Classe String e Imutabilidade

A classe java.lang.String é fundamental na plataforma Java e é estritamente imutável (final class com estado inalterável). Qualquer método que pareça modificar uma String (replace, toUpperCase, trim) na realidade aloca e retorna uma nova instância na memória.

Compact Strings (Desde o Java 9):

Historicamente, Strings em Java armazenavam um array de caracteres char[], consumindo 2 bytes por caractere (UTF-16). A partir do Java 9, a JVM adota Compact Strings: o armazenamento interno é um byte[] value acompanhado de um identificador de codificação coder:

• LATIN1 (1 byte por caractere): Ativado se todos os caracteres couberem em ISO-8859-1 (redução de 50% no consumo de Heap para textos comuns).
• UTF16 (2 bytes por caractere): Ativado apenas quando houver caracteres fora do padrão Latin-1 (acentuação complexa, alfabetos asiáticos, emojis).

O Pool de Constantes de Strings (String Constant Pool)

Literais de String declarados no código são cacheados numa tabela hash especial gerenciada pela JVM na Heap:

String s1 = "Java21";
String s2 = "Java21";
String s3 = new String("Java21");

System.out.println(s1 == s2); // true (Apontam para a mesma referência no Pool)
System.out.println(s1 == s3); // false (s3 foi forçado na Heap fora do pool)
System.out.println(s1.equals(s3)); // true (Conteúdo idêntico)

---

🏗️ 3. Manipulação Eficiente: StringBuilder vs Concatenação (+)

Quando concatenamos strings em um laço repetitivo através do operador +, o código gera um novo objeto StringBuilder e converte em String a cada iteração, resultando em uma complexidade de tempo quadrática $O(N^2)$ e pressão severa sobre o Garbage Collector.

Vantagens do StringBuilder:

O StringBuilder mantém um buffer interno mutável que é expandido sob demanda (capacidade inicial padrão de 16 caracteres, expandindo para $capacidade \times 2 + 2$).

• StringBuilder: Não sincronizado, rápido, ideal para uso em métodos locais ou em thread única.
• StringBuffer: Thread-safe, possui métodos com synchronized, porém possui sobrecarga de sincronização (praticamente substituído pelo StringBuilder em código moderno).

Recursos Modernos de Strings no Java 11/17/21:

• .strip(), .stripLeading(), .stripTrailing(): Remoção de espaços em branco Unicode (superior ao .trim()).
• .isBlank(): Valida se a string é vazia ou composta unicamente por espaços.
• .lines(): Retorna uma Stream<String> dividida por quebras de linha \n ou \r\n.
• .repeat(n): Repete o conteúdo $n$ vezes de forma otimizada.
• Text Blocks ("""): Strings multi-linhas com controle inteligente de indentação.

---

📊 4. Matriz Comparativa de Construção de Textos

Característica	String	StringBuilder	StringBuffer
Mutabilidade	Imutável	Mutável	Mutável
Thread Safety	Sim (por imutabilidade)	Não (alta performance)	Sim (métodos sincronizados)
Consumo de Memória em Concatenações	Muito Alto ($O(N^2)$ em laços)	Otimizado (Buffer redimensionável)	Otimizado com overhead de locks
Local de Armazenamento	Heap / String Pool	Heap comum	Heap comum
Cenário de Uso	Mensagens, chaves de mapa, DTOs	Montagem dinâmica de queries, logs	Código legado multithread

---

💻 5. Código de Demonstração Corporativo (Java 21 LTS)

package com.empresa.fundamentos;

/**
 * Sistema de segurança de arquivos com controle Bitwise e renderização de relatório com StringBuilder.
 */
public class GestorSegurancaTexto {

    // Máscaras de Bits para Níveis de Permissão POSIX-like
    public static final int AUTH_READ    = 1 << 0; // 0000 0001 (1)
    public static final int AUTH_WRITE   = 1 << 1; // 0000 0010 (2)
    public static final int AUTH_EXECUTE = 1 << 2; // 0000 0100 (4)
    public static final int AUTH_AUDIT   = 1 << 3; // 0000 1000 (8)

    public static String decodificarPermissoes(int mascara) {
        StringBuilder sb = new StringBuilder(4);
        sb.append((mascara & AUTH_READ) != 0 ? "R" : "-");
        sb.append((mascara & AUTH_WRITE) != 0 ? "W" : "-");
        sb.append((mascara & AUTH_EXECUTE) != 0 ? "X" : "-");
        sb.append((mascara & AUTH_AUDIT) != 0 ? "A" : "-");
        return sb.toString();
    }

    public static void main(String[] args) {
        int usuarioComum = AUTH_READ;
        int desenvolvedor = AUTH_READ | AUTH_WRITE | AUTH_EXECUTE;
        int auditorSeguranca = AUTH_READ | AUTH_AUDIT;

        // Manipulação avançada com Text Blocks e String Methods
        String templateRelatorio = """
        ================================================================================
                    RELATÓRIO DE PRIVILÉGIOS E ACESSO AO SISTEMA (JAVA 21)              
        ================================================================================
        ID DO PERFIL | NOME DO GRUPO        | BINÁRIO  | MÁSCARA TEXTUAL | STATUS
        -------------+----------------------+----------+-----------------+--------------
        %s
        ================================================================================
        """;

        StringBuilder linhas = new StringBuilder();
        Object[][] perfis = {
            { 1, "Usuários Finais", usuarioComum },
            { 2, "Engenharia DevOps", desenvolvedor },
            { 3, "Auditoria Externa", auditorSeguranca }
        };

        for (Object[] p : perfis) {
            int id = (int) p[0];
            String nome = (String) p[1];
            int mask = (int) p[2];
            String bits = String.format("%4s", Integer.toBinaryString(mask)).replace(' ', '0');
            String decoded = decodificarPermissoes(mask);
            boolean isAdmin = (mask & (AUTH_WRITE | AUTH_EXECUTE)) == (AUTH_WRITE | AUTH_EXECUTE);

            linhas.append(String.format("     %02d      | %-20s | %-8s |      %-10s | %s%n",
                    id, nome, bits, decoded, isAdmin ? "PRIVILEGIADO" : "PADRÃO"));
        }

        System.out.printf(templateRelatorio, linhas.toString().stripTrailing());
    }
}