Java - Calcular y mostrar el tiempo de alquiler de una maquina

 
Vista:
Imágen de perfil de Geraldine
Val: 51
Ha disminuido su posición en 5 puestos en Java (en relación al último mes)
Gráfica de Java

Calcular y mostrar el tiempo de alquiler de una maquina

Publicado por Geraldine (25 intervenciones) el 15/10/2018 23:01:46
Como están compañeros? Tengo el siguiente problema, tengo un error en la linea 50.

Resulta que al yo eliminar el ciclo for me muestra en orden el nombre de cada maquina. Sin embargo, la idea es que también me muestre las horas y el monto de cada una. Realmente no se por que con el ciclo for no me muestra las horas.

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
package Centro;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
 
public class Maquinas {
 
    private static File archivo = new File("Maquinas.txt");
 
    //1-Determinar la cantidad de registros en el archivo:
    public static int cantReg() throws IOException {
        int contador = 0;
 
        try {
            BufferedReader br = new BufferedReader(new FileReader(archivo));
            String linea = br.readLine();
 
            while (linea != null) {
                contador++;
                linea = br.readLine();
            }
            br.close();
        } catch (FileNotFoundException e) {
            System.err.println("No se encontro el archivo: " + archivo.getAbsolutePath());
        } catch (IOException e) {
            System.err.println("Error de lectura en archivo: " + archivo.getAbsolutePath());
        }
        return contador;
    }
 
    //2-Crear un vector tipo String que almacena el nombre y una matri tipo entero
    //donde se almacenara las horas y minutos, tanto de inicio como de fin:
    public static void leerMaquinas(String maq[], int alq[][]) throws FileNotFoundException {
        int fila = 0;
 
        try {
            BufferedReader br = new BufferedReader(new FileReader(archivo));
            String linea = br.readLine();
            final NumberFormat NUMBER_FORMAT = NumberFormat.getInstance(Locale.FRANCE);
 
            while (linea != null) {
               String[] datos = linea.split(",");
               maq[fila] = datos[0];
 
                for (int i = 0; i < alq[0].length; i+=2) {
                    alq[fila][i] = Integer.parseInt(linea.substring(0,2));
                    alq[fila][i+1] = Integer.parseInt(linea.substring(3));
                }
 
               fila++;
               linea = br.readLine();
            }
            br.close();
        } catch (FileNotFoundException e) {
            System.err.println("No se encontro el archivo: " + archivo.getAbsolutePath());
        } catch (IOException e) {
            System.err.println("Error de lectura en archivo: " + archivo.getAbsolutePath());
        } catch (NumberFormatException e) {
            System.err.println("Error en dimensiones en registro: #" + fila);
        }
    }
 
    //3-Creamos una matriz tipo entero con horas de inicio y fin del alquiler y un
    //vector tipo entero que almacene la duracion del alquiler:
    public static void duracionAlq(int alq[][], int dura[]) {
 
        for (int i = 0; i < alq.length; i++) {
            for (int j = 0; j < alq[0].length; j += 2) {
                dura[i] = alq[i][j] * 60 + alq[i][j + 1] - dura[i];
            }
        }
    }
 
    //4-Que reciba como parámetros un vector de tipo entero  donde se almaceno 
    //el tiempo que duro el alquiler en minutos  y un vector de tipo float donde 
    //se almacene por cada alquiler el monto a cancelar
    public static void calMonto(int dura[], double monto[]) {
        //variables:
        int mh, mm;
 
        for (int i = 0; i < dura.length; i++) {
            monto[i] = dura[i] / 60 * 3 + (dura[i] % 60) / 15 * 0.75;
            if (((dura[i] % 60) % 15) % 15 > 0) {
                monto[i] += 0.75;
            }
        }
    }
 
    //5-Mostramos por consola las maquinas, la duracion del alquiler y el monto a pagar:
    public static void mostrar(String maq[], int dura[], double monto[]) {
        //Variables:
        int h, m;
        double total = 0;
 
        System.out.println("\n\nNombre  Duracion(hh:mm)    Monto(Bs.S)");
        //Organizamos los nombres:
        for (int i = 0; i < maq.length; i++) {
            System.out.printf("%-10s", maq[i]);
            h = dura[i] / 60;
            m = dura[i] % 60;
            System.out.printf("%3d:%3d", h, m);
            System.out.printf("15.2f\n", monto[i]);
            total += monto[i];
        }
        System.out.println("Total facturado: " + total + "Bs.S");
    }
}

Principal

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
package Centro;
import java.io.IOException;
import java.util.Locale;
 
public class Principal {
 
    private static String[] maquinas;
    private static int[][] alquileres;
 
    public static void main(String[] args) throws IOException {
        Locale.setDefault(Locale.US);
        int numeroRegistros = Maquinas.cantReg();
 
        //Declaramos nuevas variables:
        maquinas = new String[numeroRegistros];
        alquileres = new int[numeroRegistros][4];
        int duracion[] = new int[numeroRegistros];
        double monto[] = new double[numeroRegistros];
 
        //Mostramos por consola:
        Maquinas.leerMaquinas(maquinas, alquileres);
        Maquinas.duracionAlq(alquileres, duracion);
        Maquinas.calMonto(duracion, monto);
        Maquinas.mostrar(maquinas, duracion, monto);
    }
}

La salida debería quedarme expresada así:
https://ibb.co/eOQHO0
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 2.347
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Calcular y mostrar el tiempo de alquiler de una maquina

Publicado por Kabuto (585 intervenciones) el 16/10/2018 00:20:00
Hola, de nuevo me pillas sin tiempo para poder mirar a fondo el ejercicio.

Pero creo que el problema viene por lo siguiente.

Esta es una de las lineas del archivo:
GAMMA, 06:15, 07:50

Cuando haces esto:
1
String[] datos = linea.split(",");

Obtienes un vector llamado datos, con estos tres elementos de tipo string:
datos[0] == "GAMMA"
datos[1] == " 06:15"
datos[2] == " 07:50"


Los elementos 1 y 2, no puedes parsealos a int de forma sencilla, ya que contienen un espacio en blanco y los dos puntos --> :

Si solo quieres mostrarlos, puedes dejarlos como String, sin parsear ni nada.

Sin embargo, el ejercicio pide interpretar esos dos valores para calcular tiempos en otros metodos.
Y esto, es más dificil de lo que parece. Aunque consiguieras parsear la cadena " 06:15" a un entero, ¿que tendrías?
El numero, seiscientosquince, es decir: 615
Este valor en realidad no es representativo de la hora 06:15
615 --> es un valor en sistema decimal
06:15 --> es un valor en sistema sexagesimal, que representa fracciones de tiempo en 60 unidades (60 segundos, 60 minutos)

Son sistemas completamente diferentes, así que para medir y calcular unidades de tiempo, vamos a necesitar algo mucho más complejo que simplemente intentar parsearlo a un int.

No se si existe en Java alguna librería que automaticamente interprete un String como ese en unidades de tiempo. Creo que ni la clase Calendar ni la clase Date (ya en desuso) hacen eso.

Así que me temo que tendrás que crear un método u otra clase que se encargue de hacerlo.
Si recibe la cadena "06:15", que separe el "06" calculándolo como horas y el "15" como minutos.
Y con ello, que lo pase a segundos, o todo a minutos... y de ese modo ya se puede comparar con otros tiempos y así calcular diferencias entre ellos.
Quizás crear una clase sea más eficiente, por ejemplo una clase llamada Tiempo, así sus objetos pueden darnos el tiempo en String para imprimir en pantalla, el tiempo calculado en minutos e incluso un metodo que al recibir otro objeto Tiempo los compare y devuelva la diferencia en minutos.

No se, quizás haya formas más fáciles de salvar este inconveniente, pero a mi ahora solo se me ocurre esto...
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar

Calcular y mostrar el tiempo de alquiler de una maquina

Publicado por Geraldine (1 intervención) el 16/10/2018 03:37:12
Diablos justo se me fue la luz, pero se me acaba de ocurrir agregar en la línea 38 el int dura[], y sustituir el for de la linea 50 por éste:

1
2
3
for (int i = 0; i < alq.length; i++) { for (int j = 0; j < alq[0].length; j += 2) {
dura[i] = alq[i][j] * 60 + alq[i][j + 1] - dura[i];
 }

De esa forma creo que deberia de calcular en orden el tiempo que duró el alquiler en cada uno de las máquinas; y ya con eso se almacenaria.

Eliminaría todo el método de la linea 68 al 77 y ya en el Método mostrar por consola debería de aparecer el tiempo que calcule al principio.

No sé que opines tú cariño.

Si alguno puede corroborarlo sería genial.

Igual iría avisando si me funcionó.
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 Kabuto
Val: 2.347
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Calcular y mostrar el tiempo de alquiler de una maquina

Publicado por Kabuto (585 intervenciones) el 16/10/2018 12:40:54
Mira, te propongo estos metodos.
No he tenido ocasión de probarlos, pero en teoría deberían funcionar

Este es para obtener los registros del archivo de texto, donde parseamos por separado las horas y los minutos , tanto del tiempo de inicio como el de fin de alquiler

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
public static void leerMaquinas(String maq[], int alq[][]) throws FileNotFoundException {
    int fila = 0;
 
    try {
        BufferedReader br = new BufferedReader(new FileReader(archivo));
        String linea = br.readLine();
 
        while (linea != null) {
            String[] datos = linea.split(",");
            //Cogemos el nombre
            maq[fila] = datos[0];
            /*
             * En datos[1] (hora inicio) y datos[2](hora fin) tenemos una cadena como esta --> " hh:mm"
             * Para convertirlos en int por separado las horas hh y los minutos mm
             * tenemos que usar el metodo subString() para descartar el espacio en blanco
             *  y el simbolo de los dos puntos
             */
            //Cogemos hora y minuto de INICIO
            alq[fila][0] = Integer.parseInt(datos[1].substring(1, 3));//cogemos las hh
            alq[fila][1] = Integer.parseInt(datos[1].substring(4));//cogemos las mm
            //Cogemos hora y minuto de FIN
            alq[fila][2] = Integer.parseInt(datos[2].substring(1, 3));
            alq[fila][3] = Integer.parseInt(datos[2].substring(4));
            //Pasamos al siguiente registro
            fila++;
            linea = br.readLine();
        }
        br.close();
    } catch (FileNotFoundException e) {
        System.err.println("No se encontro el archivo: " + archivo.getAbsolutePath());
    } catch (IOException e) {
        System.err.println("Error de lectura en archivo: " + archivo.getAbsolutePath());
    } catch (NumberFormatException e) {
        System.err.println("Error en dimensiones en registro: #" + fila);
    }
}

Y este es para calcular y almacenar las duraciones de los alquileres en minutos.
En realidad aquí son dos metodos, uno de ellos es private y es el que se encarga de calcular la diferencia en minutos que hay entre dos intervalos de tiempo.
Incluye comentarios explicando que hace:
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
public static void duracionAlq(int alq[][], int dura[]) {
 
    for (int i = 0; i < alq.length; i++)
    {
        //Obtenemos hh y mm de inicio y de fin
        int horaInicio = alq[i][0];
        int minutoInicio = alq[i][1];
        int horaFin = alq[i][2];
        int minutoFin = alq[i][3];
        //Calculamos la diferencia en minutos
        dura[i] = calculaDiferenciaMinutos(horaInicio, minutoInicio, horaFin, minutoFin);
    }
}
 
private static int calculaDiferenciaMinutos(int hIni, int mIni, int hFin, int mFin)
{
    /*
     * Una forma de calcular diferencias de tiempo es convertir los tiempos
     * en la cantidad de segundos que han transcurrido desde las 00:00
     * Por ejemplo, tenemos dos tiempos: 01:10 y 02:30
     * 01:10 equivale a 4200 segundos desde las 00:00
     * 02:30 equivale a 9000 segundos desde las 00:00
     * La diferencia 9000-4200 = 4800 segundos.
     * 4800 segundos son 80 minutos, que son los minutos de diferencia
     * entre las 01:10 y las 02:30
     */
 
    int segundosInicio = (hIni * 3600) + (mIni * 60);
    int segundosFin = (hFin * 3600) + (mFin * 60);
    //Retornamos diferencia en minutos
    return (segundosFin - segundosInicio) / 60;
}
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 Geraldine
Val: 51
Ha disminuido su posición en 5 puestos en Java (en relación al último mes)
Gráfica de Java

Calcular y mostrar el tiempo de alquiler de una maquina

Publicado por Geraldine (25 intervenciones) el 17/10/2018 02:06:34
Lo intente, pero nada. Los primeros 3 los medio calcula, al igual que el total facturado. Lo que no entiendo es el por que no calcula el monto de cada uno.

También lo había hecho en sentido de que solo me mostrara la hora de entrada y salida sin hacer otra operación, pero al igual que en este no lo muestra.

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
package PMaquinas;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.text.NumberFormat;
import java.util.Locale;
 
public class Maquinas2 {
 
    private static File archivo = new File("Maquinas.txt");
 
    //1-Determinar la cantidad de registros en el archivo:
    public static int cantReg() throws IOException {
        int contador = 0;
 
        try {
            BufferedReader br = new BufferedReader(new FileReader(archivo));
            String linea = br.readLine();
 
            while (linea != null) {
                contador++;
                linea = br.readLine();
            }
            br.close();
        } catch (FileNotFoundException e) {
            System.err.println("No se encontro el archivo: " + archivo.getAbsolutePath());
        } catch (IOException e) {
            System.err.println("Error de lectura en archivo: " + archivo.getAbsolutePath());
        }
        return contador;
    }
 
    //2-Crear un vector tipo String que almacena el nombre y una matri tipo entero
    //donde se almacenara las horas y minutos, tanto de inicio como de fin:
    public static void leerMaquinas(String maq[], int alq[][]) throws IOException {
        int fila = 0;
 
        try {
            BufferedReader br = new BufferedReader(new FileReader(archivo));
            String linea = br.readLine();
            final NumberFormat NUMBER_FORMAT = NumberFormat.getInstance(Locale.US);
 
            while (linea != null) {
                String[] datos = linea.split(",");
                maq[fila] = datos[0];
 
                //Cogemos hora y minuto de INICIO
                alq[fila][0] = Integer.parseInt(datos[1].substring(1, 3));//cogemos las hh
                alq[fila][1] = Integer.parseInt(datos[1].substring(4));//cogemos las mm
                //Cogemos hora y minuto de FIN
                alq[fila][2] = Integer.parseInt(datos[2].substring(1, 3));
                alq[fila][3] = Integer.parseInt(datos[2].substring(4));
                //Pasamos al siguiente registro
 
                fila++;
                linea = br.readLine();
            }
            br.close();
        } catch (FileNotFoundException e) {
            System.err.println("No se encontro el archivo: " + archivo.getAbsolutePath());
        } catch (IOException e) {
            System.err.println("Error de lectura en archivo: " + archivo.getAbsolutePath());
        } catch (NumberFormatException e) {
            System.err.println("Error en dimensiones en registro: #" + fila);
        }
    }
    //3-Creamos una matriz tipo entero con horas de inicio y fin del alquiler y un
    //vector tipo entero que almacene la duracion del alquiler:
    public static void duracionAlq(int alq[][], int dura[]) {
 
        for (int i = 0; i < alq.length; i++) {
            //Obtenemos hh y mm de inicio y de fin
            int horaInicio = alq[i][0];
            int minutoInicio = alq[i][1];
            int horaFin = alq[i][2];
            int minutoFin = alq[i][3];
            //Calculamos la diferencia en minutos
            dura[i] = calculaDiferenciaMinutos(horaInicio, minutoInicio, horaFin, minutoFin);
        }
    }
    private static int calculaDiferenciaMinutos(int hIni, int mIni, int hFin, int mFin) {
        int segundosInicio = (hIni * 3600) + (mIni * 60);
        int segundosFin = (hFin * 3600) + (mFin * 60);
        //Retornamos diferencia en minutos
        return (segundosFin - segundosInicio) / 60;
    }
    //4-Que reciba como parámetros un vector de tipo entero  donde se almaceno 
    //el tiempo que duro el alquiler en minutos  y un vector de tipo float donde 
    //se almacene por cada alquiler el monto a cancelar:
    public static void calMonto(int dura[], double monto[]) {
        //variables:
        int mh, mm;
 
        for (int i = 0; i < dura.length; i++) {
            monto[i] = dura[i] / 60 * 3 + (dura[i] % 60) / 15 * 0.75;
            if (((dura[i] % 60) % 15) % 15 > 0) {
                monto[i] += 0.75;
            }
        }
    }
    //5-Mostramos por consola las maquinas, la duracion del alquiler y el monto a pagar:
    public static void mostrar(String maq[], int dura[], double monto[]) {
        //Variables:
        int h, m;
        double total = 0;
 
        System.out.println("\n\nNombre  Duracion(hh:mm)    Monto(Bs.S)");
        //Organizamos los nombres:
        for (int i = 0; i < maq.length; i++) {
            System.out.printf("%-10s", maq[i]);
            h = dura[i] / 60;
            m = dura[i] % 60;
            System.out.printf("%3d:%3d", h, m);
            System.out.printf("15.2f\n", monto[i]);
            total += monto[i];
        }
        System.out.println("Total facturado: " + total + "Bs.S");
    }

Conseguí un codigo un poco mas corto para identificar las horas y los minutos, lo intente aplicar también pero no lo ejecuta:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private String tiempo(String hoe,String hos){
        int h1,h2,m1,m2,ht,mt;
        String tiempo;
        //Obteniendo las horas
        h1 = Integer.parseInt(hoe.substring(0, 2));
        h2 = Integer.parseInt(hos.substring(0,2));
        //Obteniendo los minutos
        m1 = Integer.parseInt(hoe.substring(3));
        m2 = Integer.parseInt(hos.substring(3));
 
        //Calculando el tiempo transcurrido
        ht = h2 - h1;
        mt = m2 - m1;
 
        if (m2 > m1) {
            tiempo = ht+":"+mt;
        }else{
            tiempo = (ht-1)+":"+(m1-m2);
        }
 
        td = tiempo;
        return tiempo;
    }
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

Calcular y mostrar el tiempo de alquiler de una maquina

Publicado por Tom (1571 intervenciones) el 18/10/2018 11:22:27
1
2
3
4
LocalTime t1 = LocalTime.parse("06:15");
LocalTime t2 = LocalTime.parse("08:50");
Duration interval = Duration.between(t1, t2);
System.out.printf("Seconds: %d\n", interval.getSeconds());
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