es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Recorrer una lista de mapas de manera eficiente

26 Jul, 2023 Programación

Básicamente tengo una List<Map<String, Object>> listOfValue y necesito comprobar si el objeto es una instancia de byte y luego codificarlo como una cadena de caracteres, como se muestra a continuación:

private void convertirByteABase64(List<Map<String, Object>> listOfValue) {

Object valor = null;


if (!CollectionUtils.isEmpty(listOfValue)) {

    for (Map<String, Object> mapa : listOfValue) {

        if (!mapa.isEmpty()) {

            for (Map.Entry<String, Object> entrada : mapa.entrySet()) {

                valor = entrada.getValue();

                if (valor instanceof byte[]) {

                    entrada.setValue(Base64.getEncoder().encodeToString((byte[]) valor));
                }
            }

        }

    }

}

}

Estoy usando Java 8 y funciona como se espera, pero ¿es esta la forma correcta de hacerlo o hay alguna otra forma mejor en términos de rendimiento?

Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Tu implementación para convertir un array de bytes a una cadena codificada en Base64 usando java-8 y streams se ve bien en términos de funcionalidad. Sin embargo, hay algunas sugerencias que puedes considerar para mejorar el rendimiento:

    1. Utiliza List.forEach en lugar de un bucle anidado:

    En lugar de hacer un bucle sobre listOfValue y map.entrySet() usando bucles anidados, puedes utilizar List.forEach para recorrer la lista y luego aplicar un stream sobre los valores del mapa para verificar si son arrays de bytes y realizar la codificación. Esto reducirá el número de iteraciones necesarias y hará que el código sea más legible.

    listOfValue.forEach(map -> {
    map.values().stream()
            .filter(value -> value instanceof byte[])
            .map(value -> Base64.getEncoder().encodeToString((byte[]) value))
            .forEach(encodedValue -> {
                // Reemplaza el array de bytes original con el valor de cadena codificado
                map.entrySet().stream()
                        .filter(entry -> entry.getValue() == value)
                        .findFirst()
                        .ifPresent(entry -> entry.setValue(encodedValue));
            });
});
    1. Utiliza parallelStream() para listas más grandes:

    Si tu listOfValue es muy grande, puedes considerar usar un parallel stream para aprovechar los procesadores multinúcleo. Sin embargo, ten en cuenta que los parallel streams tienen cierto sobrecosto, por lo que es importante medir y probar antes de usarlos.

    listOfValue.parallelStream().forEach(map -> {
    map.values().parallelStream()
            .filter(value -> value instanceof byte[])
            .map(value -> Base64.getEncoder().encodeToString((byte[]) value))
            .forEach(encodedValue -> {
                // Reemplaza el array de bytes original con el valor de cadena codificado
                map.entrySet().parallelStream()
                        .filter(entry -> entry.getValue() == value)
                        .findFirst()
                        .ifPresent(entry -> entry.setValue(encodedValue));
            });
});

    En general, tu implementación es correcta y funcional, pero hay algunas optimizaciones que puedes considerar para mejorar el rendimiento con Java 8 streams.

Comments are closed.