Procesos
ProcessBuilder
: Clase que permite crear y controlar procesos en Kotlin.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import java.io.BufferedReader import java.io.InputStreamReader fun main() { val processBuilder = ProcessBuilder("ping", "-c", "4", "google.com") val process = processBuilder.start() // Leer la salida del proceso val reader = BufferedReader(InputStreamReader(process.inputStream)) var line: String? while (reader.readLine().also { line = it } != null) { println(line) } } |
Runtime
: Clase que permite interactuar con el entorno de ejecución y controlar procesos en tiempo de ejecución.
1 2 3 4 5 6 7 8 9 10 11 |
fun main() { val runtime = Runtime.getRuntime() val process = runtime.exec("ping -c 4 google.com") // Leer la salida del proceso val reader = BufferedReader(InputStreamReader(process.inputStream)) var line: String? while (reader.readLine().also { line = it } != null) { println(line) } } |
Process
: Representa un proceso en ejecución y proporciona métodos para controlarlo.
1 2 3 4 |
fun main() { val process = ProcessBuilder("echo", "Hello, World!").start() process.waitFor() // Espera a que el proceso termine } |
ProcessHandle
: Obtener información sobre procesos en ejecución y controlarlos.
1 2 3 4 5 6 7 |
fun main() { val process = ProcessBuilder("sleep", "10").start() val processHandle = process.toHandle() println("Process ID: ${processHandle.pid()}") println("Is Alive: ${processHandle.isAlive}") } |
Hilos
Thread
: Clase que permite crear y controlar hilos en Kotlin.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
class MiThread : Thread() { override fun run() { for (i in 1..5) { println("Hilo ejecutándose: $i") sleep(500) } } } fun main() { val hilo = MiThread() hilo.start() } |
Runnable
: Interfaz funcional que define un hilo de ejecución en Kotlin.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class MiRunnable : Runnable { override fun run() { for (i in 1..5) { println("Hilo ejecutándose desde Runnable: $i") Thread.sleep(500) } } } fun main() { val miRunnable = MiRunnable() val thread = Thread(miRunnable) thread.start() } |
Coroutine
: Mecanismo de concurrencia que permite realizar tareas asíncronas y no bloqueantes en Kotlin.
1 2 3 4 5 6 7 8 9 10 |
import kotlinx.coroutines.* fun main() = runBlocking { launch { for (i in 1..5) { println("Corutina ejecutándose: $i") delay(500) } } } |
ExecutorService
: Esta interfaz permite administrar hilos y ejecutar tareas de manera concurrente.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import java.util.concurrent.Executors fun main() { val executor = Executors.newFixedThreadPool(2) executor.submit { for (i in 1..5) { println("Tarea 1: $i") Thread.sleep(500) } } executor.submit { for (i in 1..5) { println("Tarea 2: $i") Thread.sleep(500) } } executor.shutdown() } |
CompletableFuture
: Clase que facilita la programación asincrónica y la combinación de múltiples futuros en Kotlin.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import java.util.concurrent.CompletableFuture fun main() { val future = CompletableFuture.supplyAsync { Thread.sleep(500) "Resultado de la tarea" } future.thenAccept { println("Resultado: $it") } // Espera a que el futuro termine future.join() } |
Red
URL
: Clase que permite trabajar con URL y realizar operaciones de red como abrir conexiones HTTP.
1 2 3 4 5 6 7 8 9 |
import java.net.URL fun main() { val url = URL("http://www.example.com") val connection = url.openConnection() val inputStream = connection.getInputStream() val content = inputStream.bufferedReader().use { it.readText() } println(content) } |
URLConnection
: Clase abstracta que establece una conexión a un recurso a través de una URL.
1 2 3 4 5 6 7 8 9 10 11 |
import java.net.URL import java.net.HttpURLConnection fun main() { val url = URL("http://www.example.com") val connection = url.openConnection() as HttpURLConnection connection.requestMethod = "GET" val inputStream = connection.inputStream val content = inputStream.bufferedReader().use { it.readText() } println(content) } |
Socket
: Clase que representa un socket de red y permite la comunicación entre procesos a través de la red.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import java.net.ServerSocket import java.net.Socket fun main() { val serverSocket = ServerSocket(1234) println("Esperando conexión...") val clientSocket = serverSocket.accept() println("Conexión aceptada de ${clientSocket.inetAddress}") val out = clientSocket.getOutputStream() out.write("Hola, cliente!".toByteArray()) out.flush() clientSocket.close() serverSocket.close() } |
SocketChannel
: Una clase para operaciones de socket no bloqueantes en Kotlin.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import java.nio.channels.ServerSocketChannel import java.nio.channels.SocketChannel fun main() { val serverChannel = ServerSocketChannel.open() serverChannel.bind(java.net.InetSocketAddress(1234)) println("Esperando conexión...") val clientChannel = serverChannel.accept() println("Conexión aceptada de ${clientChannel.remoteAddress}") val buffer = java.nio.ByteBuffer.allocate(1024) clientChannel.read(buffer) buffer.flip() println("Mensaje recibido: ${String(buffer.array(), buffer.position(), buffer.remaining())}") clientChannel.close() serverChannel.close() } |
DatagramSocket
: Para trabajar con datagramas y sockets UDP en Kotlin.
1 2 3 4 5 6 7 8 9 10 11 12 |
import java.net.DatagramPacket import java.net.DatagramSocket import java.net.InetAddress fun main() { val socket = DatagramSocket() val message = "Hola, UDP!" val buffer = message.toByteArray() val packet = DatagramPacket(buffer, buffer.size, InetAddress.getByName("localhost"), 1234) socket.send(packet) socket.close() } |
Seguridad
Cipher
: Clase que proporciona funcionalidad de cifrado y descifrado para encriptar y desencriptar datos.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import javax.crypto.Cipher import javax.crypto.KeyGenerator import javax.crypto.SecretKey fun main() { val keyGen = KeyGenerator.getInstance("AES") keyGen.init(128) val secretKey = keyGen.generateKey() val cipher = Cipher.getInstance("AES") cipher.init(Cipher.ENCRYPT_MODE, secretKey) val encrypted = cipher.doFinal("Mensaje secreto".toByteArray()) cipher.init(Cipher.DECRYPT_MODE, secretKey) val decrypted = cipher.doFinal(encrypted) println("Mensaje desencriptado: ${String(decrypted)}") } |
SecureRandom
: Clase que genera números aleatorios criptográficamente seguros.
1 2 3 4 5 6 7 |
import java.security.SecureRandom fun main() { val secureRandom = SecureRandom() val randomNumber = secureRandom.nextInt() println("Número aleatorio seguro: $randomNumber") } |
KeyStore
: Clase que almacena claves criptográficas y certificados de seguridad.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import java.security.KeyStore import java.security.KeyStoreException import java.security.cert.CertificateException import java.security.cert.CertificateFactory import java.io.FileInputStream fun main() { val keyStore = KeyStore.getInstance("JKS") keyStore.load(FileInputStream("miKeystore.jks"), "password".toCharArray()) val certificate = keyStore.getCertificate("miAlias") println("Certificado: $certificate") } |
KeyPairGenerator
: Para generar pares de claves criptográficas (pública y privada) en Kotlin.
1 2 3 4 5 6 7 8 9 10 11 |
import java.security.KeyPairGenerator import java.security.KeyPair fun main() { val keyPairGen = KeyPairGenerator.getInstance("RSA") keyPairGen.initialize(2048) val keyPair: KeyPair = keyPairGen.generateKeyPair() println("Clave pública: ${keyPair.public}") println("Clave privada: ${keyPair.private}") } |
MessageDigest
: Clase que proporciona funciones de resumen criptográfico, como SHA-256 o MD5, para procesar datos.
1 2 3 4 5 6 7 8 |
import java.security.MessageDigest fun main() { val digest = MessageDigest.getInstance("SHA-256") val hash = digest.digest("Mensaje a hashear".toByteArray()) val hexString = hash.joinToString("") { "%02x".format(it) } println("Hash SHA-256: $hexString") } |
SSLContext
: Para configurar conexiones seguras con el protocolo SSL/TLS en Kotlin.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import javax.net.ssl.SSLContext import javax.net.ssl.TrustManagerFactory import javax.net.ssl.KeyManagerFactory import java.security.KeyStore fun main() { val keyStore = KeyStore.getInstance("JKS").apply { load(FileInputStream("miKeystore.jks"), "password".toCharArray()) } val keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()) keyManagerFactory.init(keyStore, "password".toCharArray()) val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()) trustManagerFactory.init(keyStore) val sslContext = SSLContext.getInstance("TLS") sslContext.init(keyManagerFactory.keyManagers, trustManagerFactory.trustManagers, null) println("SSLContext configurado con TLS") } |