1) Declara dos variables numéricas (con el valor que desees), muestra

por consola la suma, resta, multiplicación, división y módulo (resto de la

división).

Spoiler
public class OperacionesApp {

public static void main(String[] args) {

1
2
//Declaramos las variables
3
int num1=10;
4
int num2=5;
5
6
/*Realizamos las operaciones.
7
* Tambien lo podemos guardar el resultado en
8
variables. */
9
10
System.out.println("El resultado de la suma es "+
11
(num1+num2));
12
13
System.out.println("El resultado de la resta es "+
14
(num1-num2));
15
16
System.out.println("El resultado de la multiplicación es
17
"+(num1*num2));
18
19
System.out.println("El resultado de la división es "+
20
(num1/num2));
}
}
2) Declara 2 variables numéricas (con el valor que desees), he indica
cual es mayor de los dos. Si son iguales indicarlo también. Ves
cambiando los valores para comprobar que funciona.

Spoiler
1 public class NumeroMayorApp {
2
3 public static void main(String[] args) {
4
5 //Declaramos las variables
6 int num1=30;
7 int num2=15;
8
9 //Hacemos la comprobación
10 if (num1>=num2){
11 //If anidado
12 if(num1==num2){
 System.out.println("Los numeros
"+num1+" y "+num2+" son iguales");
13
}else{
14
System.out.println("El número "+num1+"
15
es mayor que el número "+num2);
16
}
17
}else{
18
System.out.println("El número "+num2+" es
19
mayor que el número "+num1);
20
}
21
}
}
3) Declara un String que contenga tu nombre, después muestra un
mensaje de bienvenida por consola. Por ejemplo: si
introduzco «Fernando», me aparezca «Bienvenido Fernando».

Spoiler
1 public class SaludoApp {
2
3 public static void main(String[] args) {
4
5 String nombre="Fernando";
6
7 System.out.println("Bienvenido "+nombre);
8 }
9}
4) Modifica la aplicación anterior, para que nos pida el nombre que
queremos introducir (recuerda usar JOptionPane).

Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2 public class SaludoPersonalizadoApp {
3
4 public static void main(String[] args) {
5
6 //Nos aparece un cuadro de dialogo
7 Scanner sc = new Scanner(System.in);
8 System.out.println("Introduce tu nombre");
9 String nombre=sc.nextLine();
10
11 System.out.println("Bienvenido "+nombre);
12 }
13
14 }
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class SaludoPersonalizadoApp {
 3
public static void main(String[] args) {
4
5
//Nos aparece un cuadro de dialogo
6
String
7
nombre=JOptionPane.showInputDialog("Introduce tu nombre");
8
9
System.out.println("Bienvenido "+nombre);
10
}
11
}
5) Haz una aplicación que calcule el área de un círculo(pi*R 2). El radio se
pedirá por teclado (recuerda pasar de String a double
con Double.parseDouble). Usa la constante PI y el método pow de
Math.

Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2 public class AreaCirculoApp {
3
public static void main(String[] args) {
4
5
Scanner sc = new Scanner(System.in);
6
System.out.println("Introduce un radio");
7
sc.useLocale(Locale.US);
8
double radio=sc.nextDouble();
9
10
//Formula area circulo, usamos algunos de los metodos de
11
Math
12
double area=Math.PI*Math.pow(radio, 2);
13
14 System.out.println("El area del circulo es "+area);
15 }
16 }
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class AreaCirculoApp {
3
4 public static void main(String[] args) {
5
6 String texto=JOptionPane.showInputDialog("Introduce
7 un radio");
8 //Pasamos el String a double
9 double radio=Double.parseDouble(texto);
10
11 //Formula area circulo, usamos algunos de los metodos
12 de Math
13 double area=Math.PI*Math.pow(radio, 2);
14 System.out.println("El area del circulo es "+area);
15 }
}

6) Lee un número por teclado e indica si es divisible entre 2 (resto = 0).

Si no lo es, también debemos indicarlo.
Spoiler
— Versión con Scanner

import java.util.Scanner;
public class DivisibleApp {
1
2
public static void main(String[] args) {
3
4
Scanner sc = new Scanner(System.in);
5
System.out.println("Introduce un numero");
6
int numero=sc.nextInt();
7
8
//Comprobamos si es divisible entre 2, es decir, si el resto de
9
la division es 0
10
if (numero%2==0){
11
System.out.println("El numero "+numero+" es divisible
12
entre 2");
13
}else{
14
System.out.println("El numero "+numero+" no es divisible
15
entre 2");
16
}
17
}
}
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class DivisibleApp {
3
4 public static void main(String[] args) {
5
6 String texto=JOptionPane.showInputDialog("Introduce
7 un numero");
8 //Pasamos el String a int
9 int numero=Integer.parseInt(texto);
10
11 //Comprobamos si es divisible entre 2, es decir, si el
12 resto de la division es 0
13 if (numero%2==0){
14 System.out.println("El numero "+numero+" es
15 divisible entre 2");
16 }else{
17 System.out.println("El numero "+numero+" no es
divisible entre 2");
 }
}
}
7) Lee un número por teclado y muestra por consola, el carácter al que
pertenece en la tabla ASCII. Por ejemplo: si introduzco un 97, me
muestre una a.

Spoiler
import javax.swing.JOptionPane;
1
public class CodigoASCIIApp {
2
3
public static void main(String[] args) {
4
5
String texto=JOptionPane.showInputDialog("Introduce
6
un codigo de la tabla ASCII");
7
//Pasamos el String a int
8
int codigo=Integer.parseInt(texto);
9
10
//Pasamos el codigo a caracter
11
char caracter=(char)codigo;
12
13
System.out.println(caracter);
14
}
15
}
8) Modifica el ejercicio anterior, para que en lugar de pedir un número,
pida un carácter (char) y muestre su código en la tabla ASCII.

Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2
3 public class CaracterASCIIApp {
4
5 public static void main(String[] args) {
6
7 Scanner sc = new Scanner(System.in);
8 System.out.println("Introduce un caracter ASCII");
9 char caracter = sc.next().charAt(0);
10
11 //Pasamos el caracter a codigo
12 int codigo = (int) caracter;
13
14 System.out.println(codigo);
15 }
16 }
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class CaracterASCIIApp {
 3
public static void main(String[] args) {
4
5
6
String texto=JOptionPane.showInputDialog("Introduce un
7
caracter ASCII");
8
//Pasamos el String a char con el metodo charAt
9
char caracter=texto.charAt(0);
10
11
//Pasamos el caracter a codigo
12
int codigo=(int)caracter;
13
14
System.out.println(codigo);
15
}
16
}
9) Lee un número por teclado que pida el precio de un producto (puede
tener decimales) y calcule el precio final con IVA. El IVA sera una
constante que sera del 21%.

Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2
3 public class PrecioProductoApp {
4
5 public static void main(String[] args) {
6
7 Scanner sc = new Scanner(System.in);
8 System.out.println("Introduce un caracter ASCII");
9 char caracter = sc.next().charAt(0);
10
11 //Pasamos el caracter a codigo
12 int codigo = (int) caracter;
13
14 System.out.println(codigo);
15 }
16 }
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class PrecioProductoApp {
3
4 public static void main(String[] args) {
5
6 //Declaramos una constante
7 final double IVA=0.21;
8
9 String texto=JOptionPane.showInputDialog("Introduce
10 el precio de un producto");
 //Pasamos el String a double
11
double precio=Double.parseDouble(texto);
12
13
//Obtenemos el precio final (precio+(precio*IVA))
14
double precioFinal=precio+(precio*IVA);
15
16
System.out.println(precioFinal);
17
}
18
}

10) Muestra los números del 1 al 100 (ambos incluidos). Usa un bucle
while.
Spoiler
1 public class MuestraNumWhileApp {
2
3 public static void main(String[] args) {
4
5 int num=1;
6
7 //Definimos el bucle, incluye el 100
8 while (num<=100){
9 System.out.println(num);
10 //Incrementamos num
11 num++;
12 }
13 }
14 }
11) Haz el mismo ejercicio anterior con un bucle for.

Spoiler
1 public class MuestraNumForApp {
2
3 public static void main(String[] args) {
4
5 //Definimos el bucle, incluye el 100
6 for (int num=1;num<=100;num++){
7 System.out.println(num);
8 }
9 }
10 }
12) Muestra los números del 1 al 100 (ambos incluidos) divisibles entre 2
y 3. Utiliza el bucle que desees.

Spoiler
— Con While
1 public class DivisiblesWhileApp {
2
3 public static void main(String[] args) {
4
5 int num=1;
6
7 //Definimos el bucle, incluye el 100
8 while (num<=100){
9 if (num%2==0 || num%3==0){
10 System.out.println(num);
11 }
12 //Incrementamos num
13 num++;
14 }
15 }
16 }
— Con For

1 public class DivisiblesForApp {

2
3 public static void main(String[] args) {
4
5 //Definimos el bucle, incluye el 100
6 for (int num=1;num<=100;num++){
7 //Comprobamos si es divisible entre 2 o 3
8 if (num%2==0 || num%3==0){
9 System.out.println(num);
10 }
11 }
12 }
13 }
13) Realiza una aplicación que nos pida un número de ventas a
introducir, después nos pedirá tantas ventas por teclado como número
de ventas se hayan indicado. Al final mostrara la suma de todas las
ventas. Piensa que es lo que se repite y lo que no.

Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2 public class VentasApp {
3
4 public static void main(String[] args) {
5
6 Scanner sc = new Scanner(System.in);
7 System.out.println("Introduce el número de ventas");
8 int numVentas=sc.nextInt();
9
10 /*Declaramos una variable para sumar las ventas,
11 * si lo declaramos dentro del bucle, no podriamos
12 * acceder fuera del bucle a la suma de las ventas.
13 * Esto es por el ámbito.
14 */
15 int sumaVentas=0;
 for (int i=0;i<numVentas;i++){
16
//indico el numero de venta
17
System.out.println("Introduce el precio de la venta "+
18
(i+1));
19
int venta=sc.nextInt();
20
21
//Acumulamos el valor de la venta
22
sumaVentas=sumaVentas+venta;
23
}
24
25
System.out.println(sumaVentas);
26
}
27
}
— Versión con JOptionPane

import javax.swing.JOptionPane;
1 public class VentasApp {
2
3 public static void main(String[] args) {
4
5 String texto=JOptionPane.showInputDialog("Introduce
6 el número de ventas");
7
8 //Pasamos el String a int
9 int numVentas=Integer.parseInt(texto);
10
11 /*Declaramos una variable para sumar las ventas,
12 * si lo declaramos dentro del bucle, no podriamos
13 * acceder fuera del bucle a la suma de las ventas.
14 * Esto es por el ámbito.
15 */
16 int sumaVentas=0;
17 for (int i=0;i<numVentas;i++){
18 //indico el numero de venta
19 texto=JOptionPane.showInputDialog("Introduce
20 el precio de la venta"+(i+1));
21 int venta=Integer.parseInt(texto);
22
23 //Acumulamos el valor de la venta
24 sumaVentas=sumaVentas+venta;
25 }
26
27 System.out.println(sumaVentas);
28 }
}
14) Realiza una aplicación que nos calcule una ecuación de segundo
grado. Debes pedir las variables a, b y c por teclado y comprobar antes
que el discriminante (operación en la raíz cuadrada). Para la raíz
cuadrada usa el método sqlrt de Math. Te recomiendo que uses
mensajes de traza.
Spoiler
— Versión con Scanner

import java.util.Scanner;
1 public class Ecuacion2GradoApp {
2
3 public static void main(String[] args) {
4
5 Scanner sc = new Scanner(System.in);
6 System.out.println("Introduce el valor de a");
7 int a=sc.nextInt();
8 System.out.println("Introduce el valor de b");
9 int b=sc.nextInt();
10 System.out.println("Introduce el valor de c");
11 int c=sc.nextInt();
12
13 double discriminante=Math.pow(b, 2)-(4*a*c);
14
15 //Mensaje de traza
16 System.out.println(">>"+discriminante);
17
18 if (discriminante>0){
19 //Tambien se puede hacer por parte si lo ves más facil
20 //recuerda que debes tener en cuenta la prioridad de
21 elementos
22 double x1=((b*(-1))+Math.sqrt(discriminante))/(2*a);
23 double x2=((b*(-1))-Math.sqrt(discriminante))/(2*a);
24
25 System.out.println("El valor de x1 es "+x1+" y el valor de
26 x2 es "+x2);
27 }else{
28 System.out.println("El discriminante es negativo");
29 }
30 }
}
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class Ecuacion2GradoApp {
3
4 public static void main(String[] args) {
5
6 String textoA=JOptionPane.showInputDialog("Introduce
7 el valor de a");
8 int a=Integer.parseInt(textoA);
9 String textoB=JOptionPane.showInputDialog("Introduce
10 el valor de b");
11 int b=Integer.parseInt(textoB);
12 String textoC=JOptionPane.showInputDialog("Introduce
13 el valor de c");
 int c=Integer.parseInt(textoC);

double discriminante=Math.pow(b, 2)-(4*a*c);

//Mensaje de traza
14
System.out.println(">>"+discriminante);
15
16
if (discriminante>0){
17
//Tambien se puede hacer por parte si lo ves más
18
facil
19
//recuerda que debes tener en cuenta la prioridad
20
de elementos
21
double
22
x1=((b*(-1))+Math.sqrt(discriminante))/(2*a);
23
double
24
x2=((b*(-1))-Math.sqrt(discriminante))/(2*a);
25
26
System.out.println("El valor de x1 es "+x1+" y el
27
valor de x2 es "+x2);
28
}else{
29
System.out.println("El discriminante es
negativo");
}
}
}
15) Lee un número por teclado y comprueba que este numero es mayor
o igual que cero, si no lo es lo volverá a pedir (do while), después
muestra ese número por consola.

Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2 public class Ejercicio_DiscoDurodeRoer_Basicos_15_Scanner {
3
4 public static void main(String[] args) {
5
6 /* Declaramos la varible ya que sino no podemos usarla
7 * en el while por el tema de ámbito
8 */
9 int codigo;
10 Scanner sc = new Scanner(System.in);
11 do{
12 System.out.println("Introduce un numero mayor que 0");
13 codigo=sc.nextInt();
14 }while(codigo<=0);
15
16 System.out.println(codigo);
17 }
18 }
— Versión con JOptionPane

import javax.swing.JOptionPane;
public class ComprobacionApp {
1
2
public static void main(String[] args) {
3
4
/* Declaramos la varible ya que sino no podemos
5
usarla
6
* en el while por el tema de ámbito
7
*/
8
int codigo;
9
do{
10
String
11
texto=JOptionPane.showInputDialog("Introduce un numero mayor
12
que 0");
13
codigo=Integer.parseInt(texto);
14
}while(codigo<=0);
15
16
System.out.println(codigo);
17
}
}

16) Escribe una aplicación con un String que contenga una contraseña
cualquiera. Después se te pedirá que introduzcas la contraseña, con 3
intentos. Cuando aciertes ya no pedirá mas la contraseña y mostrara un
mensaje diciendo «Enhorabuena». Piensa bien en la condición de salida
(3 intentos y si acierta sale, aunque le queden intentos).

Spoiler
—Versión con Scanner

1 import java.util.Scanner;
2 public class ContraseñaApp {
3
4 public static void main(String[] args) {
5
6 Scanner sc = new Scanner(System.in);
7 String contraseña="eureka";
8
9 final int INTENTOS = 3;
10
11 //Esta variable booleana, nos controlara que en caso de que
12 acierte la condicion cambie
13 boolean acierto=false;
14
15 String password;
 for (int i=0;i<INTENTOS && !acierto;i++){
16 System.out.println("Introduce una contraseña");
17 password = sc.next();
18
19 //Comprobamos si coincide, no usamos ==, usamos el
20 metodo equals
21 if (password.equals(contraseña)){
22 System.out.println("Enhorabuena, acertaste");
23 acierto=true;
24 }
25 }
26 }
}
— Versión con JOptionPane

import javax.swing.JOptionPane;
1 public class ContraseñaApp {
2
public static void main(String[] args) {
3
4
String contraseña="eureka";
5
6
final int INTENTOS = 3;
7
8
//Esta variable booleana, nos controlara que en caso de que
9
acierte la condicion cambie
10
boolean acierto=false;
11
12
String password;
13
for (int i=0;i<3 && !acierto;i++){
14
password=JOptionPane.showInputDialog("Introduce una
15
contraseña");
16
17 //Comprobamos si coincide, no usamos ==, usamos el
18 metodo equals
19 if (password.equals(contraseña)){
20 System.out.println("Enhorabuena, acertaste");
21 acierto=true;
22 }
23 }
24 }
}
17) Crea una aplicación que nos pida un día de la semana y que nos
diga si es un dia laboral o no. Usa un switch para ello.

Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2 public class DiaApp {
3
4 public static void main(String[] args) {
5
6 Scanner sc = new Scanner(System.in);
7
8 System.out.println("Introduce un dia de la semana");
9 String dia = sc.next();
10
11 switch(dia){
12 case "lunes":
13 case "martes":
14 case "miercoles":
15 case "jueves":
16 case "viernes":
17 System.out.println("Es un dia laboral");
18 break;
19 case "sabado":
20 case "domingo":
21 System.out.println("Es un dia festivo");
22 default:
23 System.out.println("Introduce un dia de la semana");
24 }
25 }
26 }
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class DiaApp {
3
4 public static void main(String[] args) {
5
6 String dia=JOptionPane.showInputDialog("Introduce un
7 dia de la semana");
8
9 switch(dia){
10 case "lunes":
11 case "martes":
12 case "miercoles":
13 case "jueves":
14 case "viernes":
15 System.out.println("Es un dia laboral");
16 break;
17 case "sabado":
18 case "domingo":
19 System.out.println("Es un dia festivo");
20 default:
21 System.out.println("Introduce un dia de la
22 semana");
23 }
}
 }
18) Pide por teclado dos número y genera 10 números aleatorios entre
esos números. Usa el método Math.random para generar un número
entero aleatorio (recuerda el casting de double a int).

Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2 public class GeneraNumApp {
3
public static void main(String[] args) {
4
5
Scanner sc = new Scanner(System.in);
6
System.out.println("Introduce el primero numero");
7
int num1=sc.nextInt();
8
9
System.out.println("Introduce el segundo numero");
10
int num2=sc.nextInt();
11
12 for (int i=0;i<10;i++){
13 //Generamos un numero aleatorio
14 int numAleatorio=(int)Math.floor(Math.random()*(num1-
15 num2)+num2);
16 System.out.println(numAleatorio);
17 }
18 }
19 }
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class GeneraNumApp {
3
4 public static void main(String[] args) {
5
6 String texto1=JOptionPane.showInputDialog("Introduce
7 el primero numero");
8 int num1=Integer.parseInt(texto1);
9
10 String texto2=JOptionPane.showInputDialog("Introduce
11 el segundo numero");
12 int num2=Integer.parseInt(texto2);
13
14 for (int i=0;i<10;i++){
15 //Generamos un numero aleatorio
16 int
17 numAleatorio=(int)Math.floor(Math.random()*(num1-
18 num2)+num2);
System.out.println(numAleatorio);
}
 }
}
19) Pide por teclado un número entero positivo (debemos controlarlo) y
muestra el número de cifras que tiene. Por ejemplo: si introducimos
1250, nos muestre que tiene 4 cifras. Tendremos que controlar si tiene
una o mas cifras, al mostrar el mensaje.
Spoiler
— Versión con Scanner

import java.util.Scanner;
1 public class CuentaCifrasApp {
2
public static void main(String[] args) {
3
4
Scanner sc = new Scanner(System.in);
5
int numero=0;
6
do{
7
System.out.println("Introduce un numero");
8
numero=sc.nextInt();
9
}while(numero<0); int contador=0; for (int
10
i=numero;i>0;i/=10){
11
//Incrementamos el contador
12
contador++;
13
}
14
15
//Controlamos en el caso de que haya una cifra o mas
16
if (contador==1){
17
System.out.println("El numero "+numero+ " tiene
18
"+contador+" cifra");
19
}else{
20
System.out.println("El numero "+numero+ " tiene
21
"+contador+" cifras");
22
}
23
24 }
}
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class CuentaCifrasApp {
3
4 public static void main(String[] args) {
5
6 int numero=0;
7 do{
8 String
9 texto=JOptionPane.showInputDialog("Introduce un numero");
10 numero=Integer.parseInt(texto);
11 }while(numero<0); int contador=0; for (int
12 i=numero;i>0;i/=10){
 //Incrementamos el contador
contador++;
13 }
14
15 //Controlamos en el caso de que haya una cifra o mas
16 if (contador==1){
17 System.out.println("El numero "+numero+ "
18 tiene "+contador+" cifra");
19 }else{
20 System.out.println("El numero "+numero+ "
21 tiene "+contador+" cifras");
22 }
23
}
}

20) Pide un número por teclado e indica si es un número primo o no. Un

número primo es aquel solo puede dividirse entre 1 y si mismo. Por
ejemplo: 25 no es primo, ya que 25 es divisible entre 5, sin embargo, 17
si es primo.
Un buen truco para calcular la raíz cuadrada del numero e ir
comprobando que si es divisible desde ese numero hasta 1.
NOTA: Si se introduce un numero menor o igual que 1, directamente es
no primo.
Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2
3 public class PrimoApp {
4
5 public static void main(String[] args) {
6
7 Scanner sc = new Scanner(System.in);
8 System.out.println("Introduce un numero");
9 int numero = sc.nextInt();
10
11 //Un numero negativo, el 0 y el 1, son directamente no
12 primos.
13 if (numero <= 1) {
14 System.out.println("El numero " + numero + " no es
15 primo");
16 } else {
17
18 //Hacemos un casting para que nos devuelva un numero
19 entero
20 int raiz = (int) Math.sqrt(numero);
21 int contador = 0;
22
23 //Contamos el numero de divisibles
 for (int i = raiz; i > 1; i--) {
if (numero % i == 0) {
contador++;
24
}
25
}
26
27
/*Segun el numero de divisibles, sabemos si es primo o no
28
* Si es primo el contador sera 0
29
*/
30
//Mensaje de traza
31
System.out.println(">>" + contador);
32
33
if (contador < 1) {
34
System.out.println("El numero " + numero + " es
35
primo");
36
} else {
37
System.out.println("El numero " + numero + " no es
38
primo");
39
}
40
41
}
}
}
— Version con JOptionPane

1 import javax.swing.JOptionPane;
2
3 public class Ejercicio_DiscoDurodeRoer_Basicos_20 {
4
5 public static void main(String[] args) {
6
7 String texto = JOptionPane.showInputDialog("Introduce un
8 numero");
9 int numero = Integer.parseInt(texto);
10
11 //Un numero negativo, el 0 y el 1, son directamente no
12 primos.
13 if (numero <= 1) {
14 System.out.println("El numero " + numero + " no es
15 primo");
16 } else {
17
18 //Hacemos un casting para que nos devuelva un numero
19 entero
20 int raiz = (int) Math.sqrt(numero);
21 int contador = 0;
22
23 //Contamos el numero de divisibles
24 for (int i = raiz; i > 1; i--) {
25 if (numero % i == 0) {
 contador++;
}
}
26
27 /*Segun el numero de divisibles, sabemos si es primo o no
28 * Si es primo el contador sera 0
29 */
30 //Mensaje de traza
31 System.out.println(">>" + contador);
32
33 if (contador < 1) {
34 System.out.println("El numero " + numero + " es
35 primo");
36 } else {
37 System.out.println("El numero " + numero + " no es
38 primo");
39 }
40
}
}
}
21) Muestra los números primos entre 1 y 100.
Spoiler
— Versión con Scanner

1 import java.util.Scanner;
2
3 public class MuestraPrimosApp {
4
5 public static void main(String[] args) {
6
7 for (int i=1;i<=100;i++){
8 //Hacemos un casting para que nos devuelva un numero
9 entero
10 int raiz=(int)Math.sqrt(i);
11 int contador=0;
12
13 //Hacemos otro bucle para contar los divisibles
14 for (int j=raiz;j>1;j--){
15 if (i%j==0){
16 contador++;
17 }
18 }
19
20 /*Segun el numero de divisibles, sabemos si es primo o no
21 * Si es primo el contador sera 0
22 */
23
24 if (contador<1){
25 System.out.println(i);
 }
26
27
}
28
}
29
}
— Versión con JOptionPane

public class MuestraPrimosApp {

1 public static void main(String[] args) {

2
3 for (int i=1;i<=100;i++){
4 //Hacemos un casting para que nos devuelva un
5 numero entero
6 int raiz=(int)Math.sqrt(i);
7 int contador=0;
8
9 //Hacemos otro bucle para contar los divisibles
10 for (int j=raiz;j>1;j--){
11 if (i%j==0){
12 contador++;
13 }
14 }
15
16 /*Segun el numero de divisibles, sabemos si es
17 primo o no
18 * Si es primo el contador sera 0
19 */
20
21 if (contador<1){
22 JOptionPane.showMessageDialog(null, "El
23 numero "+i+" es primo", "Primo",
24 JOptionPane.INFORMATION_MESSAGE);
25 }
26
27 }
}
}
22) Del siguiente String «La lluvia en Sevilla es una maravilla» cuenta
cuantas vocales hay en total (recorre el String con charAt).

Spoiler
1 public class Principal {
2
3 public static void main(String[] args) {
4
5 String cadena="La lluvia en Sevilla es una maravilla";
6
7 int contador=0;
8 for (int i=0;i<cadena.length();i++){
 9 //Comprobamos si el caracter es una vocal
10 if(cadena.charAt(i)=='a' ||
11 cadena.charAt(i)=='e' ||
12 cadena.charAt(i)=='i' ||
13 cadena.charAt(i)=='o' ||
14 cadena.charAt(i)=='u'){
15 contador++;
16 }
17 }
18
19 System.out.println("Hay "+contador+" vocales");
20 }
21 }
23) Reemplaza todas las a del String anterior por una e.
Spoiler
1 public class CambioLetrasApp {
2
3 public static void main(String[] args) {
4
5 String cadena="La lluvia en Sevilla es una maravilla";
6
7 //Aviso, de esta forma no modifica el String original
8 System.out.print(cadena.replace('a', 'e'));
9
10 }
11 }
24) Recorre el String del ejercicio 22 y transforma cada carácter a su
código ASCII. Muestralos en linea recta, separados por un espacio entre
cada carácter.

Spoiler
1 public class ListaCaracteresApp {
2
3 public static void main(String[] args) {
4
5 String cadena="La lluvia en Sevilla es una maravilla";
6
7 for (int i=0;i<cadena.length();i++){
8 //Hacemos un casting para convertir el char a int
9 System.out.print((int)cadena.charAt(i)+" ");
10 }
11 }
12 }
25) Crea una aplicación llamada CalculadoraPolacaInversaApp, nos
pedirá 2 operandos (int) y un signo aritmético (String), según este último
se realizara la operación correspondiente. Al final mostrara el resultado
en un cuadro de dialogo.
Los signos aritméticos disponibles son:

 +: suma los dos operandos.

  -: resta los operandos.

 *: multiplica los operandos.

 /: divide los operandos, este debe dar un resultado con decimales

(double)

 ^: 1º operando como base y 2º como exponente.

 %: módulo, resto de la división entre operando1 y operando2.

Spoiler
— Versión con Scanner

1 import java.util.Locale;
2 import java.util.Scanner;
3 public class CalculadoraPolacaInversaApp {
4
5 public static void main(String[] args) {
6
7 Scanner sc = new Scanner(System.in);
8 sc.useLocale(Locale.US);
9 //no importa que sean int o double
10 double operando1;
11 double operando2;
12 double resultado=0;
13
14 //Nos pide los operandos y el signo de operacion
15 System.out.println("Escribe el operando 1");
16 operando1=sc.nextDouble();
17
18 System.out.println("Escribe el codigo de operacion");
19 String operacion = sc.next();
20
21 System.out.println("Escribe el operando 2");
22 operando2=sc.nextDouble();
23
24 //segun el codigo de operacion, haremos una u otra accion
25 switch (operacion){
26 case "+":
27 resultado=operando1+operando2;
28 break;
29 case "-":
30 resultado=operando1-operando2;
31 break;
32 case "*":
33 resultado=operando1*operando2;
34 break;
35 case "/":
36 resultado=operando1/operando2;
37 break;
38 case "^":
 resultado=(int)Math.pow(operando1, operando2);
39
break;
40
case "%":
41
resultado=operando1%operando2;
42
break;
43
}
44
45
System.out.println( operando1+" "+operacion+"
46
"+operando2+" = "+resultado);
47
48
}
49
}
— Versión con JOptionPane

1 import javax.swing.JOptionPane;
2 public class CalculadoraPolacaInversaApp {
3
4 public static void main(String[] args) {
5
6 //no importa que sean int o double
7 double operando1;
8 double operando2;
9 double resultado=0;
10
11 //Nos pide los operandos y el signo de operacion
12 String texto=JOptionPane.showInputDialog("Escribe el
13 operando 1");
14 operando1=Integer.parseInt(texto);
15
16 String
17 operacion=JOptionPane.showInputDialog("Escribe el codigo de
18 operacion");
19
20 String texto2=JOptionPane.showInputDialog("Escribe el
21 operando 2");
22 operando2=Integer.parseInt(texto2);
23
24 //segun el codigo de operacion, haremos una u otra
25 accion
26 switch (operacion){
27 case "+":
28 resultado=operando1+operando2;
29 break;
30 case "-":
31 resultado=operando1-operando2;
32 break;
33 case "*":
34 resultado=operando1*operando2;
35 break;
36 case "/":
 resultado=operando1/operando2;
break;
case "^":
resultado=(int)Math.pow(operando1,
37
operando2);
38
break;
39
case "%":
40
resultado=operando1%operando2;
41
break;
42
}
43
44
JOptionPane.showMessageDialog(null, operando1+"
45
"+operacion+" "+operando2+" = "+resultado);

}
}
26) Realizar la suma del 1 al numero que indiquemos, este debe ser
mayor que 1.

Spoiler
1 import java.util.Scanner;
2
3 public class Ejercicio_26 {
4
5 public static void main(String[] args) {
6
7 Scanner sn=new Scanner(System.in);
8
9
10 System.out.println("Inserta un numero entero mayor que 1");
11 int num;
12
13 do{
14 //Pedimos el primer número
15 num=sn.nextInt();
16
17 if(num<=1){
18 System.out.println("Error. No has introducido un valor
19 correcto."
20 + "Vuelve a intentarlo");
21 }
22
23 }while(!(num>=1)); //condición para salir
24
25 int suma=0;
26
27 //Realizamos la suma
28 for(int contador=1;contador<=num;contador++){
29 suma+=contador;
 }
30
31
System.out.println("La suma es: "+suma);
32
33
}
34
35
}
27)

Crear una aplicación que nos permite insertar números hasta que
insertemos un -1. Calcular el numero de números introducidos.

Spoiler
import java.util.Scanner;
1
2
public class Ejercicio_27 {
3
4
public static void main(String[] args) {
5
6
//Pedimos el numero
7
Scanner sn=new Scanner(System.in);
8
int num=sn.nextInt();
9
10
int contador=0;
11
12
//Hasta que no se introduzca -1 no se sale
13
while(num!=-1){
14
15
contador++;
16
17
num=sn.nextInt(); //Pedimos de nuevo el número
18
19
}
20
21
System.out.println("Fin, se ha introducido "+contador+"
22
numeros");
23
24
}
25
26
}
28) Eliminar los espacios de una frase pasada por consola por el usuario.

Spoiler
1 import javax.swing.JOptionPane;
2
3 public class Ejercicio_basicos_DDR_28 {
4
5 public static void main(String[] args) {
6
 String texto=JOptionPane.showInputDialog(null,
7 "Inserta una frase",
8 "Inserción",
9 JOptionPane.INFORMATION_MESSAG
10 E);
11
12 //usado para almacenar el texto final
13 String texto_sin_espacios="";
14
15 char caracterActual;
16
17 //recorro el array
18 for(int i=0;i<texto.length();i++){
19
20 caracterActual=texto.charAt(i);
21
22 //Cuando es un espacio no lo copia a la cadena
23 if(caracterActual!=' '){
24 texto_sin_espacios+=String.valueOf(caracterActual);
25 }
26
27 }
28
29 JOptionPane.showMessageDialog(null,
30 "La frase tiene sin espacios es
31 "+texto_sin_espacios,
32 "Resultado",
33 JOptionPane.INFORMATION_MESSAGE);
34
35 }
36
}
29) Pedir al usuario que nos escriba frases de forma infinita hasta que
insertemos una cadena vacia. Mostrar la cadena resultante

Spoiler
1 import javax.swing.JOptionPane;
2
3 public class Ejercicio_basicos_DDR_29 {
4
5 public static void main(String[] args) {
6
7 String texto=JOptionPane.showInputDialog(null,
8 "Introduce un texto, cadena vacia
9 para terminar",
10 "Introducir texto",
11
12 JOptionPane.INFORMATION_MESSAGE);
13
 String cadenaResultante="";
14
//Mientras no este vacio la cadena escrita continuo
15
while(!texto.isEmpty()){
16
17
//Concatenamos el texto
18
cadenaResultante+=texto;
19
20
//Reintroducimos de nuevo una cadena
21
texto=JOptionPane.showInputDialog(null,
22
"Introduce un texto, cadena vacia para
23
terminar",
24
"Introducir texto",
25
JOptionPane.INFORMATION_MESSAGE);
26
27
}
28
29
JOptionPane.showMessageDialog(null,
30
cadenaResultante,
31
"Resultado",
32
JOptionPane.INFORMATION_MESSAGE);
33
34
}
35
}
30)

Convertir una frase a mayúsculas o minúsculas, que daremos opción a

que el usuario lo pida y mostraremos el resultado por pantalla.

Spoiler
— Version 1

1 import javax.swing.JOptionPane;
2
3 public class Ejercicio_basicos_DDR_30_v1 {
4
5 public static void main(String[] args) {
6
7 String texto=JOptionPane.showInputDialog(null,
8 "Por favor, introduce una frase",
9 "Introducción",
10 JOptionPane.INFORMATION_MESSAG
11 E);
12
13 String cadenaResultante="";
14
15 //true = Lo pasamos todo a mayusculas
16 //false= Lo pasamos todo a minusculas
17 boolean isMayus;
18 final int DIFERENCIA=32;
19
20 String[] opciones={"Mayusculas", "Minusculas"};
21 int eleccion=JOptionPane.showOptionDialog(null,
22 "Elige tu opcion",
23 "Eleccion",
24 JOptionPane.YES_NO_OPTION,
25 JOptionPane.QUESTION_MESSAGE,
26 null,
27 opciones,
28 opciones[0]);
29
30
31 isMayus= (eleccion==JOptionPane.YES_OPTION);
32
33 char caracterActual;
34
35 for(int i=0;i<texto.length();i++){
36
37 //obtenemos el caracter de la pos i
38 caracterActual=texto.charAt(i);
39
40 if(isMayus){
41
42 //Si esta entre esos valores, lo cambia a mayucula
43 // Puedes sustituir 97 por 'a' y asi con todos
44 if(caracterActual>=97 && caracterActual<=122){
45 cadenaResultante+=(char)(caracterActual-
46 DIFERENCIA);
47 }else{
48 //Si no es un caracter alfabetico en minuscula, lo
49 agregamos
50 // sin hacerle nada
51 cadenaResultante+=caracterActual;
52 }
53
54 }else{
55
56 //Si esta entre esos valores, lo cambia a minuscula
57 // Puedes sustituir 65 por 'A' y asi con todos
58 if(caracterActual>=65 && caracterActual<=90){
59 cadenaResultante+=(char)
60 (caracterActual+DIFERENCIA);
61 }else{
62 //Si no es un caracter alfabetico en minuscula, lo
63 agregamos
64 // sin hacerle nada
65 cadenaResultante+=caracterActual;
66 }
 }
}
67
68
//Mostramos la cadena resultante
69
JOptionPane.showMessageDialog(null,
70
cadenaResultante,
71
"Resultado",
72
JOptionPane.INFORMATION_MESSAGE);
73
74
}

}
— Version 2

1 import javax.swing.JOptionPane;
2
3 /**
4 *Ejercicio 30 version 2 Básicos
5 * @author Discoduroderoer
6 */
7 public class Ejercicio_basicos_DDR_30_v2 {
8
9 public static void main(String[] args) {
10
11 String texto=JOptionPane.showInputDialog(null,
12 "Por favor, introduce una frase",
13 "Introducción",
14 JOptionPane.INFORMATION_MESSAG
15 E);
16
17 String cadenaResultante;
18
19 //true = Lo pasamos todo a mayusculas
20 //false= Lo pasamos todo a minusculas
21 boolean isMayus;
22
23 int eleccion=JOptionPane.showConfirmDialog(null,
24 "¿Quieres que se pase a mayusculas?",
25 "Eleccion",
26 JOptionPane.YES_NO_OPTION);
27
28 isMayus= (eleccion==JOptionPane.YES_OPTION);
29
30 //Segun lo elegido, lo transformaremos a mayuscula o
31 minuscula
32 if(isMayus){
33 cadenaResultante=texto.toUpperCase();
34 }else{
35 cadenaResultante=texto.toLowerCase();
 }
36
37 //Mostramos el mensaje resultante
38 JOptionPane.showMessageDialog(null,
39 cadenaResultante,
40 "Resultado",
41 JOptionPane.INFORMATION_MESSAGE);
42
43 }
44
}
31) Mostrar la longitud de una cadena.

Spoiler
public class Ejercicio_basicos_DDR_31 {
1
2
public static void main(String[] args) {
3
4
String cadena="Hola mundo";
5
6
System.out.println("La cadena tiene "+cadena.length()+"
7
caracteres");
8
9
}
10
11
}
32) Pedir dos palabras por teclado, indicar si son iguales.

Spoiler
1 import java.util.Scanner;
2
3 public class Ejercicio_basicos_DDR_32 {
4
5 public static void main(String[] args) {
6
7 //Creamos un scanner para leer
8 Scanner sn = new Scanner(System.in);
9
10 //Pedimos las palabras
11 System.out.println("Escribe la palabra 1");
12 String palabra1 = sn.next();
13
14 System.out.println("Escribe la palabra 2");
15 String palabra2 = sn.next();
16
17 //Comparamos con el método equals
18 //Con equalsIgnoreCase, no considera las mayusculas
19 if(palabra1.equals(palabra2)){
20 System.out.println("Las palabras son iguales");
21 }else{
22 System.out.println("Las palabras no son iguales");
23 }
24
25 }
33) Dada una cadena, extraer la cuarta y quinta letra usando el método
substring.

Spoiler
public class Ejercicio_basicos_DDR_33 {
1
2 public static void main(String[] args) {
3
4 String cadena= "Hola mundo";
5
6 //CUIDADO: es 3 porque empieza en 0 las cadenas(cuarta
7 letra)
8 //el 5 es porque siempre hay que sumarle uno, ya que sino no
9 mostraria lo que deseamos (quinta letra)
10 String subcadena = cadena.substring(3, 5);
11
12 System.out.println(subcadena);
13
14 }
15
}
34)

Dada una frase, separarlo en palabras.

Spoiler
1 import java.util.Scanner;
2
3 public class Ejercicio_basicos_DDR_18 {
4
5 public static void main(String[] args) {
6
7 Scanner sn = new Scanner(System.in);
8 //Hace que podamos escribir espacios en la frase y coja todo
9 el String
10 sn.useDelimiter("\n");
11
12 System.out.println("Escribe una frase");
13 String frase=sn.next();
14
15 //Divido la frase en palabras
16 String palabras[] = frase.split(" ");
17
18 for(int i=0;i<palabras.length;i++){
 System.out.println(palabras[i]);
19
}
20
21
}
22
23
}
35) Crea un enum con los días de la semana, pide un día de la semana e
indica si es laboral o no (en el main).

Spoiler
— Dia de la semana

1 public enum DiasSemana {

2 LUNES,
3 MARTES,
4 MIERCOLES,
5 JUEVES,
6 VIERNES,
7 SABADO,
8 DOMINGO;
9
10 }
— Main

1 import java.util.Scanner;
2
3 public class Ejercicio_basicos_DDR_35 {
4
5 public static void main(String[] args) {
6
7 Scanner sn = new Scanner(System.in);
8 System.out.println("Escribe un dia de la semana");
9 String dia = sn.next();
10
11 DiasSemana diaS = DiasSemana.valueOf(dia.toUpperCase());
12
13 switch(diaS){
14 case LUNES:
15 case MARTES:
16 case MIERCOLES:
17 case JUEVES:
18 case VIERNES:
19 System.out.println("El dia "+diaS.name().toLowerCase()
20 +" es laborable");
21 break;
22 case SABADO:
23 case DOMINGO:
24 System.out.println("El dia "+diaS+" no es laborable");
25 break;
26
 }
27
28
}
29
30
}
36) Modifica el anterior enum para indicar que es día laborable
directamente (usar toString).

Spoiler
— DiaSemana

public enum DiasSemana {

1 LUNES(true),
2 MARTES(true),
3 MIERCOLES(true),
4 JUEVES(true),
5 VIERNES(true),
6 SABADO(false),
7 DOMINGO(false);
8
9 private boolean laborable;
10
11 private DiasSemana(boolean laborable){
12 this.laborable = laborable;
13 }
14
15 @Override
16 public String toString() {
17
18 if(laborable){
19 return "El dia "+ this.name().toLowerCase() +" es
20 laborable";
21 }else{
22 return "El dia "+ this.name().toLowerCase() +" no es
23 laborable";
24 }
25
26 }
27
28
29
}
— Main

1 import java.util.Scanner;
2
3 public class Ejercicio_basicos_DDR_36 {
4
5 public static void main(String[] args) {
6
 7 Scanner sn = new Scanner(System.in);
8 System.out.println("Escribe un dia de la semana");
9 String dia = sn.next();
10
11 DiasSemana diaS = DiasSemana.valueOf(dia.toUpperCase());
12
13 System.out.println(diaS.toString());
14
15 }
16
17 }
37) Crea el enum Mes, que contenga como parametros el
orden(1,2,3,etc) y el numero de dias (febrero tendra 28 dias siempre).

Estos datos pueden pedirse por separado, asi que tienes que hacer sus
respectivos get. No son necesarios los setters.

Create un arrays de Mes (mirate la funcion values), pide un numero por

teclado e indica que meses tienen ese numero de dias (toda su
informacion).

Por ejemplo, si escribes un 28, este te devolvera la informacion de

FEBRERO.

Spoiler
— Mes

1 public enum Mes {

2 ENERO(1,31),
3 FEBRERO(2,28),
4 MARZO(3,31),
5 ABRIL(4,30),
6 MAYO(5,31),
7 JUNIO(6,30),
8 JULIO(7,31),
9 AGOSTO(8,31),
10 SEPTIEMBRE(9,30),
11 OCTUBRE(10,31),
12 NOVIEMBRE(11,30),
13 DICIEMBRE(12,31);
14
15 private int orden;
16 private int numDias;
17
18 private Mes(int orden, int numDias){
19
20 this.orden=orden;
21 this.numDias=numDias;
22
23 }
24
public int getOrden() {
25
return orden;
26
}
27
28
public int getNumDias() {
29
return numDias;
30
}
31
32
@Override
33
public String toString() {
34
return "El mes "+this.name().toLowerCase()+" es el mes
35
"+orden+"º y tiene "+numDias+" dias";
36
}
37
38
39
40
41
}
— Principal

1 import java.util.Scanner;
2
3 public class Ejercicio_basicos_DDR_24 {
4
5 public static void main(String[] args) {
6
7 Scanner sn = new Scanner(System.in);
8
9 Mes[] meses = Mes.values();
10
11 System.out.println("Escribe un numero de dias");
12 int dias = sn.nextInt();
13
14 for(int i=0;i<meses.length;i++){
15
16 if(meses[i].getNumDias()==dias){
17 System.out.println(meses[i].toString());
18 }
19
20 }
21
22 }
38) Pedir números al usuario y cuando el usuario meta un -1 se
terminará el programa.
Al terminar, mostrará lo siguiente:
– mayor numero introducido
– menor numero introducido
– suma de todos los numeros
– suma de los numeros positivos
– suma de los numeros negativos
– media de la suma (la primera que pido)

El número -1 no contara como número.

Spoiler
1 import java.util.Scanner;
2
3 public class Ejercicio_basicos_DDR_25 {
4
5 public static void main(String[] args) {
6
7 //Variables necesarias
8 int numeroUsuario=0;
9 int menor=0;
10 int mayor=0;
11 int suma=0;
12 double media;
13 int contador=-1;
14 int sumaPositivos=0;
15 int sumaNegativos=0;
16
17 //Creamos el Scanner
18 Scanner sn = new Scanner(System.in);
19
20 do{
21
22 //Comprobamos si el numero es menor
23 //que el actual menor
24 if(menor>numeroUsuario){
25 menor = numeroUsuario;
26 }
27
28 //Comprobamos si el numero es mayor
29 //que el actual mayor
30 if(mayor<numeroUsuario){
31 mayor=numeroUsuario;
32 }
33
34 //Suma el numero y lo acumulamos
35 suma+=numeroUsuario;
36
37 //Si el numero es positivo, suma a la variable de los
38 positivos
39 // y sino a la de los negativos
40 if(numeroUsuario>=0){
41 sumaPositivos+=numeroUsuario;
42 }else{
43 sumaNegativos+=numeroUsuario;
 }
44
//aumento el contador
45
contador++;
46
47
//pido un numero al usuario
48
System.out.println("Introduce un numero");
49
numeroUsuario = sn.nextInt();
50
51
//Cuando el usuario ponga un -1, saldremos
52
//Se puede usar un while normal
53
}while(numeroUsuario!=-1);
54
55
//Calculamos la media
56
media = (double) suma / contador;
57
58
//Mostramos los valores
59
System.out.println("El menor es: "+menor);
60
System.out.println("El mayor es: "+mayor);
61
System.out.println("La suma es: "+suma);
62
System.out.println("La suma de los positivos es:
63
"+sumaPositivos);
64
System.out.println("La suma de los negativos es:
65
"+sumaNegativos);
66
System.out.println("La media es: "+media);
67
68
}
69
}
39)

Realiza un reloj digital que muestre la hora sin parar.

Debe esperar un segundo real para darle mas realismo.

Spoiler
1 public class Ejercicio_basicos_DDR_26 {
2
3 public static void main(String[] args) throws
4 InterruptedException {
5
6 //Variables
7 int horas = 0, minutos = 0, segundos = 0;
8
9 while (true) {
10
11 //Mostrar
12 //Si es menor que 10, escribimos un cero delante
13 if (horas < 10) {
 System.out.print("0");
14
}
15
16
System.out.print(horas + ":");
17
18
if (minutos < 10) {
19
System.out.print("0");
20
}
21
22
System.out.print(minutos + ":");
23
24
if (segundos < 10) {
25
System.out.print("0");
26
}
27
28
//salto de linea
29
System.out.println(segundos);
30
31
//Aumentar el tiempo
32
segundos++;
33
34
//Comprobar el tiempo
35
if (segundos == 60) {
36
//reinicio los segundos
37
segundos = 0;
38
//aumento los minutos
39
minutos++;
40
if (minutos == 60) {
41
//Reinicio los minutos
42
minutos = 0;
43
//Aumento las horas
44
horas++;
45
if (horas == 24) {
46
//Reinicio las horas
47
horas = 0;
48
}
49
}
50
}
51
52
Thread.sleep(1000);
53
54
}
55
56
}
57
58
}
También os dejamos videos de nuestro canal de YouTube para que veais
como se hace paso a paso.