Java - Ayudaa

 
Vista:
sin imagen de perfil
Val: 17
Ha aumentado 1 puesto en Java (en relación al último mes)
Gráfica de Java

Ayudaa

Publicado por Jhonnan esmid (1 intervención) el 16/09/2020 15:01:18
16002612157787761679759636928530
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
-5
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayudaa

Publicado por Kabuto (1381 intervenciones) el 17/09/2020 00:30:54
Comienza tú un código, aunque no lo termines, pero algo... un mínimo a partir del cuál ayudarte a completarlo.

Por ejemplo, haz simplemente un código donde se compongan esos tres arrays, sin pedir datos al usuario ni nada.
Un array String[] con nombres de personas y otros dos de tipo int[] para el estrato y nivel de factura.
Inicialízalos si quieres con esos mismos datos que muestra el ejercicio.

Y ya está solo eso, no pidas datos por teclado, ni muestres los arrays en pantalla ni nada... solo componer esos tres arrays.

Con eso ya tenemos un código empezado a partir del cuál ir completando con cada una de las tareas que solicita.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Billy Joel
Val: 2.665
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayudaa

Publicado por Billy Joel (876 intervenciones) el 13/12/2020 17:42:42
Decidí hacerlo con las nuevas funciones de streams
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeMap;
import java.util.stream.Collectors;
 
public class Parcial {
 
    /**
     * Si se está desarrollando se debe setear en true, de otro modo (para el
     * usuario final) false
     */
    public static final boolean DEBUG = true;
 
    public static Usuario[] getUsuarios() {
        return new Usuario[]{new Usuario(12, 4, "Billy"),
            new Usuario(12, 1, "Vero"),
            new Usuario(11, 2, "Alvaro"),
            new Usuario(2, 3, "Kai"),
            new Usuario(15, 4, "Hansel")};
    }
 
    public static void main(String[] args) throws IOException {
        Usuario[] usuarios;
        if (DEBUG) {
            usuarios = getUsuarios();
        } else {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.print("Introduce la cantidad de usuarios: ");
            int n = Integer.parseInt(br.readLine());
            usuarios = new Usuario[n];
            System.out.println("Ahora introduce los datos de los suaurios");
            double facturado;
            int estrato;
            String nombre;
            for (int i = 0; i < usuarios.length; i++) {
                System.out.println("Usuario #" + (i + 1));
                System.out.print("Nombre: ");
                nombre = br.readLine();
                System.out.print("Facturado: ");
                facturado = Double.parseDouble(br.readLine());
                System.out.print("Estrato: ");
                estrato = Integer.parseInt(br.readLine());
                usuarios[i] = new Usuario(facturado, estrato, nombre);
            }
        }
        TreeMap<Integer, Double> facturadoEstrato = new TreeMap();
        TreeMap<Integer, Double> usuariosEstrato = new TreeMap();
        for (Usuario u : usuarios) {
            facturadoEstrato.put(u.getEstrato(), facturadoEstrato.get(u.getEstrato()) == null ? u.getFacturado() : (facturadoEstrato.get(u.getEstrato()) + u.getFacturado()));
            usuariosEstrato.put(u.getEstrato(), usuariosEstrato.get(u.getEstrato()) == null ? 1.0 : (usuariosEstrato.get(u.getEstrato()) + 1.0));
        }
 
        System.out.println("A continuación el total facturado por por estrato");
        facturadoEstrato.forEach((e, f) -> {
            System.out.println(e + ": " + f);
        });
        System.out.println("Total facturado: " + facturadoEstrato.values().stream().mapToDouble(Double::doubleValue).sum());
        System.out.println("Usuarios de estrato 2 que pagan mas 55000: " + Arrays.asList(usuarios).stream().filter(u -> u.getEstrato() == 2 && u.getFacturado() > 55000).count());
        System.out.println("Porcentaje de usuarios por estratos");
        usuariosEstrato.forEach((e, f) -> {
            System.out.println(e + ": " + f / usuarios.length * 100);
        });
 
        List<Usuario> listaOrdenados = Arrays.asList(usuarios)
                .stream()
                .sorted(Comparator.comparingDouble(Usuario::getFacturado).reversed())
                .collect(Collectors.toList());
        System.out.println("A continuación las facturas mas altas...");
        if (listaOrdenados.size() < 5) {
            listaOrdenados.forEach(System.out::println);
        } else {
            listaOrdenados.subList(0, 4).forEach(System.out::println);
        }
 
    }
}
 
class Usuario {
 
    private double facturado;
    private int estrato;
    private String nombre;
 
    public Usuario(double facturado, int estrato, String nombre) {
        this.facturado = facturado;
        this.estrato = estrato;
        this.nombre = nombre;
    }
 
    @Override
    public String toString() {
        return "Nombre: " + nombre
                + "\nFacturado: " + facturado
                + "\nEstrato: " + estrato + "\n";
    }
 
    /**
     * @return the facturado
     */
    public double getFacturado() {
        return facturado;
    }
 
    /**
     * @param facturado the facturado to set
     */
    public void setFacturado(double facturado) {
        this.facturado = facturado;
    }
 
    /**
     * @return the estrato
     */
    public int getEstrato() {
        return estrato;
    }
 
    /**
     * @param estrato the estrato to set
     */
    public void setEstrato(int estrato) {
        this.estrato = estrato;
    }
 
    /**
     * @return the nombre
     */
    public String getNombre() {
        return nombre;
    }
 
    /**
     * @param nombre the nombre to set
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
}

PD: Estoy sorprendido de la cantidad de código que nos ahorramos con los streams

Saludos,
Billy Joel
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayudaa

Publicado por Rodrigo (623 intervenciones) el 13/12/2020 18:56:02
Parte de la simplificacion tambien se obtiene de haber mantenido los datos de 1 usuario en 1 solo objeto.
El problema original obliga a usar 3 arreglos y mantener la sincronizacion de indices, al hacerlo con objetos de una clase, tal sincronizacion no es necesaria.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Billy Joel
Val: 2.665
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayudaa

Publicado por Billy Joel (876 intervenciones) el 13/12/2020 19:26:08
Yo solo estaba practicando, entiendo que el objetivo del parcial es el uso de arrays y el uso compartido de los indices.
Si lo hubiese resuelto tal cual como piden, igual me hubiesen puesto el negativo (no entiendo el porque, pero asi son).

En la vida real usamos objetos y listas de objetos y mapas. Iteramos y procesamos y si queremos mejorar el rendimiento siempre podemos implementar hilos, pero el parallel stream es muy buena alternativa. Estas nuevas funciones simplifican mucho la cantidad de código. Solo hay que practicar y arriesgarse a los negativos.

Saludos,
Billy Joel
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar