Mes: mayo 2024

Ejemplos funciones con ArrayList

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
package com.trifulcas.colecciones;
 
import java.util.ArrayList;
 
public class FuncionesArrayList {
    public static void main(String[] args) {
 
        int[] lista = { 2, 4, 7, 3, 45, 76, 90, 101 };
        ArrayList<Integer> pares = getPares(lista);
        ArrayList<Integer> otra = new ArrayList<Integer>();
        otra.add(4);
        otra.add(76);
        otra.add(40);
        System.out.println(pares);
        System.out.println(sumaArray(pares));
        System.out.println(interseccion(pares,otra));
    }
 
    // Función a la que le pasamos un array de enteros y nos devuelve los pares
    static ArrayList<Integer> getPares(int[] numeros) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        for (int i : numeros) {
            if (i % 2 == 0) {
                res.add(i);
            }
        }
        return res;
    }
 
    // Función a la que le pasamos un ArrayLIst de enteros y nos devuelve la suma
    static int sumaArray(ArrayList<Integer> numeros) {
        int suma = 0;
        for (int i : numeros) {
            suma += i;
        }
        return suma;
    }
     
    // Función que le pasamos dos arraylist y nos devuelve la intersección de los dos
    static ArrayList<Integer> interseccion(ArrayList<Integer> a, ArrayList<Integer>b){
        ArrayList<Integer> res=new ArrayList<Integer>();
        for(int i:a) {
            if (b.contains(i)) {
                res.add(i);
            }
        }
        return res;
    }
}

Ejemplos ArrayList

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
// Sintaxis ArrayList<Tipo de datos> nombre = new ArrayList<Tipo>()
        ArrayList<String> lista = new ArrayList<String>();
         
        // Lo mismo pero no especifico tipo
        ArrayList<String> lista2 = new ArrayList<>();
         
        // Lo mismo pero usando la clase abstracta
        List<String> lista3=new ArrayList<String>();
         
        // Muy importante: el tipo tiene que ser una clase
        //ArrayList<int> enteros=new ArrayList<int>();
        // Utilizar unas clases 'wrapper' (envolventes)
        // Que son lo mismo que los tipos primitivos pero en clase
        ArrayList<Integer> enteros=new ArrayList<Integer>();
        ArrayList<Boolean> boleanos=new ArrayList<Boolean>();
        ArrayList<Double> decimales=new ArrayList<Double>();
         
        // No especificamos tamaño, porque es dinámico
        // Yo añado elementos con add, los que quiera
        enteros.add(5);
        enteros.add(9);
        enteros.add(13);
        System.out.println(enteros);
        // Puedo recorrer con un for :
        for(Integer i:enteros) {
            System.out.println(i);
        }
        // Con un for normal usando el size (tamaño)
        for(int i=0;i<enteros.size();i++) {
            // con get obtenemos el elemento en esa posición
            System.out.println(enteros.get(i));
        }
        // Podemos usar el foreach
        enteros.forEach(x->System.out.println(x));
         
        ArrayList<LocalDate> fechas= new ArrayList<LocalDate>();
        fechas.add(LocalDate.now());
         
        // Añadir en un índice determinado
        enteros.add(1,666);
        System.out.println(enteros);
        // Eliminamos el elemento de la posición 2
        enteros.remove(2);
        System.out.println(enteros);
         
        // Si un elemento está dentro el arraylist
        System.out.println(enteros.contains(5)); // true
        System.out.println(enteros.contains(90)); // false
         
        // Buscar la posición de un elemento
        System.out.println(enteros.indexOf(13)); // 2
        System.out.println(enteros.indexOf(130)); // -1 porque no lo encuentra
         
        

Soluciones fechas

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
package com.trifulcas.fechas;
 
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
 
public class EjerciciosFechas {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LocalDate cumple = LocalDate.of(2024, 8, 13);
        System.out.println(cumple.format(DateTimeFormatter.ofPattern("MM/d/yyyy")));
        System.out.println(cuantoFalta(cumple));
        System.out.println(Arrays.toString(primerosDeMes(2025)));
        System.out.println(esFinDeSemanaAnglo("06/01/2024"));
        System.out.println(esFinDeSemanaEsp("04/06/2024"));
    }
 
    // Crear una función cuantoFalta(fecha) a la que le pasamos una fecha
    // y nos devuelve cuantos días faltan hasta esa fecha
    static long cuantoFalta(LocalDate fecha) {
        return ChronoUnit.DAYS.between(LocalDate.now(), fecha);
 
    }
 
    // Crear una función primerosDeMes(anyo) que nos devuelva una array con las
    // fechas
    // de los primeros de mes de ese año (1 de enero, 1 de febrero, 1 de marzo...)
 
    // Devuelvo un array de fechas, le paso un int con el año
    static LocalDate[] primerosDeMes(int anyo) {
        // La sintaxis de un array es tipo nombre_variable= new tipo[tamaño]
        LocalDate[] fechas = new LocalDate[12]; // ¿Por qué 12? Porque son 12 meses
 
        // ¿Cómo creo yo un array con los primeros de mes?
        // (0) 1-1-2024, (1) 1-2-2024, (2) 1-3-2024...
        for (int i = 1; i <= 12; i++) {
            fechas[i - 1] = LocalDate.of(anyo, i, 1);
        }
        return fechas;
    }
 
    // Crear una función a la que le pasamos una cadena con una fecha en formato
    // "año-mes-dia" y nos devuelve true si es fin de semana y false en caso
    // contrario
    // esFinDeSemana(cadena)
 
    static boolean esFinDeSemanaEsp(String cadena) {
        // Convertir la cadena a fecha
        LocalDate fechaConvertida = LocalDate.parse(cadena, DateTimeFormatter.ofPattern("dd/MM/yyyy"));
        // Saber el día de la semana
        int diaSemana = fechaConvertida.getDayOfWeek().ordinal();
        // Si es sábado o domingo devolver true y si no false
        return diaSemana >= 5;
 
    }
 
    static boolean esFinDeSemanaAnglo(String cadena) {
        // Convertir la cadena a fecha
        LocalDate fechaConvertida = LocalDate.parse(cadena, DateTimeFormatter.ofPattern("MM/dd/yyyy"));
        // Saber el día de la semana
        int diaSemana = fechaConvertida.getDayOfWeek().ordinal();
        // Si es sábado o domingo devolver true y si no false
        return diaSemana >= 5;
 
    }
 
}

Ejercicios If

1
2
3
4
5
6
7
8
9
10
11
12
# Cread una función a la que le pasamos una cantidad y nos devuelve el PVP
# siguiendo las siguientes reglas
# Si el precio es <1000 No hay descuento
# Está entre 1000 y <3000 5% de descuento
# Es 3000 o más 10% de descuento
# devuelvo el importe, no el descuento
 
# Cread una función obtenerIRPF(departamento, sueldo) que nos devuelva el % de irpf acorde a:
# Si el departamento es 'marketing' 12%
# Si el departamento es 'administracion' y el sueldo es <2500 12%, si es mayor 15%
# Si el departamento es 'contabilidad' tiene los siguientes tramos:
# hasta 3000 10% de 3000 a 5000 12% mas de 5000 15%

Ejemplo función recursiva para buscar un archivo

Probad a crear una carpeta meted un archivo dentro y mirad a ver si lo encuentra

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
import os
 
 
def buscar_archivo(ruta, nombre_archivo):
    """
    Busca un archivo con un nombre específico en una carpeta y sus subcarpetas.
 
    :param ruta: La ruta de la carpeta en la que iniciar la búsqueda.
    :param nombre_archivo: El nombre del archivo a buscar.
    :return: La ruta completa del archivo si se encuentra, de lo contrario None.
    """
    # Recorremos todos los elementos dentro de la carpeta actual
    for elemento in os.listdir(ruta):
        # Construimos la ruta completa del elemento
        ruta_completa = os.path.join(ruta, elemento)
 
        # Si el elemento es un archivo y su nombre coincide con el que buscamos
        if os.path.isfile(ruta_completa) and elemento == nombre_archivo:
            return ruta_completa
 
        # Si el elemento es una carpeta, llamamos recursivamente a la función
        elif os.path.isdir(ruta_completa):
            resultado = buscar_archivo(ruta_completa, nombre_archivo)
            if resultado:
                return resultado
 
    # Si no encontramos el archivo, devolvemos None
    return None
 
 
# Ejemplo de uso
ruta_busqueda = 'c:\\xampp'
nombre_archivo = 'index.html'
resultado = buscar_archivo(ruta_busqueda, nombre_archivo)
 
if resultado:
    print(f'Archivo encontrado en: {resultado}')
else:
    print('Archivo no encontrado')

Ejemplos modulo os

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
import os
 
# La carpeta en la que estoy
directorio_actual = os.getcwd()
print(directorio_actual)
 
# Me devuelve una lista de todos los archivos en una carpeta determinada
archivos_en_directorio = os.listdir(directorio_actual)
print(archivos_en_directorio)
# Lista que se puede recorrer
for archivo in archivos_en_directorio:
    print(archivo)
    if os.path.isfile(archivo):
        print('Es un archivo.')
    elif os.path.isdir(archivo):
        print('Es un directorio.')
    elif os.path.islink(archivo):
        print('Es un enlace simbólico.')
 
archivos_en_directorio = os.listdir("c:\\xampp")
print(archivos_en_directorio)
 
# Si un archivo existe. Muy útil si yo quiero abrir un archivo
print(os.path.exists("c:\\xampp\\pepe.txt"))  # False
print(os.path.exists("c:\\xampp\\uninstall.dat"))  # True porque en mi ordenador sí que existe
 
# Compruebo antes de crear que la carpeta no exista
if not os.path.exists("nueva_carpeta"):
    # Creo la carpeta
    os.mkdir("nueva_carpeta")
# Compruebo que no existe la ruta de carpetas que quiero crear
if not os.path.exists("carpeta\\con\\subcarpetas"):
    # Creo la carpeta con sus subcarpetas
    os.makedirs("carpeta\\con\\subcarpetas")
#Compruebo que existe el archivo
if os.path.exists("pais.txt"):
    # Si existe, lo elimino. OJO CUIDADO no se puede deshacer
    os.remove("pais.txt")
 
#os.rename("numeros01.txt","numeros1.text")
 
ruta_absoluta = os.path.abspath('prueba.txt')
print(ruta_absoluta)

Soluciones fechas

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
import datetime
 
 
# crear una función cuantoFalta(fecha) a la que le pasamos una fecha
# y nos devuelve cuantos días faltan hasta esa fecha
 
def cuantoFalta(fecha):
    # Calcular cuantos días faltan hasta la fecha que me pasan
    # que día es hoy
    hoy = datetime.datetime.now()
    # Hago la resta, en python es tan sencillo como restar
    faltan = fecha - hoy  # timedelta que es un periodo de tiempo
    # De ese periodo de tiempo me interesan los días
    return faltan.days
 
 
# La fecha de mi cumpleaños
miFecha = datetime.datetime(2024, 8, 13)
# ¿Cuanto falta hasta mi cumpleaños?
print(cuantoFalta(miFecha))  # 75
 
 
# crear una función primerosDeMes(anyo) que nos devuelva una lista con las fechas
# de los primeros de mes de ese año (1 de enero, 1 de febrero, 1 de marzo...)
 
def primerosDeMes(anyo):
    # Crear una lista de fechas
    res = []
    # creo una fecha datetime.date(año,mes,dia)
    # ¿Cuantas fechas tengo que crear? 12
    for i in range(12):
        res.append(datetime.datetime(anyo, i + 1, 1))
        # res.append("01/"+str(i+1)+"/"+str(anyo))
    return res
 
 
print(primerosDeMes(2024))  # [2024-1-1,2024-2-1,....,2024-12-1]
print(primerosDeMes(2556))  # [2024-1-1,2024-2-1,....,2024-12-1]
fechas = primerosDeMes(2024)
for fecha in fechas:
    print(fecha.strftime("%d/%m/%Y"), cuantoFalta(fecha))
 
 
# crear una función a la que le pasamos una cadena con una fecha en formato dia/mes/año
# y nos devuelve true si es fin de semana y false en caso contrario
# esFinDeSemana(cadena)
 
def esFinDeSemana(cadena):
    res = False
    # Pasar de cadena a fecha
    fecha = datetime.datetime.strptime(cadena, "%d/%m/%Y")
    if fecha.weekday() >= 5:
        res = True
    return res
 
 
print(esFinDeSemana(("01/06/2024")))  # true
print(esFinDeSemana(("04/06/2024")))  # false
 
 
# crear una función a la que le pasamos un año, un mes y un día y nos devuelve una lista
# con todas las horas exactas de ese día
# crearAgendaDia(2024,5,1)->[2024-5-1 00:00,2024-5-1 01:00,2024-5-1 02:00,2024-5-1 03:00,...2024-5-1 23:00]
 
def crearAgendaDia(anyo, mes, dia):
    res = []
    # crear una lista con unas horas que van de donde a donde? de 0 a 23
    for i in range(24):
        res.append(datetime.datetime(anyo, mes, dia, i))
    return res
 
 
print(crearAgendaDia(2024, 5, 1))  # [2024-5-1 00:00,2024-5-1 01:00,2024-5-1 02:00,2024-5-1 03:00,...2024-5-1 23:00]

Ejemplos Fechas y Horas, Period y Duration

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
LocalDateTime now=LocalDateTime.now();
         
        System.out.println(now);
         
        System.out.println(now.format(DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm")));
         
        now=now.plusDays(2);
        now=now.plusHours(3);
        System.out.println(now.format(DateTimeFormatter.ofPattern("dd/M/yyyy HH:mm")));
             
        now=now.plus(2,ChronoUnit.MILLENNIA);
        System.out.println(now.format(DateTimeFormatter.ofPattern("dd/M/yyyy HH:mm")));
         
        // Periodos: espacio temporal entre fechas
         
        LocalDateTime ahora=LocalDateTime.now();
        // between nos devuelve el periodo entre dos fechas
        System.out.println(Period.between(now.toLocalDate(), ahora.toLocalDate()));
        // Podemos obtener los días, los meses, los años...
        System.out.println(Period.between(now.toLocalDate(), ahora.toLocalDate()).getDays());
        System.out.println(Period.between(now.toLocalDate(), ahora.toLocalDate()).getYears());
        // También sirve para añadir a fechas
        ahora=ahora.plus(Period.ofMonths(3));
         
        // Duration: espacio temporal entre horas
         
        // Nos devuelve la duración entre dos horas
        System.out.println(Duration.between(now.toLocalTime(), ahora.toLocalTime()));
        // Obtenemos los segundos
        System.out.println(Duration.between(now.toLocalTime(), ahora.toLocalTime()).getSeconds());
        // También sirve para añadir a horas
        ahora=ahora.plus(Duration.ofMinutes(40));

Ejemplos 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
LocalTime now = LocalTime.now();
 
        LocalTime miHora = LocalTime.of(10, 30);
 
        LocalTime otraHora = LocalTime.parse("10:34");
        System.out.println(now);
        System.out.println(miHora);
        System.out.println(otraHora);
 
        // Obtener información de las horas
 
        System.out.println(now.getHour());
        System.out.println(now.getMinute());
        System.out.println(now.getSecond());
        System.out.println(now.getNano());
 
        // Formatear horas
 
        System.out.println(now.format(DateTimeFormatter.ofPattern("HH:mm:ss")));
 
        // Modificar horas
 
        now = now.plusHours(1);
        now = now.plusMinutes(2);
        now = now.plusSeconds(40);
        now = now.plus(1, ChronoUnit.MINUTES);
        System.out.println(now);

Ejemplos fechas

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
// Son para crear fechas
        // La fecha de hoy
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate); // 2024-05-29
        // Creo una fecha poniendo a mano los valores
        LocalDate miFecha=LocalDate.of(2024, 6, 1);
        System.out.println(miFecha);
        // Creo una fecha intentando convertir una cadena
        LocalDate otraFecha=LocalDate.parse("2024-06-17");
        System.out.println(otraFecha);
        // Puedo obtener información de mi fecha
        // El mes en nombre o en número
        System.out.println(miFecha.getMonth());
        System.out.println(miFecha.getMonthValue());
        // El año
        System.out.println(miFecha.getYear());
        // El día del mes
        System.out.println(miFecha.getDayOfMonth());
        // El día del año
        System.out.println(miFecha.getDayOfYear());
        // El día de la semana
        System.out.println(miFecha.getDayOfWeek());
        // El número del día de la semana (0 lunes 6 domingo)
        System.out.println(miFecha.getDayOfWeek().ordinal());
        // Si es año bisiesto
        System.out.println(miFecha.isLeapYear());
        // Días del mes
        System.out.println(miFecha.lengthOfMonth());
        // Días del año
        System.out.println(miFecha.lengthOfYear());
 
 
        // Formatear fechas
        // Con el patrón que nosotros queramos
        System.out.println(miFecha.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")));
        // Formato del sistema operativo
        // Largo, nombre del día y del mes
        System.out.println(miFecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)));
        // Corto, solo números
        System.out.println(miFecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)));
         
        // Operar con fechas
        // Sumar un día
        LocalDate manyana=LocalDate.now().plusDays(1);
        System.out.println(manyana);
        // SUmar meses
        manyana=manyana.plusMonths(1);
        // SUmar Años
        manyana=manyana.plusYears(1);
        // el 30 de junio del año que viene
        System.out.println(manyana);
         
        // Sumar una duración cualquiera
        manyana=manyana.plus(1,ChronoUnit.WEEKS);
        System.out.println(manyana);
        manyana=manyana.plusYears(-1);
        System.out.println(manyana);
        manyana=manyana.minusYears(1);
        System.out.println(manyana);