Sistema D’Hont con C#

Sistema D’Hont con C#

En el post de Arithmos, explico el sistema de selección de diputados mediante el método D’Hont, pero como no, se me ocurrió crear el sistema bajo C# y ahí va.


    public class CongresoDiputados
    {
        public CongresoDiputados()
        {
            Circunscripciones = new List();
            PartidosCircunscripciones = new List();
            PartidosCongreso = new List();
        }
        public List Circunscripciones { get; set; }
        public List PartidosCircunscripciones { get; set; }
        public List PartidosCongreso { get; set; }

        public void Update(List circunscripciones)
        {
            Circunscripciones = circunscripciones;
            circunscripciones.ForEach(c => PartidosCircunscripciones.AddRange(c.PartidosCircunscripcion));
            PartidosCongreso = (from u in PartidosCircunscripciones
                         group u by u.Nombre into newGroup
                         select new PartidoPolitico(newGroup.Key)
                         {
                             DiputadosAsignados = newGroup.Sum(s => s.DiputadosAsignados),
                             NumVotos = newGroup.Sum(s=>s.NumVotos)
                         }).ToList();
        }

        public new string ToString => $"Congreso de los Diputados - Resultado Elecciones\n{PartidosCongreso.Aggregate("", (s, p) => s + p.ToString)}";
    }

    public class Circunscripcion
    {
        public Circunscripcion(string nombre, int diputados)
        {
            NombreCircunscripcion = nombre;
            Diputados = diputados;
            PartidosCircunscripcion = new List();
        }
        public string NombreCircunscripcion { get; set; }
        public int Diputados { get; set; }

        public List PartidosCircunscripcion { get; set; }

        public void Update(List partidos)
        {
            partidos.ForEach(p => Update(p));
        }

        public void Update(PartidoPolitico partido)
        {
            partido.Cociente = Diputados;
            if (PartidosCircunscripcion.Contains(partido))
            {
                PartidosCircunscripcion.Where(p => p.Nombre == partido.Nombre).FirstOrDefault().NumVotos = partido.NumVotos;
            }
            else
            {
                PartidosCircunscripcion.Add(partido);
            }

            var list = new List();
            PartidosCircunscripcion.ForEach(k => list.AddRange(k.Distribuciones));
            var listaOrdenada= list
                .OrderByDescending(v => v.ParticionVotos)
                .Take(Diputados);
            PartidosCircunscripcion.ForEach(k => k.DiputadosAsignados = listaOrdenada.Where(p => p.Nombre == k.Nombre).Count());

        }

        public new string ToString => $"{PartidosCircunscripcion.Aggregate("", (s, p) => s + p.ToString)}";
    }

    public class PartidoPolitico
    {
        public PartidoPolitico(string nombre) : this(nombre, 0) { }

        public PartidoPolitico(string nombre, int numVotos)
        {
            Nombre = nombre.PadRight(10,' ');
            NumVotos = numVotos;
        }

        public string Nombre { get; set; }
        public int NumVotos { get; set; }

        public int Cociente { get; set; } = 10;

        public int DiputadosAsignados { get; set; }

        public List Distribuciones
        {
            get {
                var l = new List();
                l.AddRange(Enumerable.Range(1, Cociente).ToList().Select(n => new Distribucion(Nombre, NumVotos / n)).ToList());
                return l;
            }
        }

        public new string ToString => $"{Nombre}\t{NumVotos} Votos\t\tDiputados:\t{DiputadosAsignados}\n";
    }

    public class Distribucion
    {
        public Distribucion(string nombre, int votos)
        {
            Nombre = nombre;
            ParticionVotos = votos;
        }
        public string Nombre { get; set; }
        public int ParticionVotos { get; set; }
    }

He incluido alguno de los resultados de las elecciones del 10N del 2019 y he aquí los resultados

    class Program
    {
        static void Main(string[] args)
        {

            Circunscripcion Malaga = new Circunscripcion("Málaga", 11);
            Malaga.Update(new List() {
                new PartidoPolitico("PSOE", 225344),
                new PartidoPolitico("PP", 162467),
                new PartidoPolitico("Vox", 161657),
                new PartidoPolitico("UP", 96988),
                new PartidoPolitico("Cs", 66524)});
            Console.WriteLine(Malaga.ToString);

            Circunscripcion Madrid = new Circunscripcion("Madrid", 37);
            Madrid.Update(new List() {
                new PartidoPolitico("PSOE", 948751),
                new PartidoPolitico("PP", 879667),
                new PartidoPolitico("Vox", 647924),
                new PartidoPolitico("UP", 459030),
                new PartidoPolitico("Cs", 316310),
                new PartidoPolitico("Mas Pais", 199172) });
            Console.WriteLine(Madrid.ToString);

            CongresoDiputados Congreso = new CongresoDiputados();
            Congreso.Update(new List()
            {
                Malaga, Madrid
            });
            Console.WriteLine(Congreso.ToString);
            Console.Read();
        }
    }

PSOE            225344 Votos            Diputados:      4
PP              162467 Votos            Diputados:      3
Vox             161657 Votos            Diputados:      2
UP              96988 Votos             Diputados:      1
Cs              66524 Votos             Diputados:      1

PSOE            948751 Votos            Diputados:      10
PP              879667 Votos            Diputados:      10
Vox             647924 Votos            Diputados:      7
UP              459030 Votos            Diputados:      5
Cs              316310 Votos            Diputados:      3
Mas Pais        199172 Votos            Diputados:      2

Congreso de los Diputados - Resultado Elecciones
PSOE            1174095 Votos           Diputados:      14
PP              1042134 Votos           Diputados:      13
Vox             809581 Votos            Diputados:      9
UP              556018 Votos            Diputados:      6
Cs              382834 Votos            Diputados:      4
Mas Pais        199172 Votos            Diputados:      2

Como siempre, el código mejorable.

Calculadora de números complejos en Kotlin

Calculadora de números complejos en Kotlin
I kt
Siempre me ha gustado C#, quero recordar cuando apareció Linq y las funciones lambda, operador Elvis, inicializadores de propiedades automáticas, la magia asincrónica, etc.. Java añadió a su código novedades, la guerra de “mi lenguaje es mejor” y… de un lenguaje de una empresa que casi nadie conocía, se va haciendo hueco hasta que Google alabando su velocidad de compilación, facilidad y simplicidad, lo nombra lenguaje oficial de Android allá por el 2017. En 2018, me da por investigar Kotlin, porque no seré el primero que ha aprendido un lenguaje que luego no ha pasado de cuartos y según avanzaba con Kotlin, más y más me gustaba, de hecho cada día me asombra y descubro alguna bondad que me aporta.Bueno, ya que he halagado, alabado, agasajado, piropeado y adulado a Kotlin, retomo una calculadora de números complejos en este lenguaje ya que la tengo en este blog en C# y Java y se ha alineado las mates y este lenguaje, así que no hay más remedio (le tocará a la calculadora IP, a matrices, a…).

Lo mejor de esta, su simplicidad en tan poco tiempo, seguro que si le dedicas un poco de tiempo, se puede simplificar más, pero esto lo dejo para vosotros. He aquí el código de una calculadora de números complejos para consola o para lo que queráis con Kotlin.


class Complex (var x: Double = 0.0, var y: Double = 0.0, val isDegrees: Boolean = false){

    var module: Double = 0.toDouble()
    var grades: Double = 0.toDouble()

    init {
        this.module = Math.sqrt(Math.pow(x, 2.0) + Math.pow(x, 2.0))
        this.grades = Math.atan2(y, x)
    }

    operator fun plus(complex: Complex):Complex = plusComplex(complex)
    operator fun minus(complex: Complex):Complex = substractComplex(complex)
    operator fun times(complex: Complex):Complex = multiplyComplex(complex)
    operator fun div(complex: Complex):Complex = divideComplex(complex)

    fun toVectorialString(): String ="(${toNumber(this.x, 2)}, ${toNumber(this.y, 2)})"

    override fun toString(): String ="${toNumber(this.x, 2)} ${if (this.y < 0) "" else  "+"} ${toNumber(this.y, 2)}i"

    fun toPolarString(): String {
        val angle = if (isDegrees) this.grades * 180 / Math.PI else this.grades
        val angleToString =
            "${(if (isDegrees) toNumber(angle, 1) else toNumber(angle, 3))} ${if (isDegrees) 'º' else " radians"}"
        return "${toNumber(this.module, 1)} )  $angleToString"
    }

    fun conjugate(complex: Complex = this): Complex = Complex(complex.x, -complex.y)

    fun opposite(complex: Complex = this): Complex = Complex(-complex.x, -complex.y)

    fun reverse(complex: Complex = this): Complex {
        return Complex(complex.x / denominator(), -complex.y / denominator())
    }

    fun equals(complex: Complex?): Boolean =complex != null && this.javaClass == complex.javaClass && this.x == complex.x && this.y == complex.y

    private fun denominator(complex: Complex=this) = Math.pow(complex.x, 2.0) + Math.pow(complex.y, 2.0)

    private fun plusComplex(complex: Complex): Complex {
        return Complex(this.x + complex.x, this.y + complex.y)
    }

    private fun substractComplex(complex: Complex): Complex = Complex(this.x - complex.x, this.y - complex.y)

    private fun multiplyComplex(complex: Complex): Complex {
        return Complex(
            this.x * complex.x - this.y * complex.y,
            this.x * complex.y + this.y * complex.x
        )
    }

    private fun divideComplex(complex: Complex): Complex = divideComplex(this, complex)

    private fun divideComplex(complex1: Complex, complex2: Complex): Complex {
        val xx = (complex1.x * complex2.x + complex1.y * complex2.y) / (Math.pow(
            complex2.x,
            2.0
        ) + Math.pow(complex2.y, 2.0))
        val yy = (complex1.y * complex2.x - complex1.x * complex2.y) / (Math.pow(
            complex2.x,
            2.0
        ) + Math.pow(complex2.y, 2.0))
        return Complex(xx, yy)
    }

    companion object {

        fun convertToBinomial(module: Double, argument: Double):Complex = convertPolarToBinomial(module, argument)

        fun convertPolarToBinomial(module: Double, argument: Double): Complex = Complex(abs(module) * cos(argument), -abs(module) * sin(argument))

        fun toNumber(number: Double, digits: Int): String {
            val fn = NumberFormat.getNumberInstance()
            fn.maximumFractionDigits = digits
            return fn.format(number)
        }
    }
}


y el resultado


fun main(args:Array){
    val c1 = Complex(3.0,4.0)
    val c2 = Complex(5.0,6.0)

    println(c1.toString())


    println(c2.toString())
    println(c1+c2)
    println(c1-c2)
    println(c1*c2)
    println(c1/c2)
    println(c1.reverse())
    println(c1.conjugate())

}

3 + 4i
5 + 6i
8 + 10i
-2  -2i
-9 + 38i
0,64 + 0,03i
0,12  -0,16i
3  -4i

PD: Kotlin es el lenguaje oficial de Android, pero también permite desarrollar aplicaciones de consola, de escritorio, WEB, etc., es multiplataforma, ya que corre bajo la JVM y puede ser compilado a JavaScript.

Señores de WordPress, ¿Cuando podré publicar lenguaje Kotlin en su editor?

Dead XOR Alive

Dead XOR Alive

En uno de mis blogs, en Arithmos, publiqué un post sobre una historia de carceleros y presos; minutos después de acabar el artículo, dije, ¿por qué no hago una app que lo muestre?, dicho y hecho, me puse y en una tarde desarrollada estaba.

Y ¿por qué digo esto? para demostrar lo fácil que es desarrollar una pequeña aplicación con C# y WPF.

Si leen el artículo, podrán observar que la aplicación solo muestra un tablero de ajedrez, con monedas en cada casilla con una cara o una cruz aleatoriamente, un cuadro mágico que es el elegido por el carcelero y un cuadro del tablero que debe calcular uno de los presos para que el siguiente convicto les salve de la muerte, este último cuadro no es otro que una operación XOR.

El modelo podría ser una clase Chessboard que alberga objetos del tipo CoinBox, las monedas que ya de camino le diremos que color tiene el cuadro donde se apoyan en el tablero.

    public class Chessboard
    {
        public List CoinsBox { get; set; }

        public Chessboard() : this(-1) { }

        public Chessboard(int headsCount)
        {
            CoinsBox = new List();
            FillChessboard(headsCount);
        }

        ///
        /// Rellena el tablero con cuadros y monedas aleaotorias con cara y cruz
        /// 

        /// Número de caras. si es -1, se genera aletoriamente
        void FillChessboard(int headsCount)
        {
            var random = new Random();

            headsCount = headsCount == -1 ? random.Next(64) : headsCount;

            // Llenar Lista con monedas con cruz
            Enumerable.Range(0, 64).ToList()
            .ForEach(n => CoinsBox.Add(new CoinBox(n, false, (n / 8) % 2 == 0 ? n % 2 == 0 : n % 2 != 0)));

            // Cambiar n monedas a cara
            Enumerable.Range(0, headsCount).ToList().ForEach(n => CoinsBox[random.Next(64)].IsHeads = true);

            // Cuadro mágico
            CoinsBox[random.Next(64)].IsMagicBox = true;

            // Cuadro que debe cambiar
            var changed= CoinsBox
                .Where(n => n.IsHeads).Aggregate(MagicBox.Index, (acum, n) => acum ^ n.Index, op => op);
            CoinsBox[changed].IsChangedBox = true;

        }

        public CoinBox MagicBox => CoinsBox.Where(n => n.IsMagicBox).FirstOrDefault();
        public CoinBox ChangedBox => CoinsBox.Where(n => n.IsChangedBox).FirstOrDefault();
        public int ParityChessboard => CoinsBox
                .Where(n => n.IsHeads).Aggregate(0, (acum, n) => acum ^ n.Index, op => op);

        public string ParityChessboardToString => $"La paridad del tablero es {ParityChessboard}";
        public string ResultToString => $"Si cambiamos la moneda {ChangedBox.Index}, la paridad del tablero será {MagicBox.Index} que es el cuadrado mágico!!!";
        public string MagicBoxToString => $"El cuadro mágico seleccionado por el carcelero es el número {MagicBox.Index}";
        public string ChangeBoxToString => $"La moneda que debe cambiar el convicto es la número {ChangedBox.Index}";
        public string ListaXORToString => $"La operación XOR de las monedas que tienen cara {string.Join(", ", CoinsBox.Where(k => k.IsHeads).Select(i => i.Index))} y el cuadro mágico {MagicBox.Index} da como resultado {ChangedBox.Index} o la operación XOR entre el cuadro mágico {MagicBox.Index} y la paridad del tablero {ParityChessboard} es {ChangedBox.Index}";
    }

    public class CoinBox
    {

        public CoinBox(int index, bool isHeads, bool isBlack)
        {
            Index = index;
            IsHeads = isHeads;
            IsBlack = isBlack;
        }

        public int Index { get; set; }

        public bool IsHeads { get; set; }

        public bool IsTails { get { return !IsHeads; } }

        public bool IsChangedBox { get; set; }

        public bool IsMagicBox { get; set; }

        public bool IsBlack { get; set; }
    }

Como algo particular, la asignación del color del cuadro mediante la operación (n / 8) % 2 == 0 ? n % 2 == 0 : n % 2 != 0) con la que con el índice del cuadro le decimos si el cuadro es negro o blanco o las expresiones lambda que calculan la operación XOR sobre una lista de elementos mediante la función lambda Aggregate, la cual le pasamos un parámetro acumulador inicial y posteriormente es usado elemento a elemento con la operación XOR.Para la vista, he creado un control definido por el usuario llamado Box, el cual contiene el Binding cambiando su aspecto según las propiedades del objeto CoinBox asociado a su Datacontext. Como podéis ver a continuación, creo converter para transformar valores booleanos en Visibility, Brush o Bitmap. (Si alguien los quiere los converter, los cuelgo)

<UserControl x:Class="DxorAlive.Box"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:DxorAlive"
             mc:Ignorable="d" 
             d:DesignHeight="43" d:DesignWidth="43" Margin="1">
    <UserControl.Resources>
        <local:BoolToVisibleConverter x:Key="b2tvc" Reverse="False"/>
        <local:ImageConverter x:Key="itc"/>
        <local:BoolToColorConverter x:Key="btcc"/>
    </UserControl.Resources>
    <Grid>

        <Rectangle Width="64" Height="64" Stroke="Gray" StrokeThickness="1" Fill="{Binding IsBlack, Converter={StaticResource btcc}}"/>
        <Rectangle Width="62" Height="62" Stroke="Red" StrokeThickness="2" Visibility="{Binding IsMagicBox, Converter={StaticResource b2tvc}}"/>
        <Rectangle Width="60" Height="60" Stroke="Orange" StrokeThickness="2" Visibility="{Binding IsChangedBox, Converter={StaticResource b2tvc}}"/>
        <Image Source="{Binding IsHeads, Converter={StaticResource itc}}" Height="48"/>
    </Grid>
</UserControl>

Ahora solo nos queda crear o con xml o desde la clase de la vista (runtime) una matriz de objetos cada uno con su datacontext. Yo lo he he desarrollado con código en vez de crear 64 cuadros del tipo Box. Llamamos al método FillChessboard y se genera un nuevo tablero.

        private void FillChessboard(int headsCount)
        {
            grid.Children.Clear();
            // Crear tablero
            var cb = new Chessboard(headsCount);

            //crear cuadros y monedas
            cb.CoinsBox.ForEach(n =>
            {
                var c = new Box();
                c.DataContext = n;
                var row = n.Index / 8;
                var col = n.Index % 8;
                Grid.SetRow(c, row);
                Grid.SetColumn(c, col+1);
                grid.Children.Add(c);
            });

            this.DataContext = cb;

        }

he aquí el resultado. Un saludo a tod@s

deadxoralive1.png
Os dejo el enlace del ejecutable

PD: Y como llevo una temporada enamorado de Kotlin, os paso código en este lenguaje para una app de consola. I ♥ kt

 
import kotlin.random.Random

fun main(args: Array) {
    val c= Chessboard(5)
    println(c)

}


class Chessboard(var headsCount: Int) {
    val coinsBox = mutableListOf()

    init {
        headsCount = if (headsCount == -1) Random.nextInt(64) else headsCount
        fillChessboard()
    }

    private fun fillChessboard() {
        // Rellenar de monedas
        (0..63).toList().forEach {
            coinsBox.add(CoinBox(it, false, if ((it / 8) % 2 == 0) (it % 2 == 0) else (it % 2 != 0)))
        }
        // Caras
        (0..headsCount!!).toList().forEach { coinsBox[Random.nextInt(64)].isHeads = true }
        // cuadro mágico
        val vMB = Random.nextInt(64)
        coinsBox[vMB].isMagicBox = true
        // moneda cambiante
        coinsBox[coinsBox.filter { i-> i.isHeads }.fold(vMB) { acc, opXOR -> acc.xor(opXOR.index) }].isChangedBox=true

    }

    override fun toString(): String {
        return "$magic\n$parityToString\n$changed\n$result\n$listaXOR\n$chessboard"
    }

    val magicBox = coinsBox.filter { n -> n.isMagicBox }.firstOrNull()
    val changedBox = coinsBox.filter { n -> n.isChangedBox }.firstOrNull()
    val parityChessBoard = coinsBox[coinsBox.filter { i-> i.isHeads }.fold(0) { acc, opXOR -> acc.xor(opXOR.index) }]

    val parityToString= "La paridad del tablero es ${parityChessBoard.index}"
    val result = "Si cambiamos la moneda ${changedBox?.index}, la paridad del tablero será ${magicBox?.index} que es el cuadrado mágico"
    val magic = "El cuadro seleccionado por el carcelero es el número ${magicBox?.index}"
    val changed = "La moneda que debe cambiar el convicto es la número ${changedBox?.index}"
    val listaXOR = "La operación XOR de las monedas que tienen cara ${coinsBox.filter { k-> k.isHeads }.joinToString(", "){it.index.toString()}} " +
            "y el cuadro mágico ${magicBox?.index} da como resultado ${changedBox?.index} " +
            "\no la operación XOR entre el cuadro mágico ${magicBox?.index} y la paridad del tablero ${parityChessBoard.index} es ${changedBox?.index}"
    val chessboard = coinsBox.joinToString("") {k-> "\t${k.index} ${if (k.isHeads) "H" else "T"} ${if ((k.index+1) % 8==0) "\n" else ""}"  }

}


data class CoinBox(
    val index: Int,
    var isHeads: Boolean,
    var isBlack: Boolean,
    var isChangedBox: Boolean = false,
    var isMagicBox: Boolean = false

Binding WPF vs Binding Android – I

Binding WPF vs Binding Android – I
Este post, es el inicio de una tetralogía con el que pretendo mostrar los aspectos de desarrollo de ambas plataformas, Microsoft y Android en cuanto al uso de la arquitectura MVVM y Databinding.
Antes de nada veamos cuales son las diferencias esenciales del modelo vista controlador (MVC) y el modelo vista vista-modelo (MVVM).

Reproductor Android

Reproductor Android

List & Set

List & Set
A veces es muy importante elegir bien el tipo de listas de objetos y para ello debemos valorar distintos aspectos como si es necesario mantener el orden en nuestra lista, si la velocidad de cálculo es importante, si podemos usar iteraciones en paralelo, el hecho en si de usar arrays o listas.
En Java tenemos objetos que implementan la interfaz Collection, que a su vez implementan las interfaces Set y List y por otra parte la interfaz Map, todas parecidas pero no iguales.
La interfaz List. Esta está diseñada para trabajar con colecciones ordenadas y con valores repetidos e implementan esta interfaz ArrayList, LinkedList, Vector y Stack
La interfaz Set y SortedSet que hereda de la primera y la implementan las colecciones HashSet y TreeSet.
Otra interfaz es Map y SortedMap con las clases HashMap HashTable y TreeMap.
Listas01
Interfaces implementadas por las  colecciones
Listas02
Jerarquía de clases de las listas
Veamos algunos ejemplos basándonos en el rendimiento y para ello vamos a crear una clase llamada Factura y crearemos una lista con 1.000.000 de Facturas pasándole como argumento una base imponible aleatoria y a toda la colección le calcularemos el promedio del importe final con IVA obteniendo el tiempo empleado en ms. El cálculo del promedio lo haremos con dos expresiones lambda, una con una iteración en línea y otra en paralelo, de modo que también veremos si una colección es mejor para aprovechar las características de varios procesadores o no.

public class Factura {
    public Factura(double bi){
        baseImponible=bi;
    }
    String numFactura;
    double baseImponible;
    double iva=.21;

    public double getBaseImponible() {
        return baseImponible;
    }
    public void setBaseImponible(double baseImponible) {
        this.baseImponible = baseImponible;
    }
    public double getIva() {
        return iva;
    }
    public void setIva(double iva) {
        this.iva = iva;
    }
    public String getNumFactura() {
        return numFactura;
    }
    public void setNumFactura(String numFactura) {
        this.numFactura = numFactura;
    }
    public double getImporte() {
        return baseImponible * (1+iva);
    }
    @Override
    public String toString() {
        return "Factura{" + "numFactura=" + numFactura + ", importe=" + getImporte() + '}';
    }
}
static void addFacturas(){
        List facturas=new Stack();

        for (int i = 0; i f.getImporte()).average();
        long endTime = System.currentTimeMillis() - startTime;
        System.out.printf("Tiempo:          %s ms\n" , endTime);
        System.out.printf("Promedio:        %f\n" , promedio.getAsDouble());

        long startTime1 = System.currentTimeMillis();
        OptionalDouble promedio1= facturas.parallelStream().mapToDouble(f->f.getImporte()).average();
        long endTime1 = System.currentTimeMillis() - startTime1;

        System.out.printf("Tiempo paralelo: %s ms\n" , endTime1);
        System.out.printf("Promedio:        %f\n" , promedio1.getAsDouble());
    }
Colección Tiempo ms llenado Tiempo ms Tiempo paralelo
ArrayList 3266 ms 88 ms 48
LinkedList 6410 ms 134 ms 5830 ms
Vector 4444 ms 92 ms 52 ms
Stack 4594 ms 84 ms 53 ms
HashSet 9683 ms 789 ms 369 ms
TreeSet 18861 ms 637 ms 636 ms

¿Que ha pasado? ¿por qué tenemos valores de carga y valores de cálculo distintos? si son listas! Veamos los objetos que implementan la interfaz List.

El ArrayList es una lista de objetos basada en indices de acceso aleatorio donde el primero de los objetos tiene índice 0, permitiendo el ordenamiento a criterio del programador y elementos duplicados. Si nos fijamos en la tabla, se trata del objeto más eficiente en cuanto a carga de objetos y proceso de cálculo. (En el ejemplo claro, el post pretende mostrar que depende del tipo de lista, podemos obtener una mayor eficiencia).
Un ArrayList podríamos usarlo cuando necesitamos acceder frecuentemente a objetos gracias a su acceso aleatorio y acceso multihilo y no deberíamos usarlo cuando añadimos o eliminamos objetos de la lista con frecuencia. Debería ser la colección más usada.
LinkedList es una lista vinculada a otra con acceso secuencial, por tanto no es tan eficiente como los arrays. En el ejemplo, podemos observar que la carga es más tediosa y el cálculo mediante stream paralelo, se vuelve casi intratable, es decir con este objeto si intentamos realizar un stream aprovechando las capacidades multiprocesador, el resultado es totalmente opuesto al esperado. Podemos usar este tipo de lista cuando añadimos o eliminamos objetos con frecuencia.
Vector. Este tal y como lo hemos instanciado, con el constructor sin argumentos, se crea inicialmente con una longitud de 10 que una vez rebasado, se duplica sucesivamente por lo que en 18 pasos, la capacidad del Vector soporta el millón de facturas, de modo que al cargar los objetos, se produce un ligero retardo con respecto a un ArrayList que no hace ningún redimensionamiento, además sus métodos son sincronizados y solo permite un hilo de acceso a los datos, por tanto, su rendimiento es menor que el de un ArrayList.
Stack. Este objeto es una pila LIFO, Last In, First Out, último en entrar, primero en salir, por tanto solo debe usar para este tipo de funcionalidad.
Ahora analicemos los objetos que implementan la interfaz Set, la cual usamos para listas con objetos ordenados o no, sin objetos repetidos usando los métodos equals() y hashcode() para determinar la igualdad; el hecho de no incluir elementos repetidos, se debe a los métodos señalados.
HashSet. Esta colección es un fiel reflejo de su interfaz, no permite elementos repetidos, su crecimiento se basa en una capacidad inicial de 16, doblada en la siguiente redimensión y con factor de crecimiento de 0,75 en las posteriores y no permite ordenamiento. El hecho de no permitir duplicados, atiende a la falta de rendimiento del ejemplo, ya que cada vez que se añade un registro, se debe comprobar la no duplicidad del elemento.
TreeSetEsta colección ordena los elementos cada vez que se inserta uno nuevo, de ahí el gran retardo en la inserción de datos.

Como conclusión, es fundamental que analicemos la cantidad de datos a tratar, el número de inserciones y eliminaciones, ordenamientos, posibilidad de proceso multihilo y que cálculos vamos a realizar con los datos. Una vez analizados los datos, la elección de vuestra colección es el siguiente paso y a continuación, los test de rendimiento para retroalimentar el análisis en su caso.

Orden en la sala

Orden en la sala
Cuando queremos ordenar una lista sin que esta implemente la interfaz Comparator, podemos hacerlo también mediante programación funcional. Para comenzar, usaremos el objeto Persona y la colección de personas que tenemos en el post sobre Colecciones en Java.
En primer lugar usaremos el ordenamiento estándar con la clase Persona, en la que la clase implementa la interfaz Comparator de modo que debe existir un método llamado compareTo el cual podemos usar para ordenar por defecto.
Al crear un ArrayList personas=new ArrayList();, este tiene un método llamado sort(Comparator comparator) y por tanto necesitamos un objeto de este tipo con el que ordenar los elementos de la lista, de modo que tenemos que crear una clase Comparator

public class ComparatorByName implements Comparator{

    @Override
    public int compare(Persona o1, Persona o2) {
        return o1.compareTo(o2);
    }
    
}

o podemos instanciar el objeto desde el argumento del método sort, generando el bloque de código con el método compareTo

ArrayList personas=new ArrayList();
        
        personas.sort(new Comparator() {
            @Override
            public int compare(Persona o1, Persona o2) {
                return o1.compareTo(o2);
            }
        });

Con programación funcional, todo se vuelve más fácil, en el siguiente ejemplo creamos dos objetos Comparator a los que le pasamos dos argumentos de los dos objetos a comparar que coincide con la firma del método de comparación del objeto original, pudiendo incluso aprovechar los métodos compareTo de la clase String para crear nuestro comparador personalizado.

Comparator comparatorEstandar= (pa, pb)-> pa.compareTo(pb);
Comparator comparatorByName= (pa, pb)-> pa.getNombre().compareTo(pb.getNombre());
personas.sort(comparatorByName);
personas.sort(comparatorEstandar);

Com ya vimos en el post Colecciones, mediante stream podemos ordenar con:

  • Método de la clase
  • Añadiendo un objeto Comparator creado mediante programación funcional o estándar
  • Añadiendo a la expresión lambda dos parámetros y la comparación.
personas.stream().
            sorted().
            forEach(p-> System.out.println(p.getFullName()));
        
        personas.stream().
            sorted(comparatorByName).
            forEach(p-> System.out.println(p.getFullName()));
        
        personas.stream().
            sorted((pa,pb)-> pa.getNombre().compareTo(pb.getNombre())).
            forEach(p-> System.out.println(p.getFullName()));

Por último para rizar el rizo… y ¿si queremos ordenar por varios campos, por ejemplo primero por apellido y después por edad? esto es posible con el método thenComparing para añadir un nuevo orden con otro comparador anidado.

        
        Comparator<Persona> comparatorByNameAndAge= comparatorByName.thenComparing((p0,p1)->p0.compareTo(p1));.
            forEach(p-> System.out.println(p.getFullName()));