Trifulcas

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));

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);

// 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);

package com.trifulcas.arrays;

import java.util.Arrays;
import java.util.stream.IntStream;

public class EjemplosStreams {

	public static void main(String[] args) {
		int[] numeros = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		// Creo un stream a partir de un array
		IntStream miStream = Arrays.stream(numeros);
		// Puedo utilizar los métodos que tiene stream. Vemos ejemplos
		// foreach nos permite iterar sobre cada elemento
		// Utilizo una función lambda (en JS eran flechas, se parecen mucho)
		// Sintaxis del lambda:  parametro->valor que retorno o código
		miStream.forEach(x -> System.out.println(x));
		
		// Otra manera
		miStream = Arrays.stream(numeros);
		// Indico directamente cual es la función que se va a aplicar a los elementos del array
		miStream.forEach(System.out::println);
		miStream = Arrays.stream(numeros);
		// Puedo filtrar los elementos. En el filter se pide un predicado
		IntStream pares = miStream.filter(x -> x % 2 == 0);
		pares.forEach(x -> System.out.println(x));

		// Si combino filter con count lo que tengo es una manera muy sencilla
		// De averiguar cuantos elementos en un array cumplen una condición
		// Por ejemplo, cuantos pares tengo en un array
		long nPares = Arrays.stream(numeros).filter(x -> x % 2 == 0).count();
		System.out.println(nPares);

		// Tenemos map que nos aplica una transformación a los elementos del stream
		String[] words = { "Java", "Python", "C++", "JavaScript" };
		// Puedo llamar directamente ala función que quiero aplicar
		Arrays.stream(words).map(String::toUpperCase).forEach(System.out::println);
		// Puedo utilizar una función lambda
		Arrays.stream(words).map(s -> s.toUpperCase()).forEach(System.out::println);
		// Usar una lambda
		Arrays.stream(numeros).map(x -> doble(x)).forEach(System.out::println);
		// Usar la función que tengo definida en mi propia clase
		Arrays.stream(numeros).map(EjemplosStreams::doble).forEach(System.out::println);

		// reduce para hacer operaciones sobre los elementos del stream
		// El ejemplo más común es la suma. Inicializo a cero y después sumo
		int sum = Arrays.stream(numeros).reduce(0, (x, y) -> x + y);
		System.out.println(sum);
		
		// La opción de máximo y mínimo. Uso getAsInt porque el tipo que devuelve
		// es un OptionalInt
		int max = Arrays.stream(numeros).max().getAsInt();
		int min = Arrays.stream(numeros).min().getAsInt();
		System.out.println("Máximo: " + max + ", Mínimo: " + min);
	}

	static int doble(int n) {
		return n * 2;
	}

	static int parityNumber(int[] nums) {
		long even = Arrays.stream(nums).filter(x -> x % 2 == 0).count();
		long odd = nums.length - even;
		if (even == odd) {
			return 0;
		} else if (even > odd) {
			return 2;
		} else {
			return 1;
		}

	}
}

package exercise;

import java.util.Arrays;

public class Exercise {
	
	static int sumArray(int[] nums) {
		int res = 0;
		
		for (int num : nums) {
			res += num;
		}
		
		return res;
	}
	
	static double sumArray(double[] nums) {
		double res = 0;
		
		for (double num : nums) {
			res += num;
		}
		
		return res;
	}
	
	static int[] rotateNumber(int[] nums) {
		int[] res = nums.clone();		
		res[0] = nums[nums.length - 1];
		
		for (int i = 1, j = 0; j < nums.length - 1; i++, j++) {
			res[i] = nums[j];
		}
		
		return res;
	}
	
	static int parityNumber(int[] nums) {
		int odd = 0;
		int even = 0;
		
		for (int num : nums) {
			if (num % 2 == 0) {
				even++;
			} else {
				odd++;
			}
		}		
		
		if (even == odd) {
			return 0;
		} else if (even > odd) {
			return 2;
		} else {
			return 1;
		}
	}
	
    static boolean duplicate(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] == nums[j]) {
                    return true; 
                }
            }
        }
        return false; 
    }
	
    static boolean duplicate(String[] strings) {
        for (int i = 0; i < strings.length; i++) {
            for (int j = i + 1; j < strings.length; j++) {
                if (strings[i].equals(strings[j])) {
                    return true;
                }
            }
        }
        return false;
    }    
    
	public static void main(String[] args) {
		int[] nums1 = { 1, 2, 3, 4, 5, 2 };
		System.out.format("Donat una array: '%s' de números mostra la suma d'ells: " + sumArray(nums1) + "\n", Arrays.toString(nums1));
		double[] nums2 = { 1.5, 2, 3.5, 4.1, 5 };
		System.out.format("Donat una array: '%s' de números mostra la suma d'ells: " + sumArray(nums2) + "\n", Arrays.toString(nums2));
		nums1 = new int[]{ 1, 2, 3, 4 };
		System.out.format("Donat una array: '%s' de números l'últim número pasara al 1er: " + Arrays.toString(rotateNumber(nums1)) + "\n", Arrays.toString(nums1));
		System.out.format("Danat una array: '%s' de números, retorna: 1 si hi ha més impars que parells, 2 si hi ha més parells i 0 si hi ha la la mateixa quantitat: %d\n", Arrays.toString(nums1), parityNumber(nums1));
		nums1 = new int[]{ 1, 2, 3, 5 };
		System.out.format("Danat una array: '%s' de números, retorna: 1 si hi ha més impars que parells, 2 si hi ha més parells i 0 si hi ha la la mateixa quantitat: %d\n", Arrays.toString(nums1), parityNumber(nums1));
		nums1 = new int[]{ 4, 2, 8, 1 };
		System.out.format("Danat una array: '%s' de números, retorna: 1 si hi ha més impars que parells, 2 si hi ha més parells i 0 si hi ha la la mateixa quantitat: %d\n", Arrays.toString(nums1), parityNumber(nums1));
		System.out.format("Donat una array: '%s' de números retorna 'true' si hi ha duplicats i en cas contrari 'false': " + duplicate(nums1) + "\n", Arrays.toString(nums1));
		nums1 = new int[]{ 4, 2, 8, 2 };
		System.out.format("Donat una array: '%s' de números retorna 'true' si hi ha duplicats i en cas contrari 'false': " + duplicate(nums1) + "\n", Arrays.toString(nums1));
		String[] string1 = {"jaume", "pere", "anna", "jaume"};
		System.out.format("Donat una array: '%s' de cadenes retorna 'true' si hi ha duplicats i en cas contrari 'false': " + duplicate(string1) + "\n", Arrays.toString(string1));
		string1 = new String[]{"jaume", "pere", "anna", "maria"};
		System.out.format("Donat una array: '%s' de cadenes retorna 'true' si hi ha duplicats i en cas contrari 'false': " + duplicate(string1) + "\n", Arrays.toString(string1));
	}

}