Mes: mayo 2024

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

}

package com.trifulcas.arrays;

import java.util.Arrays;

public class EjerciciosArrays {

	public static void main(String[] args) {
		int[] a = { 5, 3, 7, 9, 2,8 };
		System.out.println(menorElemento(a)); // 2
		int[] b = { 5, 3, -7, -9, 2 };
		System.out.println(menorElemento(b)); // -9
		System.out.println(menorElementoOrdenar(b)); // -9
		double[] c = { 1.2, 3.4, 6.7, 0.9, 9.8 };
		System.out.println(menorElemento(c)); // 0.9
		String[] d = { "aa", "bbbb", "dsds", "c", "dasdasdkaod" };
		System.out.println(menorElemento(d)); // c
		System.out.println(Arrays.toString(getPares(a)));
	}

	/**
	 * Función que devuelve los números pares de una lista de números enteros
	 * 
	 * @param int[] lista
	 * @return int[]
	 */
	static int[] getPares(int[] lista) {
		// Recorro la lista
		// Si hay un número par lo cuento
		int cont=0;
		for(int valor:lista) {
			if (valor%2==0) {
				cont++;
			}
		}
		// Creo un array de ese tamaño
		int[] pares=new int[cont];
		cont=0;
		// Voy añadiendo los números pares
		for(int valor:lista) {
			if (valor%2==0) {
				pares[cont]=valor;
				cont++;
			}
		}
		return pares;
	}

	/*
	 * Crear una función menorElemento a la que le pasamos un array de enteros y nos
	 * devuelve el número menor.
	 */

	static int menorElemento(int[] lista) {
		// ¿Cómo lo voy a hacer? {5,3,7,9,2}
		// el esquema universal de el 80% de los ejercicios
		// Tengo un resultado que vale algo al principio
		// Recorro el array o los elementos
		// Si se cumple determinada condición hago algo que cambia el resultado
		// Devuelvo el resultado
		// Cojo el primer elemento
		int resultado = lista[0];
		// Recorro el array
		for (int valor : lista) {
			if (valor < resultado) {
				resultado = valor;
			}
		}
		return resultado;
	}

	// sobrecarga para double
	static double menorElemento(double[] lista) {
		double resultado = lista[0];
		// Recorro el array
		for (double valor : lista) {
			if (valor < resultado) {
				resultado = valor;
			}
		}
		return resultado;
	}
	/*
	 * Crear una sobrecarga que le pasemos cadenas y nos devuelva la más corta, si
	 * hay dos iguales la primera
	 */

	static String menorElemento(String[] lista) {
		String resultado = lista[0];
		// Recorro el array
		for (String valor : lista) {
			if (valor.length() < resultado.length()) {
				resultado = valor;
			}
		}
		return resultado;
	}

	static int menorElementoOrdenar(int[] lista) {
		int[] copia = lista.clone();
		Arrays.sort(copia);
		return copia[0];
	}

}

package com.trifulcas.arrays;

import java.util.Arrays;

public class FuncionesArrays {

	public static void main(String[] args) {
		int[] numeros= {1,2,4,5,2,7,8,4};
		
		// Me imprime la dirección de memoria
		System.out.println(numeros);
		// Imprimimos el array como hacíamos en JS
		System.out.println(Arrays.toString(numeros));
		
		// Ordena el array ascendente
		Arrays.sort(numeros);
		System.out.println(Arrays.toString(numeros));
		int[]a= {1,2,3};
		int[]b= {1,2,3};
		
		// a y b no son iguales porque apuntan a direcciones de memoria diferentes
		System.out.println(a==b);
		// Pero a y b son iguales en valor, el equals lo comprueba
		System.out.println(Arrays.equals(a, b));
		
		// Estoy copiando los 6 primeros elementos de numeros en copia
		int[] copia=Arrays.copyOf(numeros, 6);
		System.out.println(Arrays.toString(copia));
		// Estoy copiando lo elementos desde la posición 2 a la 6 (no incluída)
		int[] otraCopia=Arrays.copyOfRange(numeros, 2,6);
		System.out.println(Arrays.toString(otraCopia));
		// Relleno todo el array con el valor 7
		Arrays.fill(a, 7);
		System.out.println(Arrays.toString(a));
		// Hago una búsqueda del numero 7 en el array. Me devuelve la posición
		System.out.println(Arrays.binarySearch(numeros, 7));
	}

}

package com.trifulcas.arrays;

public class EjemplosArrays {

	public static void main(String[] args) {
		int[] rango=crearRango(3);
		// foreach de java
		for(int i:rango) {
			System.out.println(i);
		}
		// Clonar (copiar) el array
		int[] copia=rango.clone();
		// Modifico la copia
		copia[0]=9;
		// No modifica el original
		for(int i:rango) {
			System.out.println(i);
		}
		for(int i:copia) {
			System.out.println(i);
		}
		
	}
	// Tengo una función que me devuelve un array
	static int[] crearRango(int tam) {
		// Cuando creo el array le digo el tamaño
		int[] res=new int[tam];
		for(int i=0;i<tam;i++) {
			res[i]=i+1;
		}
		return res;
	}
}

package com.trifulcas.arrays;

public class IntroArrays {

	public static void main(String[] args) {
		int[] tablaEnteros; // Un array de enteros sin incializar
		int[] otraTabla= new int[5]; // Un array de enteros de tamaño 5
		int[] ultimaTabla= {1,2,3,4,5}; // Un array lo creo y lo inicializo
		
		System.out.println(ultimaTabla[1]); // 2
		ultimaTabla[3]=99; // {1,2,3,99,5}
		
		for(int i=0;i<ultimaTabla.length;i++) {
			System.out.println(ultimaTabla[i]);
		}
		for(int i=0;i<otraTabla.length;i++) {
			System.out.println(otraTabla[i]);
		}
		/* da error
		for(int i=0;i<tablaEnteros.length;i++) {
			System.out.println(tablaEnteros[i]);
		}
		*/
		tablaEnteros=ultimaTabla; // Asignando un array a otro array
		// Se copia la referencia, no el array
		// Si modificamos cualquiera de los dos arrays
		// Se modifica el otro
		tablaEnteros[0]=666;
		for(int i=0;i<ultimaTabla.length;i++) {
			System.out.println(ultimaTabla[i]);
		}
		// Nos imprime el mismo valor porque están apuntando al mismo sitio
		System.out.println(tablaEnteros);
		System.out.println(ultimaTabla);
		int[] numeros= {1,2,3,4,5,6,7,8,9,10};
		for(int i=0;i<numeros.length;i++) {
			System.out.println(numeros[i]);
		}
		System.out.println(sumaTabla(numeros));
		// Al llamar a la función sumaTabla me ha modificado numeros fuera
		// de la función
		for(int i=0;i<numeros.length;i++) {
			System.out.println(numeros[i]);
		}
	}
	// UN array se pasa por referencia, no por valor. NO SE COPIA
	static int sumaTabla(int[] elementos) {
		// como modifico la tabla que paso, se modifica fuera
		for(int i=1;i<elementos.length;i++) {
			elementos[0]+=elementos[i];
		}
		return elementos[0];
	}

}