Capítulo 1 Conceptos básicos: notas fuente de Java

1 cadena, análisis de código fuente largo

1.1 cadena

• La inmutabilidad proviene de la clase String y el valor del atributo de clase [] se modifica con final. La clase no se puede heredar y su dirección de memoria no se puede modificar después de la asignación de propiedades.
• La cadena de caracteres está distorsionada y la cadena de caracteres se convierte en binaria. Debido a la codificación predeterminada de los diferentes sistemas, aparecen caracteres confusos .
• Capitalización de la primera letra , name.substring (0, 1) .toLowerCase () + name.substring (1); name.substring (0, 1) .toUpperCase () + name.substring (1).
• Juicio de igualdad , los métodos son equals () y equalsIgnoreCase (), juzgan si dos cadenas coinciden y juzgan si los caracteres son iguales uno por uno
• Reemplazar, eliminar , reemplazar, reemplazar todo y reemplazar primero.
• Herramientas de división y fusión , Splitter y Joiner of Guava.

1.2 largo

• Problemas de almacenamiento en
  caché En caché -128 a 127. Si es un valor en este rango, tome el valor de aquí Datos de caché de clase estática interna.

private static class LongCache {
    private LongCache(){}
    // 缓存，范围从 -128 到 127，+1 是因为有个 0
    static final Long cache[] = new Long[-(-128) + 127 + 1];

    // 容器初始化时，进行加载
    static {
        // 缓存 Long 值，注意这里是 i - 128 ，所以再拿的时候就需要 + 128
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Long(i - 128);
    }
}

1.3 Entrevista

• 3.1 Al usar Long, recomendamos usar el método valueOf cada vez menos usando el método parseLong.
  Respuesta: Debido a que Long tiene un mecanismo de almacenamiento en caché, el Long en el rango de -128 a 127 se almacena en caché. El método valueOf obtendrá el valor del caché. , Reducirá la sobrecarga de recursos, el método parseLong no tiene este mecanismo.

2 palabras clave de uso común en Java

2.1 estático

Estática, modificar variables de clase, métodos, bloques de métodos. Las variables de clase estática deben prestar atención a los problemas de seguridad concurrentes.
Tiempo de inicialización

public class Parent {
    public static List<String> PARENT_LIST = new ArrayList() {{
        System.out.println("parent 静态变量初始化");
    }};

    static {
        System.out.println("parent 静态代码块初始化");
    }

    public Parent(){
        System.out.println("parent 构造器初始化");
    }

    public void testStatic(){
        System.out.println("parent 静态方法执行");
    }
}

public class Son extends Parent {
    public static List<String> LIST = new ArrayList() {{
        System.out.println("son 静态变量初始化");
    }};

    static {
        System.out.println("son 静态代码块初始化");
    }

    public Son() {
        System.out.println("son 构造器初始化");
    }

    public void testSonStatic(){
        System.out.println("son 静态方法执行");
    }

    public static void main(String[] args) {
        System.out.println("main 执行");
        new Son();
    }
}

Imprimir los resultados:
matriz de inicialización estática
bloque estático matriz de código inicializa
hijo inicialización estática
bloque hijo estático de código inicializa
ejecución principal
constructor inicializa padre
hijo constructor inicializa
Conclusión

• Las variables estáticas de la clase primaria y los bloques de código estático se inicializan antes que las clases secundarias;
• Las variables estáticas y los bloques de código estático se inicializan antes que los constructores;
• El constructor de la clase principal tiene prioridad sobre la inicialización de la clase secundaria.

2.2 final

• Las clases modificadas por final no pueden heredarse;
• Un método modificado por final significa que el método no puede sobrescribirse;
• Una variable modificada por final significa que la variable debe inicializarse cuando se declara, y la dirección de memoria no se puede cambiar. Tenga en cuenta que la dirección de memoria no se puede cambiar, no el valor. Para objetos como Lista y Mapa, se puede cambiar el valor.

2.3 intente atrapar finalmente

public class TryCatchFinally {
    public static void main(String[] args) {
        TryCatchFinally tryCatchFinally = new TryCatchFinally();
        tryCatchFinally.test();
    }

    public void test(){
        try {
            System.out.println("log try");
            if (true) {
                throw new RuntimeException("try exception");
            }
        } catch (Exception e) {
            System.out.println("log catch");
            if (true) {
                throw new RuntimeException("catch exception");
            }
        } finally {
            System.out.println("log finally");
        }
    }
}

Try
og intente
log catch
log finalmente
Excepción en el hilo "main" java.lang.RuntimeException: captura excepción

• finalmente ejecutar primero, luego lanzar una excepción;

2.4 volátil

Explicación volátil en inglés: es probable que cambie repentina e inesperadamente, especialmente empeorando, lo que significa volátil. Se usa para compartir variables decoradas.
** Principio subyacente: ** Cuando se ejecutan varios subprocesos en varias CPU por separado, para acelerar, el subproceso no lee la variable compartida de la memoria, sino del caché de la CPU, entonces hay un problema cuando el subproceso un cambio cuando el valor de la variable X, debido a la presencia de caché de la CPU, hilo B no conoce la variable X se ha modificado, lo que conduce a un problema de valor variable X inconsistente .
Solución: modifique la variable X con volátil. Cuando el subproceso A cambia el valor de la variable X, la memoria notificará a otras CPU que la variable X de su caché de la CPU no es válida, y otros subprocesos leen la variable X de la memoria nuevamente para garantizar la consistencia de los datos.

2.5 transitorios

La variable de clase modificada significa que esta variable se ignora cuando la clase se serializa.

2.6 por defecto

Se utiliza para modificar el método de la interfaz, lo que indica que la subclase del método no es válida, pero la interfaz debe tener una implementación predeterminada.

public interface ParentInterface {
    default void testMy() {
        System.out.println("do something");
    }
}

2.7 Preguntas de la entrevista

1. ¿Cómo demostrar que las variables estáticas no están relacionadas con las clases?

• No es necesario inicializar la clase, puede usar variables estáticas directamente;
• Escriba el método principal en la clase, incluso si el código de la clase no se inicializa, las variables estáticas se inicializarán automáticamente;
• Las variables estáticas solo se inicializan una vez, y no importa cuántas clases sean nuevas, las variables estáticas se inicializan solo una vez.

3 matrices, colecciones, objetos método común análisis de código fuente

3.1 Características generales de las herramientas.

1. El constructor es privado, no hay necesidad de salir;
2. Los métodos son generalmente modificados por static y final.

3.2 matrices

Las matrices se utilizan principalmente para tratar matrices, como ordenar, buscar, rellenar, etc.

3.2.1 Ordenar

Admite muchos tipos de parámetros, ven a una demostración:

package demo.two;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.ImmutableList;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

@Slf4j
public class MyArraysDemoTest {
    @Test
    public void testSort() {
        List<MySort> list = ImmutableList.of(
                new MySort("100"),
                new MySort("200"),
                new MySort("600"),
                new MySort("220"),
                new MySort("150")
        );
        MySort[] mySorts = new MySort[list.size()];
        list.toArray(mySorts);
        log.info("before mySorts={}", JSON.toJSONString(mySorts));
        Arrays.sort(mySorts, Comparator.comparing(MySort::getValue));
        log.info("after mySorts={}", JSON.toJSONString(mySorts));
    }

    @Data
    class MySort {
        private String value;
        public MySort(String value) {
            this.value = value;
        }
    }

}

3.2.2 Búsqueda binaria

3.2.3 Copia

copyOf (), copyOfRange () (copia parcial).

3.3 Colecciones

Herramientas utilizadas por la colección.

3.3.1 Encontrar el máximo y el mínimo

Colecciones.max () y min () métodos.

Especial: <T extiende Object & Comparable <? Super T >> significa que se requiere T para heredar la clase Object e implementar la interfaz Comparable.

3.3.2 Múltiples tipos de colecciones

Hay colecciones seguras para subprocesos (comienzo sincronizado) y colecciones inmutables (comienzo no modificable), consulte la implementación subyacente.


Puede ver que las operaciones están bloqueadas.
Una colección inmutable es una nueva colección de la colección original, que solo se puede leer pero no escribir.

3.4 objetos

Se utiliza principalmente para juzgar la igualdad y juzgar vacío.

3.4.1 Juicio de igualdad

Objetos proporciona iguales y profundos. Igual dos métodos para juzgar la igualdad, el primero es determinar los tipos básicos y las clases personalizadas, el segundo se usa para determinar la matriz.

3.4.2 Juicio

Los objetos proporcionan varios juicios sobre nulo. IsNull y nonNull devuelven un valor booleano para determinar si el objeto es nulo. El método requireNonNull es más estricto. Si es nulo, se lanzará una excepción directamente.