Tema 9

Máster Executive Big Data And Artificial Intelligence
Tema 9
Excepciones
Archivos de texto
El manejo de archivos es una forma de almacenar la información obtenida en un archivo. Scala proporciona
paquetes desde los que podemos crear, abrir, leer y escribir los archivos. Para escribir en un archivo en Scala,
tomamos prestado java.io._ de Java porque no tenemos una clase para escribir en un archivo, en la biblioteca
estándar de Scala.
CREAR UN NUEVO ARCHIVO
java.io.File define clases e interfaces para los archivos de acceso, sistemas de archivos y atributos de JVM.
File(String pathname) convierte la cadena de parámetros en un nombre de ruta abstracto, creando una nueva
instancia de archivo.
ESCRIBIR EN EL ARCHIVO
java.io.PrintWriter incluye todos los métodos de impresión incluidos en PrintStream.
Escribir en un archivo
import java.io._
object main {
def main(args: Array[String]):Unit= {
val writer = new PrintWriter(new File("test.txt" ))
writer.write("Hola Scala")
writer.close()
}
}
Cuando guardemos y ejecutemos este programa, creará un archivo llamado test.txt en el directorio actual, donde se
encuentra el programa. El siguiente es el contenido de ese archivo:
Hola Scala
Lectura del contenido del archivo
La lectura de archivos es realmente simple. Puede usar la clase Source de Scala y su objeto complementario para
leer archivos. El siguiente es el ejemplo que le muestra cómo leer desde el archivo "test.txt" que creamos
anteriormente.
Ejemplo:
import scala.io.Source
object main {
def main(args: Array[String]):Unit={
println("A continuación se muestra el contenido leído.:" )
var test=Source.fromFile("test.txt")
test.foreach {
SCALA
print
}
test.close()
}
}
Salida:
A continuación, se muestra el contenido leído.
H
o
l
a
S
c
a
l
a
Ejemplo:
object main {
println("A continuación se muestra el contenido leído.:" )
var test = Source.fromFile("test.txt") test.getLines().foreach{x

=>println(x)} test.close()
}
}
Salida:
A continuación se muestra el contenido leído. :
Hola Scala
Excepciones
Una excepción es un evento no deseado o inesperado,

que se produce durante la ejecución de un programa,
es decir, en tiempo de ejecución. Estos eventos
cambian el control de flujo del programa en ejecución.
Estas son situaciones que no son demasiado peligrosas
y pueden ser manejadas por el programa.
Jerarquía de excepciones
Todos los tipos de excepción y errores son subclases

de la clase Throwable, que es la clase base de la
jerarquía. Una rama está encabezada por Exception.
Esta clase se utiliza para condiciones excepcionales que los programas de usuario deben detectar.
SCALA
NullPointerException es un ejemplo de una excepción de este tipo. Otra rama, Error son utilizados por el sistema
de tiempo de ejecución Java(JVM)para indicar errores que tienen que ver con el propio entorno en tiempo de
ejecución (JRE). StackOverflowError es un ejemplo de tal error.
¿Cómo funciona Scala Exception?
Las excepciones en scala funcionan de la misma manera que en C++ o Java. Cuando se produce una excepción,
digamos una ArithmeticException como se muestra en el ejemplo anterior se anula la operación actual y el
sistema en tiempo de ejecución busca un controlador de excepciones que puede aceptar una
ArithmeticException. El control se reanuda con el controlador más interno. Si no existe dicho controlador, el
programa finaliza.
Las excepciones de lanzamiento que producen una excepción. Se ve igual que en Java. creamos un objeto de
excepción y luego lo lanzamos mediante la palabra clave throw.
Sintaxis:
throw new ArithmeticException
Cosas importantes para recordar:
- Throw expression tiene un tipo de valor devuelto Nothing.

- Throw es la palabra clave que se usa para lanzar una excepción, mientras que throws es la palabra clave que
se usa para declarar una excepción.
- El bloque Catch utiliza la coincidencia de patrones para manejar las excepciones.
Excepciones Try-Catch
La construcción Try-Catch es diferente en Scala que en Java, Try-

Catch en Scala es una expresión. Scala hacer uso de la
coincidencia de patrones en la cláusula catch. Supongamos que
tenemos que implementar una serie de código que puede
producir una excepción y si queremos controlar esa excepción,
entonces debemos utilizar el segmento Try-Catch ya que nos
permite probar todas y cada tipo de excepción en un solo bloque,
necesitamos escribir una serie de instrucciones case en catch
como Scala usa la coincidencia con el fin de analizar y controlar
las excepciones.
Sintaxis:
try{
}catch{
SCALA
Ejemplo:
object Arithmetic{
try{
val result = 11/0
}
catch{
case x: ArithmeticException =>
{
// Mostrar esto si se encuentra una excepción
println("Excepción: un número no es divisible por
cero.")
}
}
}
}
Salida:
Excepción: un número no es divisible por cero.
Try-Catch y Finally
El bloque finally ejecuta el código dentro de su cuerpo sin importar qué excepción ocurra en el código.
Garantiza la ejecución del código en todas las circunstancias, excepto en caso de cambios desastrosos.
Ejemplo #3:
class MyClass{
def divide(a:Int, b:Int) = {
try{
a/b
}catch{
case e: ArithmeticException => println(e)
}finally{
println("Bloque Finally ejecutado")
}
println("Código ejecutando...")
}
}
object MainObject{
def main(args:Array[String]):Unit={
var e = new MyClass()
e.divide(10,0)
}
}
Salida:
java.lang.ArithmeticException: / by zero
Bloque Finally ejecutado
Código ejecutando...
SCALA
Ejemplo #1
Enunciado: Vamos a crear una función que devolverá un tipo de dato char, y
pondremos a prueba el bloque try-catch
Pasos: El bloque try-catch se usa para capturar excepciones, en este caso lo vamos a
aplicar a una función.
 Creamos la función, esta recibirá dos parámetros: uno de tipo string y otro de
tipo entero.
 Dentro de esta simplemente vamos a devolver el char de la posición obtenido
con charAt().
 Y en el caso de que no se encuentre la posición esta generará una excepción y la
trataremos con try-catch en el método principal.
object ejemplo {
def obtenerChar(str:String, p:Int):Char={
var pos = str.charAt(p)
pos
}
def main(args: Array[String]): Unit = {

try{
var str1 = "Scala"
var pos1 = -7
println("Char obtenido: "+obtenerChar(str1,pos1))
}catch{
case se: StringIndexOutOfBoundsException => println("Índice
no válido...")
}
}
}
Ejemplo #2
Enunciado: Vamos a usar el método try-catch en ficheros y matrices.
Pasos: El bloque try-catch se usa para capturar excepciones, en este caso lo vamos a
aplicar a ficheros y matrices.
 Vamos a importar librerías que nos ayudaran con el manejo de ficheros, vamos a
intentar a abrir archivos inexistentes.
 Al intentar abrir archivos que no se encuentran dónde estamos especificando,
este nos genera una excepción y la vamos a tratar con try-catch.
 Luego vamos a crear matrices, y intentar ingresar índices no válidos estas
también nos generan excepciones y vamos a tratarlas con try-catch.
 Por último, también vamos a usar la sentencia finally, esta se ejecutará pase lo
que pase en el try-catch, esta deberá ir después de esta última.
import java.io._
SCALA
object ejemplo {
try{
println("Abriendo archivo de texto...")
var lectura = Source.fromFile("prueba.txt")
}catch{
case fn: FileNotFoundException => println("No se encontro el
archivo...")
}
//Matriz
try{
var m= Array(1,2,3,4,5)
println("Imprimiendo matriz:")
for(i <- 0 until m.length){
println(m(i))
}
}catch{
case ai:ArrayIndexOutOfBoundsException => println("Índice no
válido...")
}finally{
println("Código ejecutado...")
}
}
}
UpperBound
Scala tiene algunas restricciones en los parámetros de tipo o variable de tipo, es decir, (tipo de límite) y el límite
superior es uno de ellos.
Mediante la implementación de límites de tipo, podemos explicar las

restricciones de una variable de tipo, estos tipos enlazados restringe los
valores definidos de las variables de tipo y revela más detalles sobre el
miembro de estos tipos. El límite superior se define en los parámetros
de tipo.
Descripción:
Aquí T es un parámetro de tipo y S es un tipo. Al declarar el límite

superior como [T <: S], significa que este parámetro de tipo T debe ser
el mismo que S o un subtipo de S.
Sintaxis:
[T <: Demo]
Donde, 'T' es un parámetro de tipo y 'S' es un tipo"[T <: S]" significa que este parámetro de tipo T debe ser igual que
S o Sub-Type de S.
Vamos a entender el límite superior con el ejemplo.
Ejemplo:
class Padre
class Hija1 extends Padre
SCALA
class Ejemplo{
// Declaration of upper bound
def display [T <: Hija1](d : T):Unit={
println(d)
}
}
object main{
val obj1 = new Padre()

val obj2 = new Hija1()
val ejemplo = new ComputerSciencePortal
//ejemplo.display(obj1)
ejemplo.display(obj2)
}
}
Salida:
Hija1@67f639d3
Hija2@6253c26
Aquí, Upper bound se define en la clase Ejemplo, y Padre es la super clase de Hija1 por lo que no se acepta.
Ejemplo #2:
class Director
class Profesor extends Director
class Estudiante extends Profesor
class Escuela{
// Declaration of lower bound
def display [T <: Profesor](t: T):Unit={
println(t)
}
}
// Object created
object main{
// Driver code
// Defined new variable
val principal = new Director
val teacher = new Profesor
val student = new Estudiante
val school = new Escuela
//school.display(principal)
school.display(teacher)
school.display(student)
}
}
Salida:
Profesor@67f639d3
Estudiante@6253c26
SCALA
Aquí, hemos definido el límite superior en la clase Escuela, es decir, [T <: Profesor] lo que implica que el método de
visualización acepta el objeto de clase
Profesor o subclase de este (es decir, Estudiante) lo que significa que la super clase de Profesor no será aceptada.
Por lo tanto, si Super clase de Profesor, es decir, Director no se comenta, entonces mostrará el error de discordancia
de tipo.
LowerBound
Tipo enlazado básicamente es un tipo de restricción en el parámetro o la variable.
Por el uso de estos límites de tipo podemos establecer límites para las variables.
Estos límites ayudan a poner nuestro código en ejemplos del mundo real.
Necesitamos imponer ciertas limitaciones y límites a cada factor de la vida real, eso es lo que hacen los límites Type
en Scala.
Hay principalmente 2 tipos de límites de tipo:
• Tipo Upper Bound
• Tipo Lower Bound
Estaremos más preocupados por los límites inferiores en esta sección. Los límites de tipo inferior se utilizan para
declarar un super tipo de otro tipo. Un límite inferior se indica mediante >: . Cualquier instrucción de límite inferior
se puede escribir como '[T>:S]'. Aquí T es un parámetro de tipo y S es un tipo. La instrucción de límite inferior
anterior significa que el parámetro de tipo T debe ser igual que S de un super tipo de S.
Vamos a entender acerca de super tipo, supongamos que escribimos S>:T entonces esta instrucción de límite
inferior siempre tiene T igual a S o menor que S, lo que significa que T está enlazado en este caso. Así que podemos
decir que T es un super tipo de S.
Descripción:
Aquí T es un parámetro de tipo y S es un tipo. Al declarar el límite inferior como "[T >: S]", significa que este
parámetro de tipo T debe ser el mismo que S o un supertipo de S.
Sintaxis:
[T >: Demo[T]]
En el caso anterior hemos definido un límite inferior desde el parámetro de tipo T para escribir Demo. Y T debe ser
un Demo o un super tipo de tipo Demo.
Ejemplo #1:
class Padre
class Ejemplo{
// Declaration of Lower bound
def display [T >: Hija2](d : T):Unit={
println(d)
}
}
object main{
SCALA
val obj1 = new Padre()

val ejemplo = new ComputerSciencePortal
}
}
Salida:
Padre@67f639d3
Hija1@6253c26
Hija2@49049a04
Aquí, el límite inferior se define en la clase ejemplo y Padre es la clase Super de Hija1. se acepta en límite inferior.
Ejemplo #2:
class Director
class Profesor extends Director
class Estudiante extends Profesor
class Escuela{
// Declaration of lower bound
def display [T >: Profesor](t: T):Unit={
println(t)
}
}
// Object created
object main{
// Driver code
// Defined new variable
val principal = new Director
val teacher = new Profesor
val student = new Estudiante
val school = new Escuela
school.display(principal)
school.display(teacher)
school.display(student)
}
}
Salida:
Director@67f639d3
Profesor@6253c26
Estudiante@49049a04
Aquí, hemos definido límite inferior en la clase Escuela, es decir, [T >: Profesor] lo que implica que el método de
visualización acepta el objeto de clase Director o subclase de la misma (es decir, Profesor) o la subclase de la clase
Profesor (es decir, Estudiante) lo que significa que se aceptará la superclase de Profesor.
Extractores
SCALA
En Scala, Extractor se define como un objeto que tiene un método llamado unapply como una de sus partes. Este
método extrae un objeto y devuelve los atributos. Este método también se utiliza en la coincidencia de patrones y
las funciones parciales.
Extractors también explica el método apply , que toma los argumentos y construye un objeto, por lo que es útil para
construir valores. El método unapply invierte el procedimiento de construcción del método de apply.
El tipo de devolución del método unapply se puede seleccionar como se indica a continuación:
- Si es un procedimiento de verificación, devuelva un tipo booleano.

- Si el procedimiento devuelve solo un subvalor de tipo T, devuelva una Opción[T].
- Si el procedimiento devuelve varios subvalores de tipo T1, T2,..., Tn, devuelve una tupla opcional, es decir,
Opción[(T1, T2,..., Tn)].
- Si el procedimiento devuelve un número impredecible de valores, entonces los extractores se pueden definir
con unapply Seq que devuelve Option[Seq[T]].
Ejemplo:
Tomemos un ejemplo de los métodos de apply y unapply de las definiciones de objetos. El método de apply tiene el
mismo significado de siempre: convierte Prueba en un objeto que se puede aplicar a los argumentos entre
paréntesis de la misma manera que se aplica un método. Entonces puedes escribir Prueba ("Zara", "gmail.com")
para construir la cadena "Zara@gmail.com".
El método unapply es lo que convierte a la clase Test en un extractor e invierte el proceso de construcción de apply .
Donde apply toma dos cadenas y forma una cadena de dirección de correo electrónico a partir de ellas, unapply
toma una dirección de correo electrónico y devuelve potencialmente dos cadenas: el usuario y el dominio de la
dirección.
Unapply también debe manejar el caso en el que la cadena dada no es una dirección de correo electrónico. Es por
eso que unapply devuelve un tipo de opción sobre pares de cadenas. Su resultado es Some (usuario, dominio) si la
cadena str es una dirección de correo electrónico con las partes de usuario y dominio dadas, o None, si str no es
una dirección de correo electrónico. Aquí hay algunos ejemplos de la siguiente manera.
Sintaxis:
unapply("Zara@gmail.com") equals Some("Zara", "gmail.com")
unapply("Zara Ali") equals None
El siguiente programa de ejemplo muestra un objeto extractor para

direcciones de correo electrónico.
object Demo {
println ("Apply method : " + apply("Zara", "gmail.com"));
println ("Unapply method : " + unapply("Zara@gmail.com"));
println ("Unapply method : " + unapply("Zara Ali"));
}
// The injection method (optional)

def apply(user: String, domain: String) = {
user +"@"+ domain
}
// The extraction method (mandatory)

def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
SCALA
if (parts.length == 2){
Some(parts(0), parts(1))
} else {
None
}
}
}
Salida:
Apply method : Zara@gmail.com
Unapply method : Some((Zara,gmail.com))
Unapply method : None
Pattern Matching con extractores
Cuando una instancia de una clase va seguida de paréntesis con una lista de cero o más parámetros, el compilador
invoca el método de aplicación en esa instancia. Podemos definir aplicar tanto en objetos como en clases.
Como se mencionó anteriormente, el propósito del método no aplicado es extraer un valor específico que
estamos buscando. Se aplica la operación contraria. Al comparar un objeto extractor usando la declaración de
coincidencia, el método de no aplicación se ejecutará automáticamente
Ejemplo #2:
object Demo {
val x = Demo(5)
println(x)
x match {
case Demo(num) => println(x+" es dos veces mas
grande que "+num)
//unapply is invoked
case _ => println("No se puede calcular..")
}
}
def apply(x: Int) = x*2
def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2)
else None
}
Salida:
10
10 es dos veces más grande que 5
Ejemplo
Pattern Matching con extractores
Cuando una instancia de una clase va seguida de paréntesis con una lista de cero o más
parámetros, el compilador invoca el método de aplicación en esa instancia. Podemos
definir aplicar tanto en objetos como en clases.
Como se mencionó anteriormente, el propósito del método no aplicado es extraer un

valor específico que estamos buscando. Se aplica la operación contraria. Al comparar un
objeto extractor usando la declaración de coincidencia, el método de no aplicación se
ejecutará automáticamente.
SCALA
object Ejemplo {
var x = Ejemplo(24)
//Método apply
println(x)
x match{
case Ejemplo(y) => println("El valor es: "+y)
case _ => println("No se puede evaluar...")
}
}
def apply(x:Double)= x/5
def unapply(z:Double):Option[Double]={
if(z%5 == 0){
Some(z/5)
}else{
None
}
}
}
Random
La función aleatoria de Scala se utiliza para generar números o caracteres aleatorios en Scala. Para generar los
números Random sobre Scala usamos la función Random con la clase Scala.util.Random. El número aleatorio
generado puede ser cualquier cosa, ya sea entero, flotante, doble, char. Este número aleatorio se usa y es
importante para aplicaciones de varios niveles, como validación, etc. Por lo tanto, se usa para la generación
aleatoria de números en nuestra aplicación Scala.
Sintaxis:
import scala.util.Random
var variable_nombre = Random
Ejemplo:
La clase Scala.util.Random se utiliza para la generación de números aleatorios sobre la
aplicación. Solo necesitamos importar la clase y los métodos como nextInt, nextFloat genera
los números.
import scala.util.Random
object rand {
var r = Random
for(i <- 0 to 10){

println(r.nextInt(1000))
}
//Matriz tipo double
var m1 = new Array[Double](10)
println("Rellenando matriz con números random...")

for(i <- 0 until m1.length){
m1(i)=r.nextDouble()
SCALA
println("Mostrando matriz con números random...")

print(" "+m1(i))
}
//Matriz tipo char

var m2 = new Array[Char](10)
println("Rellenando matriz con caracteres random...")

m2(i)=r.nextPrintableChar()
}
println("Mostrando matriz con caracteres random...")

print(" "+m2(i))
}
}
}
Salida:
380
888
915
822
927
324
917
191
942
521
212
Rellenando matriz con números random...
Mostrando matriz con números random...
0.3763564391197727 0.002694038862120607 0.9871320117137273 0.8317108880355971
0.9690425048380543 0.5643876869452915 0.6981394607763309 0.4501050629952842
0.6907094698384503 0.9937223083229213
Rellenando matriz con caracteres random...
Mostrando matriz con caracteres random...
7U#4:XCoDq
Hora y Fecha
Scala es un lenguaje de programación de propósito general, que se utiliza principalmente para la manipulación de
datos. Tiene bibliotecas y soporte para casi todas las diferentes utilidades que son importantes. Una de las cosas
importantes que se requieren durante la programación es el estado de fecha y hora en tiempo real y Scala
también tiene una solución para eso.
Obtener la fecha y la hora actuales en Scala
SCALA
Obtener la fecha y la hora actuales en Scala es muy simple y puede hacerlo usando la clásica clase de 'calendar' de
Java.
Esta clase se puede importar usando la instrucción: "java.util.Calendar" . La clase de calendario en Java es una
clase abstracta que se utiliza para obtener la fecha y la hora actuales. La misma clase también se usa en Scala,
podemos obtener la fecha y hora actual usándola. Hay un campo en esta clase que almacena la fecha y hora
actuales.
Sintaxis:
import java.util.Calendar
var variable_nombre = Calendar.getInstance()
Ejemplo:
object main {
var dT = Calendar.getInstance()
var horaActual = dT.get(Calendar.HOUR_OF_DAY)
var minutoActual = dT.get(Calendar.MINUTE)
var segActual = dT.get(Calendar.SECOND)
if(horaActual>12){
println("La hora actual es
"+horaActual+":"+minutoActual+":"+segActual+" PM")
}else{
"+horaActual+":"+minutoActual+":"+segActual+" AM")
}
}
}
Salida:
La hora actual es 11:22:02 AM
Obtener fecha y hora completa en Scala
En este programa, hemos utilizado el método getInstance() de la clase Calendar. Este método se usa para
encontrar la fecha y la hora en Java, el mismo método también se usa en Scala. Pasamos las variables
calendar.MINUTE y calendar.HOUR_OF_DAY , y almacenamos el resultado de los métodos en las variables
minutoActual y horaActual respectivamente. Los valores devueltos por las funciones se almacenan en las
variables. El método gets ( Calendar.HOUR_OF_DAY ) devuelve la hora actual en formato de 24 horas.
Ejemplo:
object main {
var fechaActual = dT.getTime()

println("La fecha actual "+fechaActual)
}
}
Salida:
La fecha actual es Tue Jul 16 19:54:59 UTC 2019
SCALA
Este código usa el método getTime() que devuelve la fecha y la hora actuales en el formato día MM DD hora UTC
AAAA . Este es también un método incorporado del calendario de clases.
Ejemplo :
object main {
var horaActual = dT.get(Calendar.HOUR_OF_DAY)
var minutoActual = dT.get(Calendar.MINUTE)
var segActual = dT.get(Calendar.SECOND)
if(horaActual>12){
"+horaActual+":"+minutoActual+":"+segActual+" PM")
}else{
"+horaActual+":"+minutoActual+":"+segActual+" AM")
}
}
}
Salida:
La hora actual es 11:22:02 AM
En este programa, hemos utilizado el método getInstance() de la clase Calendar.
Este método se usa para encontrar la fecha y la hora en Java, el mismo método también se usa en Scala. Pasamos
las variables calendar.MINUTE y calendar.HOUR_OF_DAY , y almacenamos el resultado de los métodos en las
variables minutoActual y horaActual respectivamente. Los valores devueltos por las funciones se almacenan en las
variables. El método gets (Calendar.HOUR_OF_DAY ) devuelve la hora actual en formato de 24 horas.
También puede obtener la fecha y hora exactas de su hora actual según UTC. Algunos métodos lo ayudan a
obtener el año, el día, el minuto y también el segundo. Puedes obtener todo esto usando el método get() de la
clase Calendar. Pasar diferentes parámetros puede obtener diferentes resultados. Estos son:
- get(object.YEAR)
- get(object.DATE)
- get(object.MINUTE)
- get(object.SECOND)
Programa para obtener la hora actual usando la clase SimpleDateFormat
Ejemplo:
import java.text.SimpleDateFormat
object formato {
var dt = Calendar.getInstance()
var formato = new SimpleDateFormat("yy / MM / dd")
var hr24 = new SimpleDateFormat("HH")
var formatoh24 = hr24.format(dt.getTime())
var hr12 = new SimpleDateFormat("hh")
var min = new SimpleDateFormat("mm")
var formatoMin = min.format(dt.getTime())
var seg = new SimpleDateFormat("ss")
var formatoSeg = seg.format(dt.getTime())
var a_p = new SimpleDateFormat("a")
var formatoP = a_p.format(dt.getTime())
SCALA
println("Hora con formato de 24 =

"+formatoh24+":"+formatoMin+":"
+formatoSeg)
+formatoSeg+" "+formatoP)
}
}
Salida:
Hora con formato de 24 = 20 : 12 : 18
Hora con formato de 24 = 08 : 12 : 18 PM
Las funciones Java calendar () y SimpleDateFormat() también son válidas en Scala. Al igual que en los programas
anteriores, puede ver que los métodos de estas clases que se importan de Java son tan poderosos que pueden
manipular todas las funcionalidades de fecha y hora de finalización que están incorporadas en el compilador.
Puede verificar las fechas de ok en cualquier formato. Al usar esto, también puede ver qué calendario está usando
el compilador y la hora que está usando el compilador. Generalmente, el compilador usa UTC y el calendario
georgiano.
Ejemplo
Obtener la hora actual usando la clase SimpleDateFormat
Las funciones Java calendar () y SimpleDateFormat() también son válidas en Scala. Al

igual que en los programas anteriores, puede ver que los métodos de estas clases que se
importan de Java son tan poderosos que pueden manipular todas las funcionalidades de
fecha y hora de finalización que están incorporadas en el compilador. Puede verificar las
fechas de ok en cualquier formato. Al usar esto, también puede ver qué calendario está
usando el compilador y la hora que está usando el compilador. Generalmente, el
compilador usa UTC y el calendario georgiano.
import java.text.SimpleDateFormat
object formato {
var dt = Calendar.getInstance()
var formato = new SimpleDateFormat("yy / MM / dd")
println("Fecha actual "+dt.getTime())
var fechaFormato = formato.format(dt.getTime())

println("Formato de fecha : "+fechaFormato)
var hr24 = new SimpleDateFormat("HH")

var hr12 = new SimpleDateFormat("hh")

var min = new SimpleDateFormat("mm")

var formatoMin = min.format(dt.getTime())
var seg = new SimpleDateFormat("ss")

var formatoSeg = seg.format(dt.getTime())
SCALA
var a_p = new SimpleDateFormat("a")

var formatoP = a_p.format(dt.getTime())

+formatoSeg)
+formatoSeg+" "+formatoP)
}
}
SCALA

Tema 9

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema 9

Cargado por

Copyright:

Formatos disponibles

Máster Executive Big Data And Artificial Intelligence

CREAR UN NUEVO ARCHIVO

java.io.PrintWriter incluye todos los métodos de impresión incluidos en PrintStream.

Lectura del contenido del archivo

var test = Source.fromFile("test.txt") test.getLines().foreach{x

Una excepción es un evento no deseado o inesperado,

Todos los tipos de excepción y errores son subclases

¿Cómo funciona Scala Exception?

Cosas importantes para recordar:

- Throw expression tiene un tipo de valor devuelto Nothing.

La construcción Try-Catch es diferente en Scala que en Java, Try-

def main(args: Array[String]): Unit = {

Mediante la implementación de límites de tipo, podemos explicar las

Aquí T es un parámetro de tipo y S es un tipo. Al declarar el límite

Vamos a entender el límite superior con el ejemplo.

class Hija2 extends Padre

val obj1 = new Padre()

val ejemplo = new ComputerSciencePortal

Tipo enlazado básicamente es un tipo de restricción en el parámetro o la variable.

Hay principalmente 2 tipos de límites de tipo:

• Tipo Upper Bound

• Tipo Lower Bound

val obj1 = new Padre()

- Si es un procedimiento de verificación, devuelva un tipo booleano.

El siguiente programa de ejemplo muestra un objeto extractor para

// The injection method (optional)

// The extraction method (mandatory)

Pattern Matching con extractores

Como se mencionó anteriormente, el propósito del método no aplicado es extraer un

def apply(x:Double)= x/5

for(i <- 0 to 10){

println("Rellenando matriz con números random...")

println("Mostrando matriz con números random...")

//Matriz tipo char

println("Rellenando matriz con caracteres random...")

println("Mostrando matriz con caracteres random...")

Obtener la fecha y la hora actuales en Scala

Obtener fecha y hora completa en Scala

var fechaActual = dT.getTime()

Programa para obtener la hora actual usando la clase SimpleDateFormat

println("Hora con formato de 24 =

Las funciones Java calendar () y SimpleDateFormat() también son válidas en Scala. Al

println("Fecha actual "+dt.getTime())

var fechaFormato = formato.format(dt.getTime())

var hr24 = new SimpleDateFormat("HH")

var hr12 = new SimpleDateFormat("hh")

var min = new SimpleDateFormat("mm")

var seg = new SimpleDateFormat("ss")

var a_p = new SimpleDateFormat("a")

println("Hora con formato de 24 =

También podría gustarte