feat(examen 19/6/25): solucionado

.classpath

@@ -6,5 +6,20 @@
 		</attributes>
 	</classpathentry>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="librerias/Driver_MySQL_Connector_J/mysql-connector-java-8.0.19.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/jpa/javax.persistence_2.1.0.v201304241213.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/jpa/org.eclipse.persistence.jpa.modelgen_2.5.2.v20140319-9ad6abd.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/jpa/org.eclipse.persistence.jpars_2.5.2.v20140319-9ad6abd.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/com.sun.tools.xjc_2.2.0.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/com.sun.xml.bind_2.2.0.v201004141950.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/javax.activation_1.1.0.v201108011116.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/javax.mail_1.4.0.v201005080615.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/javax.xml.bind_2.2.0.v201105210648.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/javax.xml.stream_1.0.1.v201004272200.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/eclipselink.jar"/>
+	<classpathentry kind="lib" path="librerias/Jackson/jackson-annotations-2.9.0.jar"/>
+	<classpathentry kind="lib" path="librerias/Jackson/jackson-core-2.9.5.jar"/>
+	<classpathentry kind="lib" path="librerias/Jackson/jackson-databind-2.9.5.jar"/>
+	<classpathentry kind="lib" path="librerias/mongoDB-Java-driver/mongo-java-driver-3.12.12.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

BBDDs/02_BBDD_EvaluacionCentroEducativo/evaluacionCentroEducativo.sql

@@ -0,0 +1,174 @@
+CREATE DATABASE  IF NOT EXISTS `centroeducativo` /*!40100 DEFAULT CHARACTER SET utf8 */;
+USE `centroeducativo`;
+-- MySQL dump 10.13  Distrib 5.6.13, for Win32 (x86)
+--
+-- Host: 127.0.0.1    Database: centroeducativo
+-- ------------------------------------------------------
+-- Server version	5.6.16-log
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+/*!40101 SET NAMES utf8 */;
+/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
+/*!40103 SET TIME_ZONE='+00:00' */;
+/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
+/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
+/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
+/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
+
+--
+-- Table structure for table `curso`
+--
+
+DROP TABLE IF EXISTS `curso`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `curso` (
+  `id` int(11) NOT NULL,
+  `descripcion` varchar(45) DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `curso`
+--
+
+LOCK TABLES `curso` WRITE;
+/*!40000 ALTER TABLE `curso` DISABLE KEYS */;
+INSERT INTO `curso` VALUES (1,'2017-18');
+/*!40000 ALTER TABLE `curso` ENABLE KEYS */;
+UNLOCK TABLES;
+
+--
+-- Table structure for table `estudiante`
+--
+
+DROP TABLE IF EXISTS `estudiante`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `estudiante` (
+  `id` int(11) NOT NULL,
+  `nombre` varchar(150) DEFAULT NULL,
+  `apellido1` varchar(150) DEFAULT NULL,
+  `apellido2` varchar(150) DEFAULT NULL,
+  `dni` varchar(15) DEFAULT NULL,
+  `direccion` varchar(250) DEFAULT NULL,
+  `email` varchar(150) DEFAULT NULL,
+  `telefono` varchar(150) DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `estudiante`
+--
+
+LOCK TABLES `estudiante` WRITE;
+/*!40000 ALTER TABLE `estudiante` DISABLE KEYS */;
+INSERT INTO `estudiante` VALUES (1,'Julio','Mármol','Mármol','14785236A','dir, 21','adsf','654785214'),(2,'Francisco','Fernández','Fernández','52874369B','dir, 24','f@f.com','741258963'),(3,'Miguel','Palacios','Fernández','58963214C','dir, 26','m@m.com','632521478');
+/*!40000 ALTER TABLE `estudiante` ENABLE KEYS */;
+UNLOCK TABLES;
+
+--
+-- Table structure for table `materia`
+--
+
+DROP TABLE IF EXISTS `materia`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `materia` (
+  `id` int(11) NOT NULL,
+  `nombre` varchar(100) DEFAULT NULL,
+  `acronimo` varchar(15) DEFAULT NULL,
+  `curso_id` int(11) NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `fk_asignatura_curso1_idx` (`curso_id`),
+  CONSTRAINT `fk_asignatura_curso1` FOREIGN KEY (`curso_id`) REFERENCES `curso` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `materia`
+--
+
+LOCK TABLES `materia` WRITE;
+/*!40000 ALTER TABLE `materia` DISABLE KEYS */;
+INSERT INTO `materia` VALUES (1,'Programación','PROG',1),(2,'Lenguajes de Marcas y Sistemas de Gestión de la Información','LMSGI',1),(3,'Sistemas Informáticos','SI',1),(4,'Entornos de Desarrollo','EntDes',1),(5,'Bases de Datos','BD',1),(6,'Formación y Orientación Laboral','FOL',1);
+/*!40000 ALTER TABLE `materia` ENABLE KEYS */;
+UNLOCK TABLES;
+
+--
+-- Table structure for table `profesor`
+--
+
+DROP TABLE IF EXISTS `profesor`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `profesor` (
+  `id` int(11) NOT NULL,
+  `nombre` varchar(150) DEFAULT NULL,
+  `apellido1` varchar(150) DEFAULT NULL,
+  `apellido2` varchar(150) DEFAULT NULL,
+  `dni` varchar(15) DEFAULT NULL,
+  `direccion` varchar(250) DEFAULT NULL,
+  `email` varchar(150) DEFAULT NULL,
+  `telefono` varchar(150) DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `profesor`
+--
+
+LOCK TABLES `profesor` WRITE;
+/*!40000 ALTER TABLE `profesor` DISABLE KEYS */;
+INSERT INTO `profesor` VALUES (1,'Rafael Carlos','López','Ruiz','12345678b','Su casa, 34','asdf','sdaf'),(2,'Joaquín','Molinero','Suárez','23456789B','Su casa también, 42','joaquin@joaquin.com','654789322'),(3,'Miguel Ángel','Pérez','Carmona','98765432C','Otra casa, 12','miguel@miguel.com','654147852'),(4,'Alejandro','Fernández','Fernández','47125896D','Allí, 65','alejandro@alejandro.com','658974125'),(5,'Águeda','Cuenca','Cuenca','96325874','Graná, 25','','698521478');
+/*!40000 ALTER TABLE `profesor` ENABLE KEYS */;
+UNLOCK TABLES;
+
+--
+-- Table structure for table `valoracionmateria`
+--
+
+DROP TABLE IF EXISTS `valoracionmateria`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `valoracionmateria` (
+  `id` int(11) NOT NULL,
+  `idProfesor` int(11) NOT NULL,
+  `idEstudiante` int(11) NOT NULL,
+  `idMateria` int(11) NOT NULL,
+  `valoracion` float DEFAULT NULL,
+  PRIMARY KEY (`id`),
+  KEY `fk_asignatura_profesor_idx` (`idProfesor`),
+  KEY `fk_asignatura_estudiante1_idx` (`idEstudiante`),
+  KEY `fk_asignatura_asignatura1_idx` (`idMateria`),
+  CONSTRAINT `fk_asignatura_asignatura1` FOREIGN KEY (`idMateria`) REFERENCES `materia` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
+  CONSTRAINT `fk_asignatura_estudiante1` FOREIGN KEY (`idEstudiante`) REFERENCES `estudiante` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
+  CONSTRAINT `fk_asignatura_profesor` FOREIGN KEY (`idProfesor`) REFERENCES `profesor` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `valoracionmateria`
+--
+
+LOCK TABLES `valoracionmateria` WRITE;
+/*!40000 ALTER TABLE `valoracionmateria` DISABLE KEYS */;
+INSERT INTO `valoracionmateria` VALUES (1,1,1,1,6),(2,1,1,2,7),(3,2,1,3,6),(4,3,1,4,6),(5,4,1,5,8),(6,5,1,6,4),(7,1,2,1,5),(8,1,2,2,7),(9,2,2,3,8),(10,3,2,4,5),(11,4,2,5,6),(12,5,2,6,4);
+/*!40000 ALTER TABLE `valoracionmateria` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+
+/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
+/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
+/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
+/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
+
+-- Dump completed on 2019-04-09 10:05:53

BBDDs/05_JSON_CCAA_Provincias_Poblaciones/ccaa.json

@@ -0,0 +1,97 @@
+[
+  {
+    "parent_code": "0",
+    "label": "Andalucía",
+    "code": "01"
+  },
+  {
+    "parent_code": "0",
+    "label": "Aragón",
+    "code": "02"
+  },
+  {
+    "parent_code": "0",
+    "label": "Asturias, Principado de",
+    "code": "03"
+  },
+  {
+    "parent_code": "0",
+    "label": "Balears, Illes",
+    "code": "04"
+  },
+  {
+    "parent_code": "0",
+    "label": "Canarias",
+    "code": "05"
+  },
+  {
+    "parent_code": "0",
+    "label": "Cantabria",
+    "code": "06"
+  },
+  {
+    "parent_code": "0",
+    "label": "Castilla y León",
+    "code": "07"
+  },
+  {
+    "parent_code": "0",
+    "label": "Castilla - La Mancha",
+    "code": "08"
+  },
+  {
+    "parent_code": "0",
+    "label": "Cataluńa",
+    "code": "09"
+  },
+  {
+    "parent_code": "0",
+    "label": "Comunitat Valenciana",
+    "code": "10"
+  },
+  {
+    "parent_code": "0",
+    "label": "Extremadura",
+    "code": "11"
+  },
+  {
+    "parent_code": "0",
+    "label": "Galicia",
+    "code": "12"
+  },
+  {
+    "parent_code": "0",
+    "label": "Madrid, Comunidad de",
+    "code": "13"
+  },
+  {
+    "parent_code": "0",
+    "label": "Murcia, Región de",
+    "code": "14"
+  },
+  {
+    "parent_code": "0",
+    "label": "Navarra, Comunidad Foral de",
+    "code": "15"
+  },
+  {
+    "parent_code": "0",
+    "label": "País Vasco",
+    "code": "16"
+  },
+  {
+    "parent_code": "0",
+    "label": "Rioja, La",
+    "code": "17"
+  },
+  {
+    "parent_code": "0",
+    "label": "Ceuta",
+    "code": "18"
+  },
+  {
+    "parent_code": "0",
+    "label": "Melilla",
+    "code": "19"
+  }
+]

BBDDs/05_JSON_CCAA_Provincias_Poblaciones/provincias.json

@@ -0,0 +1,262 @@
+[
+  {
+    "parent_code": "01",
+    "code": "04",
+    "label": "Almería"
+  },
+  {
+    "parent_code": "01",
+    "code": "11",
+    "label": "Cádiz"
+  },
+  {
+    "parent_code": "01",
+    "code": "14",
+    "label": "Córdoba"
+  },
+  {
+    "parent_code": "01",
+    "code": "18",
+    "label": "Granada"
+  },
+  {
+    "parent_code": "01",
+    "code": "21",
+    "label": "Huelva"
+  },
+  {
+    "parent_code": "01",
+    "code": "23",
+    "label": "Jaén"
+  },
+  {
+    "parent_code": "01",
+    "code": "29",
+    "label": "Málaga"
+  },
+  {
+    "parent_code": "01",
+    "code": "41",
+    "label": "Sevilla"
+  },
+  {
+    "parent_code": "02",
+    "code": "22",
+    "label": "Huesca"
+  },
+  {
+    "parent_code": "02",
+    "code": "44",
+    "label": "Teruel"
+  },
+  {
+    "parent_code": "02",
+    "code": "50",
+    "label": "Zaragoza"
+  },
+  {
+    "parent_code": "03",
+    "code": "33",
+    "label": "Asturias"
+  },
+  {
+    "parent_code": "04",
+    "code": "07",
+    "label": "Balears, Illes"
+  },
+  {
+    "parent_code": "05",
+    "code": "35",
+    "label": "Palmas, Las"
+  },
+  {
+    "parent_code": "05",
+    "code": "38",
+    "label": "Santa Cruz de Tenerife"
+  },
+  {
+    "parent_code": "06",
+    "code": "39",
+    "label": "Cantabria"
+  },
+  {
+    "parent_code": "07",
+    "code": "05",
+    "label": "Ávila"
+  },
+  {
+    "parent_code": "07",
+    "code": "09",
+    "label": "Burgos"
+  },
+  {
+    "parent_code": "07",
+    "code": "24",
+    "label": "León"
+  },
+  {
+    "parent_code": "07",
+    "code": "34",
+    "label": "Palencia"
+  },
+  {
+    "parent_code": "07",
+    "code": "37",
+    "label": "Salamanca"
+  },
+  {
+    "parent_code": "07",
+    "code": "40",
+    "label": "Segovia"
+  },
+  {
+    "parent_code": "07",
+    "code": "42",
+    "label": "Soria"
+  },
+  {
+    "parent_code": "07",
+    "code": "47",
+    "label": "Valladolid"
+  },
+  {
+    "parent_code": "07",
+    "code": "49",
+    "label": "Zamora"
+  },
+  {
+    "parent_code": "08",
+    "code": "02",
+    "label": "Albacete"
+  },
+  {
+    "parent_code": "08",
+    "code": "13",
+    "label": "Ciudad Real"
+  },
+  {
+    "parent_code": "08",
+    "code": "16",
+    "label": "Cuenca"
+  },
+  {
+    "parent_code": "08",
+    "code": "19",
+    "label": "Guadalajara"
+  },
+  {
+    "parent_code": "08",
+    "code": "45",
+    "label": "Toledo"
+  },
+  {
+    "parent_code": "09",
+    "code": "08",
+    "label": "Barcelona"
+  },
+  {
+    "parent_code": "09",
+    "code": "17",
+    "label": "Girona"
+  },
+  {
+    "parent_code": "09",
+    "code": "25",
+    "label": "Lleida"
+  },
+  {
+    "parent_code": "09",
+    "code": "43",
+    "label": "Tarragona"
+  },
+  {
+    "parent_code": "10",
+    "code": "03",
+    "label": "Alicante/Alacant"
+  },
+  {
+    "parent_code": "10",
+    "code": "12",
+    "label": "Castellón/Castelló"
+  },
+  {
+    "parent_code": "10",
+    "code": "46",
+    "label": "Valencia/València"
+  },
+  {
+    "parent_code": "11",
+    "code": "06",
+    "label": "Badajoz"
+  },
+  {
+    "parent_code": "11",
+    "code": "10",
+    "label": "Cáceres"
+  },
+  {
+    "parent_code": "12",
+    "code": "15",
+    "label": "Coruña, A"
+  },
+  {
+    "parent_code": "12",
+    "code": "27",
+    "label": "Lugo"
+  },
+  {
+    "parent_code": "12",
+    "code": "32",
+    "label": "Ourense"
+  },
+  {
+    "parent_code": "12",
+    "code": "36",
+    "label": "Pontevedra"
+  },
+  {
+    "parent_code": "13",
+    "code": "28",
+    "label": "Madrid"
+  },
+  {
+    "parent_code": "14",
+    "code": "30",
+    "label": "Murcia"
+  },
+  {
+    "parent_code": "15",
+    "code": "31",
+    "label": "Navarra"
+  },
+  {
+    "parent_code": "16",
+    "code": "01",
+    "label": "Araba/Álava"
+  },
+  {
+    "parent_code": "16",
+    "code": "48",
+    "label": "Bizkaia"
+  },
+  {
+    "parent_code": "16",
+    "code": "20",
+    "label": "Gipuzkoa"
+  },
+  {
+    "parent_code": "17",
+    "code": "26",
+    "label": "Rioja, La"
+  },
+  {
+    "parent_code": "18",
+    "code": "51",
+    "label": "Ceuta"
+  },
+  {
+    "parent_code": "19",
+    "code": "52",
+    "label": "Melilla"
+  }
+]

src/tutorialJava/Utils.java

@@ -53,6 +53,30 @@ public class Utils {
 		return n;
 	}
 	
+	/**
+	 * Pide un número entero al usuario
+	 * @param mensaje String que va a mostrarse en consola para pedir el número
+	 * @return Número entero introducido por el usuario
+	 */
+	public static float pideNumeroFloat (String mensaje) {
+		float n = 0;
+		boolean esNumeroCorrecto;
+		Scanner sc = new Scanner(System.in);
+		
+		do {
+			esNumeroCorrecto = false;
+			try {
+				System.out.println(mensaje);
+				n = Float.parseFloat(sc.nextLine());
+				esNumeroCorrecto = true;
+			}
+			catch (Exception e) {
+				System.out.println("No ha introducido un número");
+			}
+		} while (esNumeroCorrecto == false);
+		
+		return n;
+	}
 	
 	
 	/**
@@ -90,6 +114,41 @@ public class Utils {
 		
 	}
 	
+	/**
+	 * Obtiene un número entero a través de un objeto Scanner
+	 * @return Número entero introducido por el usuario.
+	 */
+	public static double obtenerDoublePorScanner() {
+		Scanner sc = new Scanner(System.in);
+		
+		while (true) {
+			try {
+				return sc.nextDouble();
+			} catch (Exception ex) {
+				System.out.println("Error, introduce un número double: ");
+				sc.nextLine();
+			}
+		}
+		
+	}
+	
+	/**
+	 * Obtiene un número entero a través de un objeto Scanner
+	 * @return Número entero introducido por el usuario.
+	 */
+	public static double obtenerDoublePorScanner(String mensaje) {
+		System.out.println(mensaje);
+		return obtenerDoublePorScanner();
+	}
+	
+	/**
+	 * Obtiene un número entero a través de un objeto Scanner
+	 * @return Número entero introducido por el usuario.
+	 */
+	public static float obtenerFloatPorScanner(String mensaje) {
+		return (float) obtenerDoublePorScanner(mensaje);
+	}
+	
 	/**
 	 * Obtiene un número entero a través de un JOptionPane
 	 * @return Número entero introducido a través de un JOptionPane.
@@ -119,6 +178,11 @@ public class Utils {
 		return num;
 	}
 	
+	public static double obtenerDoubleConDescripcion(String desc) {
+		System.out.println(desc);
+		return obtenerDoublePorScanner();
+	}
+	
 	/**
 	 * 
 	 * @return Número entero introducido por el usuario

src/tutorialJava/UtilsArrays.java

@@ -0,0 +1,198 @@
+package tutorialJava;
+
+public class UtilsArrays {
+
+	
+	/**
+	 * Imprime el array en consola, de forma que queda en una única línea y con
+	 * un espacio en blanco entre valores
+	 * @param num
+	 */
+	public static void imprimeArray (int a[]) {
+		for (int i = 0; i < a.length; i++) {
+			System.out.print(a[i] + " ");
+		}
+		System.out.println();
+	}
+
+	/**
+	 * Imprime el array en consola, de forma que queda en una única línea y con
+	 * un espacio en blanco entre valores
+	 * @param num
+	 */
+	public static void imprimeArray (char a[]) {
+		for (int i = 0; i < a.length; i++) {
+			System.out.print(a[i] + " ");
+		}
+		System.out.println();
+	}
+
+	/**
+	 * 
+	 * @param a
+	 * @param limInf
+	 * @param limSup
+	 */
+	public static void inicializaArray (int a[], int limInf, int limSup) {
+		for (int i = 0; i < a.length; i++) {
+			a[i] = Utils.obtenerNumeroAzar(limInf, limSup);
+		}
+	}
+	
+	
+	/**
+	 * 
+	 * @param array
+	 * @return
+	 */
+	public static int suma (int array[]) {
+		int suma = 0;
+		for (int i = 0; i < array.length; i++) {
+			suma += array[i];
+		}
+		return suma;
+	}
+	
+	
+	/**
+	 * 
+	 * @param array
+	 * @return
+	 */
+	public static float promedia (int array[]) {
+		return suma(array) / (float) array.length;
+	}
+	
+	
+	/**
+	 * 
+	 * @param array
+	 * @return
+	 */
+	public static int mayor (int array[]) {
+		int mayor = array[0];
+		for (int i = 1; i < array.length; i++) {
+			if (array[i] > mayor) mayor = array[i];
+		}
+		return mayor;
+	}
+	
+	/**
+	 * 
+	 * @param array
+	 * @return
+	 */
+	public static int menor (int array[]) {
+		int menor = array[0];
+		for (int i = 1; i < array.length; i++) {
+			if (array[i] < menor) menor = array[i];
+		}
+		return menor;
+	}
+
+	
+	
+	/**
+	 * 
+	 * @param filas
+	 * @param cols
+	 * @param valorInicial
+	 * @return
+	 */
+	public static int[][] creaEInicializaMatriz (int filas, int cols, int valorInicial) {
+		int m[][] = new int[filas][cols];
+		
+		for (int i = 0; i < m.length; i++) {
+			for (int j = 0; j < m[i].length; j++) {
+				m[i][j] = valorInicial;
+			}
+		}
+		
+		return m;
+	}
+	
+	
+	/**
+	 * 
+	 * @param filas
+	 * @param cols
+	 * @param minimo
+	 * @param maximo
+	 * @return
+	 */
+	public static int[][] creaEInicializaMatrizAlAzar (
+			int filas, int cols, int minimo, int maximo) {
+		
+		int m[][] = new int[filas][cols];
+		
+		for (int i = 0; i < m.length; i++) {
+			for (int j = 0; j < m[i].length; j++) {
+				m[i][j] = Utils.obtenerNumeroAzar(minimo, maximo);
+			}
+		}
+		
+		return m;
+	}
+	
+	
+	/**
+	 * 
+	 * @param m
+	 */
+	public static void imprimeMatriz (int m[][]) {
+		for (int i = 0; i < m.length; i++) {
+			for (int j = 0; j < m[i].length; j++) {
+				System.out.print(m[i][j] + "\t");
+			}
+			System.out.println();
+		}
+	}
+
+	
+	 /* 
+	 * @param m
+	 */
+	public static void imprimeMatriz (char m[][]) {
+		for (int i = 0; i < m.length; i++) {
+			for (int j = 0; j < m[i].length; j++) {
+				System.out.print(m[i][j] + " ");
+			}
+			System.out.println();
+		}
+	}
+
+	
+	public static void ordenaArray (int a[], boolean asc) {
+		boolean hayIntercambios;
+		do {
+			hayIntercambios = false;
+			for (int i = 0; i < (a.length - 1); i++) {
+				if ((asc == true && a[i] > a[i + 1]) 
+						|| (asc == false && a[i] < a[i + 1])) {
+					int aux = a[i];
+					a[i] = a[i + 1];
+					a[i + 1] = aux;
+					hayIntercambios = true;
+				}
+			}
+		} while (hayIntercambios == true);
+
+	}
+
+	public static void ordenaArray(int[] a) {
+		ordenaArray(a, true);		
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo1_io_tipos_y_operaciones/Ejemplo01_HolaMundo.java

@@ -3,7 +3,7 @@ package tutorialJava.capitulo1_io_tipos_y_operaciones;
 public class Ejemplo01_HolaMundo {
 
 	public static void main(String[] args) {
-		System.out.println("Hola 1º DAW");
+		System.out.println("Hola Mundo");
 	}      
   
 }

src/tutorialJava/capitulo1_io_tipos_y_operaciones/Ejemplo02_TiposPrimitivos.java

@@ -7,18 +7,21 @@ public class Ejemplo02_TiposPrimitivos {
 	 */
 	public static void main (String args[]) {
 		int numEntero;  // Declaración de una variable entera
-		float numFlotante; // Declaración de una variable real o flotante
-		double numDouble; // Declaración de una variable flotante larga
+		float numFlotante; // Declaración de una variable flotante
+		double numDoble; // Declaración de una variable double
 		
-		numEntero = 4 + 6; // Asignación de un valor a una variable
-		numFlotante = (float) 4; // Casting de valor double a float
-		numDouble = 4.8; // Asignación de valor double a variable double
-	
-		// Impresión en la consola de salida de las variabless
-		System.out.print("El número entero es " + numEntero + 
-				"\ny el número flotante es " + numFlotante + 
-				"\ny el número double es: " + numDouble);          
+		short numEnteroA16bits;
+		byte numEnteroA8bits;
+		long numEnteroA64bits;
 		
+		numFlotante = 2.3f; // Casting
+		numFlotante = (float) 2.3;
+		numDoble = 2.3;
+		numEntero = (int) 2.3;
+		
+		System.out.println("El valor final entero es " + numEntero);
+		System.out.println("El valor final entero ahora cambia a " + ( numEntero + numEntero) );
+		System.out.println("El valor final entero ahora cambia a " + numEntero + numEntero );
 	}
 	    
 	

src/tutorialJava/capitulo1_io_tipos_y_operaciones/Ejemplo03_IntroduccionString.java

@@ -11,7 +11,7 @@ public class Ejemplo03_IntroduccionString {
 		
 		System.out.println("Valor de cadenaCarac: " + cadenaCarac);  // Imprime una cadena de caracteres
 		System.out.println("Longitud de cadenaCarac: " + cadenaCarac.length()); // Imprime l alongitud de una cadena
-		System.out.println("Localización por caracteres: " + cadenaCarac.indexOf("Lenguaje")); // Índice en el que encontramos una cadena
+		System.out.println("Localización por caracteres: " + cadenaCarac.indexOf("Rafa")); // Índice en el que encontramos una cadena
 		System.out.println("Localización por índices: " + cadenaCarac.charAt(12)); // Carácter encontrado en el índice 12, empezando por 0 
 		System.out.println("Uso de subcadenas: " + cadenaCarac.substring(12, 20)); // Obtener una subcadena dentro de una cadena
 		System.out.println("Uso de toLower: " + cadenaCarac.toLowerCase()); // Convertir una cadena de caracteres en minúscula

src/tutorialJava/capitulo1_io_tipos_y_operaciones/ejercicios/bloque01/Ej01_PidoTresNumerosMuestroEnUnaSolaFila.java

@@ -0,0 +1,28 @@
+package tutorialJava.capitulo1_io_tipos_y_operaciones.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej01_PidoTresNumerosMuestroEnUnaSolaFila {
+
+	public static void main(String[] args) {
+		int numEntero = 0;
+		float numFloat;
+		double numDouble;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Introduzca un número entero: ");
+		numEntero = sc.nextInt();
+
+		System.out.println("Introduzca un número float: ");
+		numFloat = sc.nextFloat();
+
+		System.out.println("Introduzca un número double: ");
+		numDouble = sc.nextDouble();
+
+		System.out.println("El entero es: " + numEntero + " y el float es " 
+				+ numFloat + " y el double es " + numDouble);
+		
+		sc.close();
+	}
+
+}

src/tutorialJava/capitulo1_io_tipos_y_operaciones/ejercicios/bloque01/Ej02_PidoTresNumerosMuestroEnEnDiferentesFilas.java

@@ -0,0 +1,27 @@
+package tutorialJava.capitulo1_io_tipos_y_operaciones.ejercicios.bloque01;
+
+import javax.swing.JOptionPane;
+
+public class Ej02_PidoTresNumerosMuestroEnEnDiferentesFilas {
+
+	public static void main(String[] args) {
+		int numEntero = 0;
+		float numFloat;
+		double numDouble;
+		String str;
+		
+		str = JOptionPane.showInputDialog("Introduzca un número entero: ");
+		numEntero = Integer.parseInt(str);
+		System.out.println("El número entero introducido es: " + numEntero);
+
+		str = JOptionPane.showInputDialog("Introduzca un número float: ");
+		numFloat = Float.parseFloat(str);
+		System.out.println("El número float introducido es: " + numFloat);
+
+		str = JOptionPane.showInputDialog("Introduzca un número double: ");
+		numDouble = Double.parseDouble(str);
+		System.out.println("El número double introducido es: " + numDouble);
+
+	}
+
+}

src/tutorialJava/capitulo1_io_tipos_y_operaciones/ejercicios/bloque01/Ej03_PidoTresNumerosCalculoSuSuma.java

@@ -0,0 +1,31 @@
+package tutorialJava.capitulo1_io_tipos_y_operaciones.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej03_PidoTresNumerosCalculoSuSuma {
+
+	public static void main(String[] args) {
+		int suma;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Introduzca un número entero: ");
+		suma = sc.nextInt();
+
+		System.out.println("Introduzca un número entero: ");
+		suma = suma + sc.nextInt();
+
+		System.out.println("Introduzca un número entero: ");
+		suma = suma + sc.nextInt();
+
+		System.out.println("La suma es " + suma);
+	}
+
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo1_io_tipos_y_operaciones/ejercicios/bloque01/Ej04_PidoTresNumerosCalculoSuMedia.java

@@ -0,0 +1,33 @@
+package tutorialJava.capitulo1_io_tipos_y_operaciones.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej04_PidoTresNumerosCalculoSuMedia {
+
+	public static void main(String[] args) {
+		int suma;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Introduzca un número entero: ");
+		suma = sc.nextInt();
+
+		System.out.println("Introduzca un número entero: ");
+		suma = suma + sc.nextInt();
+
+		System.out.println("Introduzca un número entero: ");
+		suma = suma + sc.nextInt();
+
+		System.out.println("La suma es " + (suma / 3f));
+		
+		sc.close();
+	}
+
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo1_io_tipos_y_operaciones/ejercicios/bloque01/Ej05_IntercambioValoresDosVariables.java

@@ -0,0 +1,36 @@
+package tutorialJava.capitulo1_io_tipos_y_operaciones.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej05_IntercambioValoresDosVariables {
+
+	public static void main(String[] args) {
+		int n1, n2, aux;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Introduzca un número entero: ");
+		n1 = sc.nextInt();
+
+		System.out.println("Introduzca un número entero: ");
+		n2 = sc.nextInt();
+
+		System.out.println("Los valores son " + n1 + " y " + n2);
+		
+		aux = n1;
+		n1 = n2;
+		n2 = aux;
+		
+		System.out.println("Los valores son " + n1 + " y " + n2);
+		
+		sc.close();
+	}
+
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo1_io_tipos_y_operaciones/ejercicios/bloque01/Ej06_CalculoCuotaMensualHipoteca.java

@@ -0,0 +1,32 @@
+package tutorialJava.capitulo1_io_tipos_y_operaciones.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej06_CalculoCuotaMensualHipoteca {
+
+	public static void main(String[] args) {
+		int meses = 300;
+		float capital = 200000;
+		float diferencial = 1.1f;
+		float euribor = 5.5f;
+		float interesAnual, interesMensual, aux, cuotaMensual;
+		
+		
+		interesAnual = (euribor + diferencial) / 100;
+		interesMensual = interesAnual / 12f;
+		aux = (float) Math.pow(1 + interesMensual, meses);
+		cuotaMensual = capital * (interesMensual * aux) / (aux - 1);
+		
+		System.out.println("Cuota: " + cuotaMensual);
+		
+	}
+
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo2_condicionales/Ejemplo01_Condicionales.java

@@ -2,17 +2,16 @@ package tutorialJava.capitulo2_condicionales;
 
 
 public class Ejemplo01_Condicionales {
-
-	 
+ 
 	/**
 	 * 
 	 * @param args
 	 */
 	public static void main (String args[]) {		
-		primerEjemploCondicionalSimple();
+//		primerEjemploCondicionalSimple();
 //		ejemploCondicionalCompuesto();
 //		ejemploCondicionalAnidado();
-//		ejemploCondicionalMultiple();
+		ejemploCondicionalMultiple();
 //		ejemploOperadorTernario();
 	}
 	
@@ -25,9 +24,10 @@ public class Ejemplo01_Condicionales {
 		System.out.println(numero); // Lo imprimo
 		
 		// Determino si el número está entre unos límites
-		if ( (numero >= 10 && numero <= 50) || (numero >= 70 && numero <= 90) ) {
+		if ( (numero >= 10 && numero <= 50) || (numero >= 70 && numero <= 90) ) { 
 			System.out.println("Bingooooooooo");
 		}
+		System.out.println("Saliendo");
 	}
 	
 	
@@ -53,6 +53,10 @@ public class Ejemplo01_Condicionales {
 	 */
 	public static void ejemploCondicionalAnidado () {
 		int numero = (int) Math.round(Math.random() * 100); // Pido número al azar
+		int signo = (int) Math.round(Math.random());
+		if (signo == 1) {
+			numero = numero * (-1);
+		}
 		System.out.println("Número al azar: " + numero);
 		
 		if (numero > 0) {
@@ -63,7 +67,9 @@ public class Ejemplo01_Condicionales {
 				System.out.println("Es negativo");
 			}		
 			else {
-				System.out.println("El número es cero");
+				if (numero == 0) {
+					System.out.println("El número es cero");
+				}
 			}
 		}
 		
@@ -74,16 +80,16 @@ public class Ejemplo01_Condicionales {
 	 * Ejemplo de switch
 	 */
 	public static void ejemploCondicionalMultiple () {
-		int nota = 1;
+		int nota = 0;
 		
 		// switch decidirá el camino a tomar en función del valor
 		// de la variable
 		switch (nota) {
 			case 0:
 			case 1:
-			case 2:
 				System.out.println("Muy deficiente"); // Se llega en los cases 0, 1 y 2
-				break; // Con esta instrucción salimos del switch
+				break;
+			case 2:
 			case 3:
 			case 4:
 				System.out.println("Deficiente");

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque01/Ej01_MayorDeDosNumeros.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej01_MayorDeDosNumeros {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n1, n2;
+		
+		System.out.println("Introduzca número: ");
+		n1 = sc.nextInt();
+		
+		System.out.println("Introduzca número: ");
+		n2 = sc.nextInt();
+		
+		if (n1 > n2) {
+			System.out.println("El mayor es " + n1);
+		}
+		else {
+			if (n2 > n1) {
+				System.out.println("El mayor es " + n2);
+			}
+			else { 
+				System.out.println("Son iguales");
+				System.out.println("Quillo, despierta que estás"
+						+ " acarajotao");
+			}
+		}
+	}
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque01/Ej02_MenorDeDosNumeros.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej02_MenorDeDosNumeros {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n1, n2;
+		
+		System.out.println("Introduzca número: ");
+		n1 = sc.nextInt();
+		
+		System.out.println("Introduzca número: ");
+		n2 = sc.nextInt();
+		
+		if (n1 < n2) {
+			System.out.println("El menor es " + n1);
+		}
+		else {
+			if (n2 < n1) {
+				System.out.println("El menor es " + n2);
+			}
+			else { 
+				System.out.println("Son iguales");
+				System.out.println("Quillo, despierta que estás"
+						+ " acarajotao");
+			}
+		}
+	}
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque01/Ej03_MayorDeCincoNumeros.java

@@ -0,0 +1,40 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej03_MayorDeCincoNumeros {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n, mayor;
+		
+		System.out.println("Introduzca número: ");
+		mayor = sc.nextInt();
+		
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+		if (n > mayor) mayor = n;
+		
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+		if (n > mayor) mayor = n;
+		
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+		if (n > mayor) mayor = n;
+		
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+		if (n > mayor) mayor = n;
+	
+		System.out.println("El mayor vale: " + mayor);
+	}
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque01/Ej04_MenorDeCincoNumeros.java

@@ -0,0 +1,40 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej04_MenorDeCincoNumeros {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n, menor;
+		
+		System.out.println("Introduzca número: ");
+		menor = sc.nextInt();
+		
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+		if (n < menor) menor = n;
+		
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+		if (n < menor) menor = n;
+	
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+		if (n < menor) menor = n;
+		
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+		if (n < menor) menor = n;
+	
+		System.out.println("El menor vale: " + menor);
+	}
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque01/Ej06_ParaOImparPorModulo.java

@@ -0,0 +1,25 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej06_ParaOImparPorModulo {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n;
+		
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+
+		if (n % 2 == 0) System.out.println("El número es par");
+		else 			System.out.println("El número es impar");
+	}
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque01/Ej07_ParaOImparPorOperadorDeBits.java

@@ -0,0 +1,25 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ej07_ParaOImparPorOperadorDeBits {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n;
+		
+		System.out.println("Introduzca número: ");
+		n = sc.nextInt();
+
+		if ((n & 1) == 0) System.out.println("El número es par");
+		else 			System.out.println("El número es impar");
+	}
+}
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque02/Ej01_Acumulador4Categorias.java

@@ -0,0 +1,75 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque02;
+
+import java.util.Scanner;
+
+public class Ej01_Acumulador4Categorias {
+
+	public static void main(String[] args) {
+		int sumaNegativos = 0, sumaBajos = 0, sumaMedios = 0, 
+				sumaAltos = 0, num;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		
+		if (num < 0) {
+//			sumaNegativos = sumaNegativos + num;
+			sumaNegativos += num;
+		}
+		else { 
+			if (num >= 0 && num <= 25) {
+				sumaBajos += num;
+			}
+			else {
+				if (num > 25 && num <= 250) {
+					sumaMedios += num;
+				}
+				else {
+					if (num > 250) {
+						sumaAltos += num;
+					}
+				}
+			}
+		}
+			
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		if (num < 0) sumaNegativos += num;
+		else if (num <= 25) sumaBajos += num;
+		else if (num <= 250) sumaMedios += num;
+		else sumaAltos += num;
+
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		if (num < 0) sumaNegativos += num;
+		else if (num <= 25) sumaBajos += num;
+		else if (num <= 250) sumaMedios += num;
+		else sumaAltos += num;
+
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		if (num < 0) sumaNegativos += num;
+		else if (num <= 25) sumaBajos += num;
+		else if (num <= 250) sumaMedios += num;
+		else sumaAltos += num;
+
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		if (num < 0) sumaNegativos += num;
+		else if (num <= 25) sumaBajos += num;
+		else if (num <= 250) sumaMedios += num;
+		else sumaAltos += num;
+
+		System.out.println("Negativos: " + sumaNegativos + 
+				" Bajos: " + sumaBajos + 
+				" Medios: " + sumaMedios +
+				" Altos: " + sumaAltos);
+	}
+
+}
+
+
+
+
+
+

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque02/Ej02_Contador4Categorias.java

@@ -0,0 +1,75 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque02;
+
+import java.util.Scanner;
+
+public class Ej02_Contador4Categorias {
+
+	public static void main(String[] args) {
+		int contNegativos = 0, contBajos = 0, contMedios = 0, 
+				contAltos = 0, num;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		
+		if (num < 0) {
+//			contNegativos += 1;
+			contNegativos++;
+		}
+		else { 
+			if (num >= 0 && num <= 25) {
+				contBajos++;
+			}
+			else {
+				if (num > 25 && num <= 250) {
+					contMedios++;
+				}
+				else {
+					if (num > 250) {
+						contAltos++;
+					}
+				}
+			}
+		}
+			
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		if (num < 0) contNegativos++;
+		else if (num <= 25) contBajos++;
+		else if (num <= 250) contMedios++;
+		else contAltos++;
+
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		if (num < 0) contNegativos++;
+		else if (num <= 25) contBajos++;
+		else if (num <= 250) contMedios++;
+		else contAltos++;
+
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		if (num < 0) contNegativos++;
+		else if (num <= 25) contBajos++;
+		else if (num <= 250) contMedios++;
+		else contAltos++;
+
+		System.out.println("Dame un número: ");
+		num = sc.nextInt();
+		if (num < 0) contNegativos++;
+		else if (num <= 25) contBajos++;
+		else if (num <= 250) contMedios++;
+		else contAltos++;
+
+		System.out.println("Negativos: " + contNegativos + 
+				" Bajos: " + contBajos + 
+				" Medios: " + contMedios +
+				" Altos: " + contAltos);
+	}
+
+}
+
+
+
+
+
+

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque03/Ejercicio01_NotaDeExamen.java

@@ -0,0 +1,45 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio01_NotaDeExamen {
+
+	public static void main(String[] args) {
+		int nota;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Introduzca la nota: ");
+		nota = sc.nextInt();
+		
+		// Ahora manejo la nota.
+		switch (nota) {
+		case 0:
+		case 1:
+			System.out.println("Muy deficiente");
+			break;
+		case 2:
+		case 3:
+		case 4:
+			System.out.println("Deficiente");
+			break;
+		case 5: 
+			System.out.println("Suficiente");
+			break;
+		case 6:
+			System.out.println("Bien");
+		case 7: 
+		case 8:
+			System.out.println("Notable");
+			break;
+		case 9:
+		case 10:
+			System.out.println("Sobresaliente");
+			break;
+		default:
+			System.out.println("Nota incorrecta");	
+		}
+		
+
+	}
+
+}

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque03/Ejercicio02_CalculadoraAvanzada.java

@@ -0,0 +1,47 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio02_CalculadoraAvanzada {
+
+	public static void main(String[] args) {
+		int opcion, num1, num2;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("\n\tMenú\n"
+				+ "\n1.- Raíz"
+				+ "\n2.- Potencia"
+				+ "\n3.- Módulo"
+				+ "\n\nIntroduzca su opción: ");
+		opcion = sc.nextInt();
+		
+		switch (opcion) {
+		case 1:
+			System.out.println("Introduzca índice: ");
+			num1 = sc.nextInt();
+			System.out.println("Introduzca radicando: ");
+			num2 = sc.nextInt();
+			System.out.println("Resultado = " + Math.pow(num2, 1f/num1));
+			break;
+		case 2:
+			System.out.println("Introduzca exponente: ");
+			num1 = sc.nextInt();
+			System.out.println("Introduzca base: ");
+			num2 = sc.nextInt();
+			System.out.println("Resultado = " + Math.pow(num2, num1));
+			break;
+		case 3:
+			System.out.println("Introduzca dividendo: ");
+			num1 = sc.nextInt();
+			System.out.println("Introduzca divisor: ");
+			num2 = sc.nextInt();
+			System.out.println("Resultado = " + (num1 % num2));
+			break;
+			
+			
+			
+		}
+
+	}
+
+}

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque03/Ejercicio03_CalculadoraGeometria.java

@@ -0,0 +1,61 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio03_CalculadoraGeometria {
+
+	public static void main(String[] args) {
+		int opcion, num1, num2;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("\n\tMenú\n"
+				+ "\n1.- Hipotenusa de un triángulo."
+				+ "\n2.- Superficie de un círculo."
+				+ "\n3.- Longitud de una circunferencia."
+				+ "\n4.- Área de un rectángulo."
+				+ "\n5.- Área de un triángulo."
+				+ "\n\nIntroduzca su opción: ");
+		opcion = sc.nextInt();
+		
+		switch (opcion) {
+		// Hipotenusa de un triángulo rectángulo
+		case 1:
+			System.out.println("Introduzca primer cateto: ");
+			num1 = sc.nextInt();
+			System.out.println("Introduzca segundo cateto: ");
+			num2 = sc.nextInt();
+			System.out.println("Resultado = " + Math.hypot(num1, num2));
+			break;
+		// Superficie de un círculo
+		case 2:
+			System.out.println("Introduzca radio del círculo: ");
+			num1 = sc.nextInt();
+			System.out.println("Resultado = " + (Math.PI * Math.pow(num1, 2)));
+			break;
+		// Longitud de una circunferencia
+		case 3:
+			System.out.println("Introduzca radio del círculo: ");
+			num1 = sc.nextInt();
+			System.out.println("Resultado = " + (2 * Math.PI * num1));
+			break;			
+		// Área de un rectángulo
+		case 4:
+			System.out.println("Introduzca la base: ");
+			num1 = sc.nextInt();
+			System.out.println("Introduzca la altura: ");
+			num2 = sc.nextInt();
+			System.out.println("Resultado = " + (num1 * num2));
+			break;
+		// Área de un triángulo
+		case 5:
+			System.out.println("Introduzca la base: ");
+			num1 = sc.nextInt();
+			System.out.println("Introduzca la altura: ");
+			num2 = sc.nextInt();
+			System.out.println("Resultado = " + (num1 * num2) / 2);
+			break;
+
+		}
+	}
+
+}

src/tutorialJava/capitulo2_condicionales/ejercicios/bloque03/Ejercicio04_DevolucionEnMonedas.java

@@ -0,0 +1,30 @@
+package tutorialJava.capitulo2_condicionales.ejercicios.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio04_DevolucionEnMonedas {
+
+	public static void main(String[] args) {
+		int precio, paga, cambioADevolver;
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Introduzca precio: ");
+		precio = sc.nextInt();
+		System.out.println("Introduzca unidades con las que paga: ");
+		paga = sc.nextInt();
+		
+		cambioADevolver = paga - precio;
+		
+		System.out.println((cambioADevolver / 100) + " Monedas de 100");
+		cambioADevolver = cambioADevolver % 100;
+		System.out.println((cambioADevolver / 50) + " Monedas de 50");
+		cambioADevolver %= 50;
+		System.out.println((cambioADevolver / 25) + " Monedas de 25");
+		cambioADevolver %= 25;
+		System.out.println((cambioADevolver / 5) + " Monedas de 5");
+		cambioADevolver %= 5;
+		System.out.println(cambioADevolver + " Monedas de 1");
+
+	}
+
+}

src/tutorialJava/capitulo3_bucles/Ejemplo01_Bucle_For.java

@@ -11,11 +11,11 @@ public class Ejemplo01_Bucle_For {
 	 * @param args
 	 */
 	public static void main (String args[]) {
-		cuentaAdelanteYAtras();
+//		cuentaAdelanteYAtras();
 //		cuentaAdelanteConMultiplos();
 //		tablaMultiplicar();
 //		mayorDeUnaSerieDeNumeros();
-//		numerosPrimos();		
+		numerosPrimos();		
 	}
 	
 	
@@ -26,10 +26,10 @@ public class Ejemplo01_Bucle_For {
 		
 		// Cuenta hacia delante
 		System.out.println("Cuenta adelante con bucle for");
-		for (int i = 0; i < 10; i++) {
+		for (int i = 0; i == i; i++) {
 			System.out.println("Valor de i: " + i);
 		}
-
+		
 		// Cuenta hacia atrás
 		System.out.println("Cuenta hacia atrás con bucle for");
 		for (int i = 10; i > -1; i--) {
@@ -62,7 +62,7 @@ public class Ejemplo01_Bucle_For {
 	public static void tablaMultiplicar () {
 		int factor = Integer.parseInt(JOptionPane.showInputDialog("Introduzca número"));;
 		
-		for (int i = 1; i < 11; i++) {
+		for (int i = 1; i <= 10; i++) {
 			System.out.println(i + " x " + factor + " = " + (i * factor));
 		}
 	}
@@ -76,11 +76,11 @@ public class Ejemplo01_Bucle_For {
 		
 		for (int i = 0; num != 0; i++) {
 			if (i == 0) { // Estoy en la primera iteración del bucle
-				mayor = Integer.parseInt(JOptionPane.showInputDialog("Introduzca número: "));
+				mayor = Integer.parseInt(JOptionPane.showInputDialog("Introduzca número: (0 para salir)"));
 			}
 			else {
-				num = Integer.parseInt(JOptionPane.showInputDialog("Introduzca número: "));
-				if (num > mayor && num!= 0) {
+				num = Integer.parseInt(JOptionPane.showInputDialog("Introduzca número: (0 para salir)"));
+				if (num > mayor && num != 0) {
 					mayor = num;
 				}
 			}
@@ -111,21 +111,23 @@ public class Ejemplo01_Bucle_For {
 	 */
 	public static void numerosPrimos () {
 
-		
-		for (int num = 1; num < 1000000; num++) {
-			boolean esPrimo = true;
+//		int num = 7037;
 
+		for (int num = 100000000; true; num++) {
+
+			boolean esPrimo = true;
 			for (int i = 2; i < num; i++) {
 				if (num % i == 0) {
 					esPrimo = false;
+					break;
 				}
 			}
 			
 			if (esPrimo == true) {
 				System.out.println(num + " es primo");
 			}
+
 		}
-		
 	}
 	
 	

src/tutorialJava/capitulo3_bucles/ejercicios/bloque01/Ejercicio01_SumarNumerosMayoresDe10.java

@@ -0,0 +1,22 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ejercicio01_SumarNumerosMayoresDe10 {
+
+	public static void main(String[] args) {
+		int suma = 0, num;
+		Scanner sc = new Scanner (System.in);
+		
+		for (int i = 0; i < 4; i++) {
+			System.out.println("Introduzca un número: ");
+			num = sc.nextInt();
+			if (num > 10) {
+				suma += num;
+			}
+		}
+
+		System.out.println("La suma vale: " + suma);
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque01/Ejercicio02_SumarNumerosMayoresDe10TantosComoQuieraUsuario.java

@@ -0,0 +1,25 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ejercicio02_SumarNumerosMayoresDe10TantosComoQuieraUsuario {
+
+	public static void main(String[] args) {
+		int suma = 0, num, repeticiones;
+		Scanner sc = new Scanner (System.in);
+		
+		System.out.println("¿Cuántos números va a introduci?");
+		repeticiones = sc.nextInt();
+		
+		for (int i = 0; i < repeticiones; i++) {
+			System.out.println("Introduzca un número: ");
+			num = sc.nextInt();
+			if (num > 10) {
+				suma += num;
+			}
+		}
+
+		System.out.println("La suma vale: " + suma);
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque01/Ejercicio03_PositivosYNegativosTantosComoQuieraUsuario.java

@@ -0,0 +1,29 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+public class Ejercicio03_PositivosYNegativosTantosComoQuieraUsuario {
+
+	public static void main(String[] args) {
+		int suma = 0, num, repeticiones, contPositivos = 0, contNegativos = 0;
+		Scanner sc = new Scanner (System.in);
+		
+		System.out.println("¿Cuántos números va a introducir?");
+		repeticiones = sc.nextInt();
+		
+		for (int i = 0; i < repeticiones; i++) {
+			System.out.println("Introduzca un número: ");
+			num = sc.nextInt();
+			if (num > 0) {
+				contPositivos++;
+			}
+			if (num < 0) {
+				contNegativos++;
+			}
+		}
+
+		System.out.println("Positivos: " + contPositivos);
+		System.out.println("Negativos: " + contNegativos);
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque02/Ejercicio01_MediaTantosComoQuieraUsuario.java

@@ -0,0 +1,23 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio01_MediaTantosComoQuieraUsuario {
+
+	public static void main(String[] args) {
+		int suma = 0, num, repeticiones;
+		Scanner sc = new Scanner (System.in);
+		
+		System.out.println("¿Cuántos números va a introducir?");
+		repeticiones = sc.nextInt();
+		
+		for (int i = 0; i < repeticiones; i++) {
+			System.out.println("Introduzca un número: ");
+			num = sc.nextInt();
+			suma += num;
+		}
+
+		System.out.println("Media de los números: " + (suma / (float) repeticiones));
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque02/Ejercicio02_MayorYMenorTantosComoQuieraUsuario.java

@@ -0,0 +1,35 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio02_MayorYMenorTantosComoQuieraUsuario {
+
+	public static void main(String[] args) {
+		int suma = 0, num, repeticiones, mayor = 0, menor = 0;
+		Scanner sc = new Scanner (System.in);
+		
+		System.out.println("¿Cuántos números va a introducir?");
+		repeticiones = sc.nextInt();
+		
+		for (int i = 0; i < repeticiones; i++) {
+			System.out.println("Introduzca un número: ");
+			num = sc.nextInt();
+			// Sólo vamos a entrar en el siguiente if en la primera iteración
+			// del bucle. Aprovechamos para inicializar las variables mayor y
+			// menor
+			if (i == 0) {
+				mayor = num;
+				menor = num;
+			}
+			// En el caso else no estamos en la primera iteración del bucle
+			else {
+				if (num > mayor) mayor = num;
+				if (num < menor) menor = num;				
+			}
+		}
+
+		System.out.println("Mayor: " + mayor);
+		System.out.println("Menor: " + menor);
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque02/Ejercicio03_MultiplosHastaUnLimite.java

@@ -0,0 +1,20 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio03_MultiplosHastaUnLimite {
+
+	public static void main(String[] args) {
+		int num, repeticiones;
+		Scanner sc = new Scanner (System.in);
+		
+		System.out.println("Número al que calcular sus múltiplos: ");
+		num = sc.nextInt();
+		
+		// Otra forma de hacer los múltiplos
+		for (int i = 0; i < 100; i+=num) {
+			System.out.println("Múltiplo de " + num + ": " + i);
+		}
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque02/Ejercicio04_MultiplosHastaUnLimiteDadoPorUsuario.java

@@ -0,0 +1,24 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio04_MultiplosHastaUnLimiteDadoPorUsuario {
+
+	public static void main(String[] args) {
+		int num, limite;
+		Scanner sc = new Scanner (System.in);
+		
+		System.out.println("Número al que calcular sus múltiplos: ");
+		num = sc.nextInt();
+
+		System.out.println("Límite para calcular múltiplos: ");
+		limite = sc.nextInt();
+		
+		
+		// Otra forma de hacer los múltiplos
+		for (int i = num; i <= limite; i+=num) {
+			System.out.println("Múltiplo de " + num + ": " + i);
+		}
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque03/Ejercicio01_SumaMediaNumerosHasta0.java

@@ -0,0 +1,23 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio01_SumaMediaNumerosHasta0 {
+
+	public static void main(String[] args) {
+		int suma = 0, contador = 0, num = 1;
+		Scanner sc = new Scanner(System.in);
+
+		
+		for (;num != 0;) {
+			System.out.println("Introduzca número: ");
+			num = sc.nextInt();
+			suma += num;
+			contador++;
+		}
+			
+		System.out.println("Suma: " + suma + " - Media: " + (suma / (float) (contador-1)));
+
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque03/Ejercicio02_MayorMenorNumerosHasta0.java

@@ -0,0 +1,29 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio02_MayorMenorNumerosHasta0 {
+
+	public static void main(String[] args) {
+		int mayor = 0, menor = 0, num = 1;
+		Scanner sc = new Scanner(System.in);
+
+		
+		for (int i = 0; num != 0; i++) {
+			System.out.println("Introduzca número: ");
+			num = sc.nextInt();
+			if (i == 0) {
+				mayor = num;
+				menor = num;
+			}
+			else {
+				if (num > mayor) mayor = num;
+				if (num < menor) menor = num;
+			}
+		}
+			
+		System.out.println("Mayor: " + mayor + " - Menor: " + menor);
+
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque03/Ejercicio03_TablaDeMultiplicarHasta0.java

@@ -0,0 +1,26 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio03_TablaDeMultiplicarHasta0 {
+
+	public static void main(String[] args) {
+		int num = 1;
+		Scanner sc = new Scanner(System.in);
+
+		
+		for (;num != 0;) {
+			System.out.println("Introduzca número: ");
+			num = sc.nextInt();
+			if (num == 0) {
+				break;
+			}
+			
+			for (int i = 1; i <= 10; i++) {
+				System.out.println(num + " * " + i + " = " + (num * i));
+			}
+		}
+
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque03/Ejercicio04_ContadorPositivosYNegativosHasta0.java

@@ -0,0 +1,26 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio04_ContadorPositivosYNegativosHasta0 {
+
+	public static void main(String[] args) {
+		int num = 1, contadorPos = 0, contadorNeg = 0;
+		Scanner sc = new Scanner(System.in);
+
+		
+		for (;num != 0;) {
+			System.out.println("Introduzca número: ");
+			num = sc.nextInt();
+			if (num == 0) {
+				break;
+			}
+			
+			if (num > 0) contadorPos++;
+			if (num < 0) contadorNeg++;
+		}
+
+		System.out.println("Positivos: " + contadorPos + " - Negativos: " + contadorNeg);
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque04/Ejercicio01_NumeroPrimoOCompuestoSinFor.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque04;
+
+import java.util.Scanner;
+
+public class Ejercicio01_NumeroPrimoOCompuestoSinFor {
+
+	public static void main(String[] args) {
+		// Creo las variables necesarias
+		int numUsuario, i;
+		Scanner sc = new Scanner(System.in);
+		boolean numeroTieneDivisores;
+		
+		// Pido el número al usuario
+		System.out.println("Por favor, introduzca un número y comprobaré si es primo: ");
+		numUsuario = sc.nextInt();
+		
+		// Utilizo un bucle diferente al for, pero le imito con una variable "i"
+		i = 2;
+		numeroTieneDivisores = false;
+		// Pasaré con la variable "i" por todos los números entre el 2 y el anterior al número
+		// que ha introducido el usuario, buscando divisores
+		while (i < numUsuario) {
+			if (numUsuario % i == 0) { // He encontrado un divisor
+				numeroTieneDivisores = true;
+				break;
+			}
+			i++;
+		}
+		
+		// Si el número tiene divisores se trata de un compuesto, si no se trata de un primo
+		if (numeroTieneDivisores) {
+			System.out.println("El número " + numUsuario + " es compuesto");
+		}
+		else {
+			System.out.println("El número " + numUsuario + " es primo");
+		}
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque04/Ejercicio02_NumerosPrimosOCompuestoEntreLimitesSinFor.java

@@ -0,0 +1,52 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque04;
+
+import java.util.Scanner;
+
+public class Ejercicio02_NumerosPrimosOCompuestoEntreLimitesSinFor {
+
+	public static void main(String[] args) {
+		// Creo las variables necesarias
+		int limiteInf, limiteSup, numInvestigado, i;
+		Scanner sc = new Scanner(System.in);
+		boolean numeroTieneDivisores;
+		
+		// Pido los límites al usuario
+		System.out.println("Por favor, introduzca un límite inferior: ");
+		limiteInf = sc.nextInt();
+		System.out.println("Por favor, introduzca un límite superior: ");
+		limiteSup = sc.nextInt();
+		
+		// Utilizo un bucle diferente al for, con la variable "numInvestigado"
+		numInvestigado = limiteInf;
+		// Pasaré por todos los número entre el límite inferior y el superior, comprobando siempre el 
+		// numInvestigado
+		while (numInvestigado <= limiteSup) {
+			// Supongo que el número investigado es primo e intento demostrar que tiene algún divisor.
+			numeroTieneDivisores = false;
+			i = 2;
+			// Pasaré con la variable "i" por todos los números entre el 2 y el anterior al número
+			// que ha introducido el usuario, buscando divisores
+			while (i < numInvestigado) {
+				if (numInvestigado % i == 0) { // He encontrado un divisor
+					numeroTieneDivisores = true;
+					break;
+				}
+				i++;
+			}
+			
+			// Si el número tiene divisores se trata de un compuesto, si no se trata de un primo
+			if (numeroTieneDivisores == true) {
+				System.out.println("El número " + numInvestigado + " es compuesto");
+			}
+			else {
+				System.out.println("El número " + numInvestigado + " es primo");
+			}
+			
+			// Sumamos uno al número investigado para comprobar el siguiente número
+			numInvestigado++;
+		}
+		
+		
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque04/Ejercicio03_TablasMultiplicarHasta15.java

@@ -0,0 +1,24 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque04;
+
+public class Ejercicio03_TablasMultiplicarHasta15 {
+
+	public static void main(String[] args) {
+		// Declaro las variables
+		int num = 1; // Número al que se le calculará su tabla de multiplicar
+		int factor; // Factor por el que se multiplicará al número "num"
+		
+		// En lugar de bucles "for" usaré bucles while
+		
+		do {
+			factor = 1;
+			System.out.println("\nTabla de multiplicar del " + num);
+			do {
+				System.out.println("\t" + num + " x " + factor + " = " + (num * factor));
+				factor++; // Aumento el factor
+			} while (factor <= 10);
+			
+			num++; // Prepara para que se calcule la tabla de multiplicar del siguiente número;
+		} while (num <= 15);
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque04/Ejercicio04_ImprimirEnteroEnBinario.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque04;
+
+import java.util.Scanner;
+
+public class Ejercicio04_ImprimirEnteroEnBinario {
+
+	public static void main(String[] args) {
+		// Declaro las variables
+		int numAImprimirEnBinario;
+		Scanner sc = new Scanner(System.in);
+		int numDescubrimientoBits;
+		
+		// Pido el número al usuario
+		System.out.println("Por favor, introduzca un número y lo imprimiré en binario: ");
+		numAImprimirEnBinario = sc.nextInt();
+		
+		// Voy a hacer la operación "&" para ir detectando los bits del número
+		numDescubrimientoBits = (int) Math.pow(2, 30);
+		while (numDescubrimientoBits > 0) {
+			
+			if ( (numDescubrimientoBits & numAImprimirEnBinario) != 0) {
+				System.out.print("1");
+			}
+			else {
+				System.out.print("0");
+			}
+			
+			// Acualizo el valor del numDescubrimientoBits para que apunte al siguiente bit por descubrir
+			numDescubrimientoBits >>= 1;
+		}
+
+	}
+
+}
+
+
+
+
+

src/tutorialJava/capitulo3_bucles/ejercicios/bloque04/Ejercicio05_FactorialSinUsarBucleFor.java

@@ -0,0 +1,28 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque04;
+
+import java.util.Scanner;
+
+public class Ejercicio05_FactorialSinUsarBucleFor {
+
+	public static void main(String[] args) {
+		// Declaro las variables
+		int num, i, factorial = 1;
+		Scanner sc = new Scanner(System.in);
+		
+		// Pido el número al usuario
+		System.out.println("Por favor, introduzca un número y calcularé su factorial: ");
+		num = sc.nextInt();
+		
+		// Realizo el algoritmo de cálculo del factorial
+		factorial = num;
+		i = num - 1;
+		while (i > 1) {
+			factorial *= i;
+			i--;
+		}
+		
+		// Imprimo el resultado
+		System.out.println("Factorial de " + num + " es: " + factorial);
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque05/Ej01_sumaCifrasDeUnNumero.java

@@ -0,0 +1,19 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque05;
+
+public class Ej01_sumaCifrasDeUnNumero {
+
+	public static void main(String[] args) {
+		int num = 2345;
+		int sumaDigitos = 0; 
+		
+		for (int i = 10000000; i > 0; i/=10) {
+			int digito = num / i;
+			num = num % i;
+			sumaDigitos += digito;
+		}
+		
+		System.out.println("Suma: " + sumaDigitos);
+		
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque05/Ej02_SerieFibonacci.java

@@ -0,0 +1,18 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque05;
+
+public class Ej02_SerieFibonacci {
+
+	public static void main(String[] args) {
+		int actual = 0, ant = 1, ant_1 = 1;
+
+		int cantidadValores = 6;
+		
+		for (int i = 0; i < cantidadValores; i++) {
+			ant_1 = ant;
+			ant = actual;
+			actual = ant + ant_1;
+			System.out.print(actual + " ");
+		}
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque05/Ej03_NumerosPerfectos.java

@@ -0,0 +1,28 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque05;
+
+public class Ej03_NumerosPerfectos {
+
+	public static void main(String[] args) {
+		int limInf = 1, limSup = 150000;
+		int sumaDivisores = 0;
+		
+		
+		for (int i = limInf; i <= limSup; i++) {
+			sumaDivisores = 0;
+			for (int j = 1; j < i; j++) {
+				if (i % j == 0) { // j es divisor de i
+					sumaDivisores += j;
+				}
+			}
+			// En "sumaDivisores" tengo la suma de todos
+			// los divisores de i
+			if (i == sumaDivisores) {
+				System.out.println(i + " es un número perfecto");
+			}
+		}
+	}
+
+}
+
+
+

src/tutorialJava/capitulo3_bucles/ejercicios/bloque05/Ej04_JuegoBuscarNumeroPensado.java

@@ -0,0 +1,33 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque05;
+
+import java.util.Scanner;
+
+public class Ej04_JuegoBuscarNumeroPensado {
+
+	public static void main(String[] args) {
+		int numeroPensado, tirada;
+		Scanner sc = new Scanner(System.in);
+		
+		numeroPensado = (int) Math.round(Math.random() * 100);
+
+		do {
+			System.out.println("Dame un número: ");
+			tirada = sc.nextInt();
+			
+			if (tirada < numeroPensado) {
+				System.out.println("Mi número pensado es mayor");
+			}
+			else {
+				if (tirada > numeroPensado) {
+					System.out.println("Mi número pensado es menor");
+				}
+				else {
+					System.out.println("Enhorabuena, lo has encontrado");
+				}
+			}
+			
+		} while(tirada != numeroPensado);
+		
+	}
+
+}

src/tutorialJava/capitulo3_bucles/ejercicios/bloque05/Ej05_TrianguloPascal.java

@@ -0,0 +1,36 @@
+package tutorialJava.capitulo3_bucles.ejercicios.bloque05;
+
+public class Ej05_TrianguloPascal {
+
+	public static void main(String[] args) {
+		int filas = 5;
+	
+		for (int i = 0; i < filas; i++) {
+			for (int j = 0; j < (filas - i); j++) {
+				System.out.print(" ");
+			}
+			
+			for (int j = 0; j <= i; j++) {
+				int valor = (int) (factorial(i) / 
+						(factorial(j) * factorial (i - j) ));
+				System.out.print(valor + " ");
+			}
+			System.out.println("");
+		}
+	}
+	
+	/**
+	 * 
+	 * @param n
+	 * @return
+	 */
+	public static float factorial (int n) {
+		if (n == 0) {
+			return 1;
+		}
+		for (int i = n - 1; i > 1; i--) {
+			n *= i;
+		}
+		return n;
+	}
+}

src/tutorialJava/capitulo4_Arrays/Ej01_EjemploArraysPrimitivos.java

@@ -9,8 +9,8 @@ public class Ej01_EjemploArraysPrimitivos {
 	 * @param args
 	 */
 	public static void main(String[] args) {
-		primerEjemploArray();
-//		segundoEjemploArray();
+//		primerEjemploArray();
+		segundoEjemploArray();
 //		tercerEjemploArray();
 	}
 	
@@ -40,7 +40,7 @@ public class Ej01_EjemploArraysPrimitivos {
 	 */
 	public static void segundoEjemploArray() {
 		// Otra forma de inicializar el array
-		int array2[] = new int[] {88, 89, 90, 4, 5, 6, 7, 8, 9, 10};
+		int array2[] = new int[] {88, 89, 90, 4, 5, 8, 9, 10};
 
 		// Recorrido del array para imprimir sus valores en pantalla.
 		// Este tipo de bucle se conoce como "for each".
@@ -59,22 +59,22 @@ public class Ej01_EjemploArraysPrimitivos {
 		float media;
 		
 		// Declaración del array
-		int array[] = new int[1000000];
+		int array[] = new int[10];
 		
 		// Recorro para inicializar el array
 		for (int i = 0; i < array.length; i++) {
-			array[i] = (int) Math.round(Math.random()*10000);
+			array[i] = (int) Math.round(Math.random() * 100);
 		}
 		
 		// Recorro e imprimo en pantalla
-		for (int i = 0; i < array.length; i++) {
-			System.out.print(array[i] + " ");
+		for (int n : array) {
+			System.out.print(n + " ");
 		}
 		System.out.println("");
 		
 		// Recorro para obtener la suma
-		for (int i = 0; i < array.length; i++) {
-			suma += array[i];
+		for (int n : array) {
+			suma += n;
 		}
 		// Calculo la media
 		media = suma / ((float) array.length);

src/tutorialJava/capitulo4_Arrays/Ej03_ArraysDeCaracteres.java

@@ -0,0 +1,44 @@
+package tutorialJava.capitulo4_Arrays;
+
+import tutorialJava.UtilsArrays;
+
+public class Ej03_ArraysDeCaracteres {
+
+	public static void main(String[] args) {
+//		char a[] = new char[] {'H', 'o', 'l', 'a'};
+//		
+//		for (int i = 0; i < a.length; i++) {
+//			System.out.println((int) a[i]);
+//		}
+		
+		
+//		int a[] = new int[10];
+//		UtilsArrays.inicializaArray(a, 97, 122);
+//		for (int i = 0; i < a.length; i++) {
+//			System.out.print(a[i]);
+//			System.out.println(" " + ((char) a[i]));
+//		}
+		
+		String str = "HolA";
+		for (int i = 0; i < str.length(); i++) {
+			int valorNumChar = (int) str.charAt(i);
+			if (valorNumChar >= 97 && valorNumChar <=122) { // minúsculas
+				System.out.print(str.charAt(i));
+			}
+			else {
+				if (valorNumChar >= 65 && valorNumChar <= 90) { // mayúsculas
+					System.out.print( (char) (valorNumChar + 32) );
+				}
+			}
+		}
+	}
+}
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/Ej03_EjemploMatrices.java

@@ -1,23 +1,28 @@
 package tutorialJava.capitulo4_Arrays;
 
+import java.util.Iterator;
+
 import tutorialJava.Utils;
 
 public class Ej03_EjemploMatrices {
 
 	public static void main(String[] args) {
+//		primeraFormaDeclararUnaMatri();
+		segundaFormaDeclararUnaMatri();
+	}
+	
+	/**
+	 * 
+	 */
+	public static void primeraFormaDeclararUnaMatri() {
 		int m[][] = new int[4][3];
-//		int m2[][] = new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
 		
-		int cont = 1;
 		for (int i = 0; i < m.length; i++) {
 			for (int j = 0; j < m[i].length; j++) {
-//				m[i][j] = (int) Math.round(Math.random() * 100);
-				m[i][j] = cont;
-				cont++;
+				m[i][j] = (int) Math.round(Math.random() * 100);
 			}
 		}
 		
-		m[0][2] = 1;
 		
 		for (int i = 0; i < m.length; i++) {
 			for (int j = 0; j < m[i].length; j++) {
@@ -27,4 +32,30 @@ public class Ej03_EjemploMatrices {
 		}
 		
 	}
+	
+	
+	/**
+	 * 
+	 */
+	public static void segundaFormaDeclararUnaMatri() {
+		int m[][] = new int[][] {{1, 2, 3}, 
+								 {4, 5, 6}, 
+								 {7, 8, 9}, 
+								 {10, 11, 12}};
+				
+		for (int i = 0; i < m.length; i++) {
+			for (int j = 0; j < m[i].length; j++) {
+				System.out.print(m[i][j] + " ");
+			}
+			System.out.println();
+		}
+		
+	}
+
 }
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/Ej04_ComoHacerEjerciciosMatrices.java

@@ -16,7 +16,8 @@ public class Ej04_ComoHacerEjerciciosMatrices {
 									{10,	0, 		12, 	13, 	14}, 
 									{0, 	16,		17, 	18, 	19}, 
 									{20, 	21, 	22, 	0, 		24} };
-									
+
+//		int m[][] = new int[5][5];
 //		inicializaMatrizAlAzar(m);
 		imprimeMatriz(m);
 		System.out.println("Es positiva: " + esMatrizPositiva(m));

src/tutorialJava/capitulo4_Arrays/EjemploMetodos.java

@@ -0,0 +1,15 @@
+package tutorialJava.capitulo4_Arrays;
+
+import tutorialJava.UtilsArrays;
+
+public class EjemploMetodos {
+
+	public static void main(String[] args) {
+		int array[] = new int[10];
+		UtilsArrays.inicializaArray(array, 0, 10000);
+		UtilsArrays.imprimeArray(array);
+		
+	}
+
+	
+}

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque01/Ejercicio01_150ElementosEnArray_SumaMediaMayorMenor.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque01;
+
+import tutorialJava.Utils;
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio01_150ElementosEnArray_SumaMediaMayorMenor {
+
+	public static void main(String[] args) {
+		int array[] = new int[500];
+
+		UtilsArrays.inicializaArray(array, 0, 100);
+		
+		UtilsArrays.imprimeArray(array);
+			
+		
+		// Imprimo resultados
+		System.out.println("Suma: " + UtilsArrays.suma(array) 
+				+ " - Media: " + UtilsArrays.promedia(array) + 
+				" - Menor: " + UtilsArrays.menor(array) 
+				+ " - Mayor: " + UtilsArrays.mayor(array));
+		
+	}
+
+	
+	
+}
+
+
+
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque01/Ejercicio02_150ElementosEnArray_SumaMediaMayorMenorEntreLimites.java

@@ -0,0 +1,46 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque01;
+
+import java.util.Scanner;
+
+import tutorialJava.Utils;
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio02_150ElementosEnArray_SumaMediaMayorMenorEntreLimites {
+
+	public static void main(String[] args) {
+		int array[] = new int[5], suma = 0, mayor, menor;
+		int limInf, limSup;
+		float media;		
+		
+		limInf = Utils.pideNumeroEntero("Introduzca límite inferior: ");
+		limSup = Utils.pideNumeroEntero("Introduzca límite superior: ");
+		
+		UtilsArrays.inicializaArray(array, limInf, limSup);
+		
+		UtilsArrays.imprimeArray(array);
+
+		// Imprimo resultados
+		System.out.println("Suma: " + UtilsArrays.suma(array) 
+				+ " - Media: " + UtilsArrays.promedia(array) + 
+				" - Menor: " + UtilsArrays.menor(array) 
+				+ " - Mayor: " + UtilsArrays.mayor(array));
+		
+
+	}
+
+	
+	
+}
+
+
+
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque01/Ejercicio03_MuestraArrayEnOrdenInverso.java

@@ -0,0 +1,20 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque01;
+
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio03_MuestraArrayEnOrdenInverso {
+
+	public static void main(String[] args) {
+		int array[] = new int[5];
+		
+		UtilsArrays.inicializaArray(array, 0, 100);
+		
+		UtilsArrays.imprimeArray(array);
+		
+		for (int i = array.length-1; i >= 0; i--) {
+			System.out.print(array[i] + " ");
+		}
+
+	}
+
+}

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque01/Ejercicio04_EncuentraElementoEnArray.java

@@ -0,0 +1,34 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque01;
+
+import tutorialJava.Utils;
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio04_EncuentraElementoEnArray {
+
+	public static void main(String[] args) {
+		int array[] = new int[5];
+		int numBuscado;
+		
+		UtilsArrays.inicializaArray(array, 0, 100);
+		
+		UtilsArrays.imprimeArray(array);
+		
+		numBuscado = Utils.pideNumeroEntero("Número que deseas encontrar: ");
+		
+		for (int i = 0; i < array.length; i++) {
+			if (numBuscado == array[i]) {
+				System.out.println("Encontrado en posición " + i);
+				return;
+			}
+		}
+		System.out.println("El número no existe en el array");
+	}
+
+}
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque01/Ejercicio05_SumaValoresParesEImpares.java

@@ -0,0 +1,36 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque01;
+
+import tutorialJava.Utils;
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio05_SumaValoresParesEImpares {
+
+	public static void main(String[] args) {
+		int array[] = new int[5];
+		int sumaPares = 0, sumaImpares = 0;
+		
+		UtilsArrays.inicializaArray(array, 0, 100);
+		
+		UtilsArrays.imprimeArray(array);
+		
+		for (int i = 0; i < array.length; i++) {
+			if (array[i] % 2 == 0) {
+				sumaPares += array[i];
+			}
+			else {
+				sumaImpares += array[i];
+			}
+		}
+		
+		System.out.println("Suma pares: " + sumaPares + " - "
+				+ "Suma impares: " + sumaImpares);
+	}
+
+}
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque01/Ejercicio06_SumaValoresIndicePar.java

@@ -0,0 +1,36 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque01;
+
+import tutorialJava.Utils;
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio06_SumaValoresIndicePar {
+
+	public static void main(String[] args) {
+		int array[] = new int[5];
+		int sumaPares = 0, sumaImpares = 0;
+		
+		UtilsArrays.inicializaArray(array, 0, 100);
+		
+		UtilsArrays.imprimeArray(array);
+		
+		for (int i = 0; i < array.length; i++) {
+			if (array[i] % 2 == 0) {
+				sumaPares += array[i];
+			}
+			else {
+				sumaImpares += array[i];
+			}
+		}
+		
+		System.out.println("Suma pares: " + sumaPares);
+		System.out.println("Suma impares: " + sumaImpares);
+	}
+
+}
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque02/Ejercicio01_ParesCambianSignoEnArray.java

@@ -0,0 +1,31 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque02;
+
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio01_ParesCambianSignoEnArray {
+
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main (String args[]) {
+		int a[] = new int[15];
+		UtilsArrays.inicializaArray(a, -100, 100);
+		UtilsArrays.imprimeArray(a);
+		cambiaSignoEnValores(a);
+		UtilsArrays.imprimeArray(a);
+	}
+	
+	/**
+	 * 
+	 * @param array
+	 */
+	public static void cambiaSignoEnValores(int array[]) {
+		for (int i = 0; i < array.length; i++) {
+			if (array[i] % 2 == 0) {
+				array[i] = -array[i];
+			}
+		}
+	}
+	
+}

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque02/Ejercicio02_DosArraysCrearTercerArray.java

@@ -0,0 +1,52 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque02;
+
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio02_DosArraysCrearTercerArray {
+
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main (String args[]) {
+		int a1[] = new int[15];
+		int a2[] = new int[15];
+		int a3[];
+		
+		UtilsArrays.inicializaArray(a1, 0, 100);
+		UtilsArrays.imprimeArray(a1);
+		UtilsArrays.inicializaArray(a2, 0, 100);
+		UtilsArrays.imprimeArray(a2);
+		
+		a3 = creaTercerArray(a1, a2);
+		UtilsArrays.imprimeArray(a3);
+	}
+	
+	/**
+	 * 
+	 * @param array
+	 */
+	public static int[] creaTercerArray (int a1[], int a2[]) {
+		int a[] = new int[a1.length];
+		for (int i = 0; i < a1.length; i++) {
+			if (i % 2 == 1) {
+				a[i] = a1[i];
+			}
+			else {
+				a[i] = a2[i];
+			}
+		}
+		return a;
+	}
+	
+}
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque02/Ejercicio03_MultiplicaElementosArray.java

@@ -0,0 +1,46 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque02;
+
+import tutorialJava.Utils;
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio03_MultiplicaElementosArray {
+
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main (String args[]) {
+		int a1[] = new int[15];
+		int factor;
+		
+		// Incializo e imprimo el array
+		UtilsArrays.inicializaArray(a1, 0, 100);
+		UtilsArrays.imprimeArray(a1);
+		
+		factor = Utils.pideNumeroEntero("Por favor, introduzca el factor: ");
+		
+		multiplicaValoresPorFactor(a1, factor);
+	}
+	
+	/**
+	 * 
+	 * @param a
+	 * @param factor
+	 */
+	public static void multiplicaValoresPorFactor (int a[], int factor) {
+		for (int i = 0; i < a.length; i++) {
+			a[i] *= factor;
+		}
+	}
+	
+}
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque02/Ejercicio04_DeplazamientoCiclicoDerecha.java

@@ -0,0 +1,43 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque02;
+
+import tutorialJava.Utils;
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio04_DeplazamientoCiclicoDerecha {
+
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main (String args[]) {
+		int a[] = new int[] {1, 2, 3, 4, 5};
+		
+		UtilsArrays.imprimeArray(a);
+		desplazaCiclicoDerecha(a);
+		UtilsArrays.imprimeArray(a);
+	}
+	
+	/**
+	 * 
+	 * @param a
+	 * @param factor
+	 */
+	public static void desplazaCiclicoDerecha (int a[]) {
+		int aux = a[a.length - 1];
+		for (int i = (a.length - 1); i > 0; i--) {
+			a[i] = a[i - 1];
+		}
+		a[0] = aux;
+	}
+	
+}
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque02/Ejercicio05_DeplazamientoCiclicoDerechaLugaresPersonalizados.java

@@ -0,0 +1,48 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque02;
+
+import tutorialJava.Utils;
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio05_DeplazamientoCiclicoDerechaLugaresPersonalizados {
+
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main (String args[]) {
+		int a[] = new int[] {1, 2, 3, 4, 5};
+		int posiciones;
+		
+		UtilsArrays.imprimeArray(a);
+		
+		posiciones = Utils.pideNumeroEntero("Indica cantidad de posiciones a derecha: ");
+		desplazaCiclicoDerecha(a, posiciones);
+		UtilsArrays.imprimeArray(a);
+	}
+	
+	/**
+	 * 
+	 * @param a
+	 * @param factor
+	 */
+	public static void desplazaCiclicoDerecha (int a[], int posicionesARotar) {
+		for (int repeticiones = 0; repeticiones < posicionesARotar; repeticiones++) {
+			int aux = a[a.length - 1];
+			for (int i = (a.length - 1); i > 0; i--) {
+				a[i] = a[i - 1];
+			}
+			a[0] = aux;
+		}
+	}
+	
+}
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque02/Ejercicio06_DeplazamientoCiclicoLugaresYDireccionPersonalizadas.java

@@ -0,0 +1,61 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque02;
+
+import tutorialJava.Utils;
+import tutorialJava.UtilsArrays;
+
+public class Ejercicio06_DeplazamientoCiclicoLugaresYDireccionPersonalizadas {
+
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main (String args[]) {
+		int a[] = new int[] {1, 2, 3, 4, 5};
+		int posiciones, direccion;
+		
+		UtilsArrays.imprimeArray(a);
+		
+		posiciones = Utils.pideNumeroEntero("Indica cantidad de posiciones: ");
+		direccion = Utils.pideNumeroEntero("Indica dirección (0-Izquierda, 1-Derecha): ");
+		desplazaCiclico(a, posiciones, direccion);
+		UtilsArrays.imprimeArray(a);
+	}
+	
+	/**
+	 * 
+	 * @param a
+	 * @param factor
+	 */
+	public static void desplazaCiclico (int a[], int posiciones, int direccion) {
+
+		if (direccion == 1) { // Se desea desplazar a derecha
+			for (int repeticiones = 0; repeticiones < posiciones; repeticiones++) {
+				int aux = a[a.length - 1];
+				for (int i = (a.length - 1); i > 0; i--) {
+					a[i] = a[i - 1];
+				}
+				a[0] = aux;
+			}
+		}
+		else { // Se desea desplazar a izquierda
+			for (int repeticiones = 0; repeticiones < posiciones; repeticiones++) {
+				int aux = a[0];
+				for (int i = 0; i < (a.length - 1); i++) {
+					a[i] = a[i + 1];
+				}
+				a[a.length - 1] = aux;
+			}			
+		}
+	}
+	
+}
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque03/EjE_PicosDeUnArray.java

@@ -0,0 +1,68 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque03;
+
+import tutorialJava.UtilsArrays;
+
+public class EjE_PicosDeUnArray {
+
+	public static void main(String[] args) {
+		int a[] = new int[] {7, 3, 20, 4, 6, 0, 5};
+		
+		int picos[] = picosDeArray(a);
+		UtilsArrays.imprimeArray(picos);
+	}
+
+	
+	public static int[] picosDeArray(int a[]) {
+		int contPicos = 0;
+		
+		for (int i = 0; i < a.length; i++) {
+			if (i == 0 && a[0] > a[1]) {
+				contPicos++;
+			}
+			else {
+				if (i == (a.length - 1) && a[a.length-1] > a[a.length-2]) {
+					contPicos++;
+				}
+				else {
+					if (a[i] > a[i-1] && a[i] > a[i+1]) {
+						contPicos++;
+					}
+				}
+			}
+		}
+		
+		int picos[] = new int[contPicos];
+		int indiceArrayPicos = 0;
+		for (int i = 0; i < a.length; i++) {
+			if (i == 0 && a[0] > a[1]) {
+				picos[indiceArrayPicos] = a[i];
+				indiceArrayPicos++;
+			}
+			else {
+				if (i == (a.length - 1) && a[a.length-1] > a[a.length-2]) {
+					picos[indiceArrayPicos] = a[i];
+					indiceArrayPicos++;
+				}
+				else {
+					if (a[i] > a[i-1] && a[i] > a[i+1]) {
+						picos[indiceArrayPicos] = a[i];
+						indiceArrayPicos++;
+					}
+				}
+			}
+		}
+		
+		return picos;
+	}
+}
+
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque03/Ejemplo04_OrdenacionSeleccion.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo4_Arrays.ejercicios.bloque03;
+
+import tutorialJava.UtilsArrays;
+
+public class Ejemplo04_OrdenacionSeleccion {
+
+	public static void main (String args[]) {
+//		int a[] = new int[] {33, 17, 72, 11, 35};
+		int a[] = new int[100];
+		int posicionMenor, aux;
+		
+		UtilsArrays.inicializaArray(a, 0, 100);
+		UtilsArrays.imprimeArray(a);
+		
+		for (int i = 0; i < a.length; i++) {
+			// Asumo que el menor es la posición de i
+			posicionMenor = i;
+
+			// Busco la posición REAL del menor, a partir de la posición i
+			for (int j = i + 1; j < a.length; j++) {
+				if (a[posicionMenor] > a[j]) {
+					posicionMenor = j;
+				}
+			}
+
+			// Intercambio
+			aux = a[i];
+			a[i] = a[posicionMenor];
+			a[posicionMenor] = aux;	
+		}		
+		
+		UtilsArrays.imprimeArray(a);
+		
+	}
+}
+
+
+
+