|
| 1 | +public class llonardo798 { |
| 2 | + |
| 3 | + public static void main(String[] args) { |
| 4 | + // 1. Tipos de operadores por categoría: |
| 5 | + |
| 6 | + // 1. Operadores Aritméticos: |
| 7 | + |
| 8 | + int suma = 5 + 5 + 5; // Suma |
| 9 | + System.out.println(suma); // Imprime 15 |
| 10 | + int resta = 10 - 5; // Resta |
| 11 | + System.out.println(resta); // Imprime 5 |
| 12 | + int multiplicacion = 5 * 5; // Multiplicación |
| 13 | + System.out.println(multiplicacion); // Imprime 25 |
| 14 | + int division = 10 / 2; // División |
| 15 | + System.out.println(division); // Imprime 5 |
| 16 | + int modulo = 10 % 3; // Módulo (resto o sobrante de la división) 10 % 3 = 1 se puede considerar como |
| 17 | + // 10/3 = 3 y sobra 1 |
| 18 | + System.out.println(modulo); // Imprime 1 |
| 19 | + suma++; // Incremento en 1 |
| 20 | + System.out.println(suma); // Imprime 16 |
| 21 | + resta--; // Decremento en 1 |
| 22 | + System.out.println(resta); // Imprime 4 |
| 23 | + |
| 24 | + // 2. Operadores de Asignación: |
| 25 | + |
| 26 | + String nombre = "Leonardo"; // Asignación simple: = |
| 27 | + System.out.println(nombre); // Imprime "Leonardo" |
| 28 | + suma += 5; // Suma y asignación |
| 29 | + System.out.println(suma); // Imprime 21 |
| 30 | + resta -= 5; // Resta y asignación |
| 31 | + System.out.println(resta); // Imprime -1 |
| 32 | + multiplicacion *= 5; // Multiplicación y asignación |
| 33 | + System.out.println(multiplicacion); // Imprime 125 |
| 34 | + division /= 2; // División y asignación |
| 35 | + System.out.println(division); // Imprime 2 - el valorse recorta en el decimal porque es int y no float |
| 36 | + modulo %= 3; // Módulo y asignación |
| 37 | + System.out.println(modulo); // Imprime 1 porque 10 % 3 = 0.99999... y se redondea a 1 por ser int |
| 38 | + |
| 39 | + // 3. Operadores de Comparación: |
| 40 | + |
| 41 | + boolean igual = 5 == 5; // Igual a |
| 42 | + System.out.println(igual); // Imprime true - 5 es igual a 5 |
| 43 | + boolean diferente = 5 != 5; // Diferente de |
| 44 | + System.out.println(diferente); // Imprime false - 5 no es diferente de 5 |
| 45 | + boolean mayor = 10 > 5; // Mayor que |
| 46 | + System.out.println(mayor); // Imprime true - 10 es mayor que 5 |
| 47 | + boolean menor = 5 < 10; // Menor que |
| 48 | + System.out.println(menor); // Imprime true - 5 es menor que 10 |
| 49 | + boolean mayorIgual = 10 >= 5; // Mayor o igual que |
| 50 | + System.out.println(mayorIgual); // Imprime true - 10 es mayor o igual que 5 |
| 51 | + boolean menorIgual = 5 <= 10; // Menor o igual que |
| 52 | + System.out.println(menorIgual); // Imprime true - 5 es menor o igual que 10 |
| 53 | + |
| 54 | + // 4. Operadores Lógicos: |
| 55 | + |
| 56 | + boolean and = true && true; // AND lógico - ambas condiciones deben ser verdaderas |
| 57 | + System.out.println(and); // Imprime true |
| 58 | + boolean or = true || false; // OR lógico - al menos una condición debe ser verdadera |
| 59 | + System.out.println(or); // Imprime true |
| 60 | + boolean not = !true; // NOT lógico - niega la condición |
| 61 | + System.out.println(not); // Imprime false |
| 62 | + |
| 63 | + // 5. Operadores Bit a Bit (a nivel de bits): |
| 64 | + |
| 65 | + // AND bit a bit & - valida los numeros bit a bit como un AND. |
| 66 | + // Si compara 0 y 0 = 0, 0 y 1 = 0, 1 y 0 = 0, 1 y 1 = 1 |
| 67 | + int a = 60; // En binario: 0011 1100 |
| 68 | + int b = 13; // En binario: 0000 1101 |
| 69 | + int resultadoAnd = a & b; |
| 70 | + System.out.println(resultadoAnd); // Resultado: 0000 1100 (Imprime 12 en decimal) |
| 71 | + // Explicación: |
| 72 | + // 0011 1100 - Valor a |
| 73 | + // 0000 1101 - Valor b |
| 74 | + // --------- & (AND) |
| 75 | + // 0000 1100 - 12 en decimal |
| 76 | + |
| 77 | + // OR bit a bit: | - valida los numeros bit a bit como un OR. |
| 78 | + // Si compara 0 y 0 = 0, 0 y 1 = 1, 1 y 0 = 1, 1 y 1 = 1 |
| 79 | + int resultadoOr = a | b; |
| 80 | + System.out.println(resultadoOr); // Resultado: 0011 1101 (Imprime 61 en decimal) |
| 81 | + // Explicación: |
| 82 | + // 0011 1100 |
| 83 | + // 0000 1101 |
| 84 | + // --------- | (OR) |
| 85 | + // 0011 1101 - 61 en decimal |
| 86 | + |
| 87 | + // XOR bit a bit: ^ - valida los numeros bit a bit como un XOR. |
| 88 | + // Si compara 0 y 0 = 0, 0 y 1 = 1, 1 y 0 = 1, 1 y 1 = 0 |
| 89 | + int resultadoXor = a ^ b; |
| 90 | + System.out.println(resultadoXor); // Resultado: 0011 0001 (Imprime 49 en decimal) |
| 91 | + // Explicación: |
| 92 | + // 0011 1100 |
| 93 | + // 0000 1101 |
| 94 | + // --------- ^ (XOR) |
| 95 | + // 0011 0001 |
| 96 | + |
| 97 | + // Complemento bit a bit: ~ - cambia los bits de 0 a 1 y de 1 a 0 |
| 98 | + a = 60; // En binario: 0011 1100 |
| 99 | + int resultadoComplemento = ~a; |
| 100 | + System.out.println(resultadoComplemento); // Resultado: 1100 0011 (Imprime 195 en decimal) |
| 101 | + // Explicación: |
| 102 | + // 0011 1100 - Valor a = 60 |
| 103 | + // --------- ~ (Complemento) |
| 104 | + // 1100 0011 - 195 en decimal |
| 105 | + |
| 106 | + // Desplazamiento a la izquierda: << - desplaza los bits a la izquierda |
| 107 | + a = 33; // En binario: 0010 0001 |
| 108 | + int resultadoDesplazamientoIzquierda = a << 2; |
| 109 | + System.out.println(resultadoDesplazamientoIzquierda); // Resultado: 1000 0100 (132 en decimal) |
| 110 | + // Mover el número 33 dos posiciones a la izquierda. |
| 111 | + // moviendo los bits en 1 dos posiciones a la izquierda |
| 112 | + // Explicación: |
| 113 | + // 0010 0001 - Valor a = 33 |
| 114 | + // --------- << (Desplazamiento a la izquierda) |
| 115 | + // 1000 0100 - 132 en decimal |
| 116 | + |
| 117 | + // Desplazamiento a la derecha: >> - desplaza los bits a la derecha |
| 118 | + a = 33; // En binario: 0010 0001 |
| 119 | + int resultadoDesplazamientoDerecha = a >> 2; |
| 120 | + System.out.println(resultadoDesplazamientoDerecha); // Resultado: 0000 1000 (8 en decimal) |
| 121 | + // Mover el número 33 dos posiciones a la derecha. |
| 122 | + // moviendo los bits en 1 dos posiciones a la derecha |
| 123 | + // Explicación: |
| 124 | + // 0010 0001 - Valor a = 33 |
| 125 | + // --------- >> (Desplazamiento a la derecha) |
| 126 | + // 0000 1000 - 8 en decimal |
| 127 | + |
| 128 | + // Desplazamiento a la derecha sin signo: >> - desplaza los bits a la derecha |
| 129 | + // sin importar si el numero es positivo o negativo para lo cual agrerga 0 a |
| 130 | + // la izquierda |
| 131 | + a = -10; // En binario (complemento a dos): 1111 1111 1111 1111 1111 1111 1111 0110 |
| 132 | + int resultadoDesplazamientoIzquierdaSinSigno = a >>> 1; |
| 133 | + System.out.println(resultadoDesplazamientoIzquierdaSinSigno); // Resultado: 0111 1111 1111 1111 1111 1111 1111 |
| 134 | + // 1011 (2147483643 en decimal) |
| 135 | + |
| 136 | + // 6. Operadores Ternarios: |
| 137 | + |
| 138 | + // Operador condicional ternario: ?: |
| 139 | + a = 5; |
| 140 | + int edad = (a == 10) ? 10 : 20; // Si a es igual a 10, entonces edad es igual a 10, de lo contrario, edad es |
| 141 | + // igual a 20 |
| 142 | + System.out.println(edad); // Imprime 20 |
| 143 | + |
| 144 | + // 7. Otros Operadores: |
| 145 | + |
| 146 | + String nombreCompleto = "Leonardo " + "Aedo"; // Concatenación de cadenas |
| 147 | + System.out.println(nombreCompleto); // Imprime "Leonardo Aedo" |
| 148 | + byte[] bytes = nombreCompleto.getBytes(); // Operador de acceso a miembros de clase "." |
| 149 | + System.out.println(bytes); // Imprime [B@6d06d69c |
| 150 | + int[] numeros = { 1, 3, 7, 2, 5 }; |
| 151 | + int numero = numeros[2]; // Operador de acceso a elementos de arreglo "[]" |
| 152 | + System.out.println(numero); // Imprime 7 |
| 153 | + double numeroDecimal = 10.5; |
| 154 | + int numeroEntero = (int) numeroDecimal; // Operador de cast (conversión de tipos) |
| 155 | + System.out.println(numeroEntero); // Imprime 10 - se recorta el decimal porque se convierte de double a int |
| 156 | + boolean esInstancia = nombre instanceof String; // Operador instanceof (verifica si un objeto es una instancia |
| 157 | + // de una clase) esInstancia devuelve true si nombre es una instancia de la |
| 158 | + // clase String, de lo contrario, devuelve false |
| 159 | + System.out.println(esInstancia); // Imprime true ya que nombre es una instancia de la clase String |
| 160 | + |
| 161 | + // DIFICULTAD EXTRA - Crea un programa que imprima por consola todos los números |
| 162 | + // comprendidos entre 10 y 55 (incluidos), pares, y que no son ni el 16 ni |
| 163 | + // múltiplos de 3. |
| 164 | + System.out.println("Números pares entre 10 y 55 que son pares, que no son 16 y no es múltiplos de 3:"); |
| 165 | + for (int i = 10; i < 56; i++) { |
| 166 | + if ( i % 2 == 0 && i != 16 && i % 3 != 0) { |
| 167 | + System.out.println(i); |
| 168 | + } |
| 169 | + } |
| 170 | + } |
| 171 | + |
| 172 | +} |
0 commit comments