Scala So sortieren Sie die Liste der Objekte Liste nach Objektfeld (Object.field)?

Question

Ich habe die folgende Art von Daten:

case class TipoDeDato[T] (nombreCampo: String,valor: T) 

Und in meiner Übung, ich brauche die folgende Struktur zu schaffen, die Art der Daten unter Verwendung von I erwähnt:

I Also, erstellt die folgende Struktur

val registro0: List[TipoDeDato[_>: String with Int]] = List(
    new TipoDeDato[String]("Autor", "Gabo"), 
    new TipoDeDato[String]("Titulo", "100 Años"), 
    new TipoDeDato[Int]("Numero de Paginas", 700) 
) 
    val registro1: List[TipoDeDato[_>: String with Int]] = List(
    new TipoDeDato[String]("Autor", "Gabo"), 
    new TipoDeDato[String]("Titulo", "Maria"), 
    new TipoDeDato[Int]("Numero de Paginas", 1200) 
) 
    val registro2: List[TipoDeDato[_>: String with Int]] = List(
    new TipoDeDato[String]("Autor", "Gabo"), 
    new TipoDeDato[String]("Titulo", "Carrasco"), 
    new TipoDeDato[Int]("Numero de Paginas", 150) 
) 
    val registro3: List[TipoDeDato[_>: String with Int]] = List(
    new TipoDeDato[String]("Autor", "Gabo"), 
    new TipoDeDato[String]("Titulo", "Oceano"), 
    new TipoDeDato[Int]("Numero de Paginas", 200) 
) 

und die „Libros“ Objekt zu erstellen, ich folgendes getan:

val Libros: List[List[TipoDeDato[_>: String with Int]]] = List(registro0,registro1,registro2,registro3) 

Meine Frage ist, wie kann ich die „Libros“ Objekt, durch eine seiner Komponenten sortieren, „Autor“, „Titulo“, „Numero de paginas“ ?, ist diese Struktur angemessen für das, was ich brauche machen?

Answer 1

zu sortieren List von List:

sealed trait TipoDeDato 

case class Autor (autor: String) extends TipoDeDato 
case class Titulo (titulo: String) extends TipoDeDato 
case class NumeroDePaginas (numeroDePaginas: Int) extends TipoDeDato 

class TablaItems(var registros: List[List[TipoDeDato]]){ 
    def insertInto(reg: List[List[TipoDeDato]]): TablaItems = { 
    registros = registros ::: reg 
    this 
    } 
} 

    val registro0: List[TipoDeDato] = List(
    Autor("HGabo"), 
    Titulo("ZLa María"), 
    NumeroDePaginas(752) 
) 

    val registro1: List[TipoDeDato] = List(
    Autor("AGabo"), 
    Titulo("CLa María"), 
    NumeroDePaginas(521) 
) 

    val Registros1: List[List[TipoDeDato]] = List(registro0) 
    val Registros2: List[List[TipoDeDato]] = List(registro1) 

    val tablaLibros = new TablaItems(Registros1) 
    tablaLibros.registros.foreach(println) 
    println("----") 
    tablaLibros.insertInto(Registros2) 
    tablaLibros.registros.foreach(println) 
    println("----") 
    tablaLibros.registros.sortBy(r=>r.collectFirst{ 
     case NumeroDePaginas(n) => n 
    }.getOrElse(0)) 

Eigentlich denke ich, Sie brauchen:

case class Dato(autor: String, titulo: String, numeroDePaginas: Int) 


class TablaItems(var registros: List[Dato]){ 
    def insertInto(reg: List[Dato]): TablaItems = { 
    registros = registros ::: reg 
    this 
    } 
} 

    //you can also do (if you prefer) `Dato(author = "HGabo", titulo = "ZLa María", numeroDePaginas = 752) 
    val registro0 = Dato("HGabo", "ZLa María", 752) 

    val registro1 = Dato("AGabo", "CLa María", 521) 

    val Registros1: List[Dato] = List(registro0) 
    val Registros2: List[Dato] = List(registro1) 

    val tablaLibros = new TablaItems(Registros1) 
    tablaLibros.registros.foreach(println) 
    println("----") 
    tablaLibros.insertInto(Registros2) 
    tablaLibros.registros.foreach(println) 
    println("----") 
    tablaLibros.registros.sortBy(_.numeroDePaginas) 

Auch wenn dieses Problem der funktionalen Programmierung erfordert (keine Nebenwirkungen, und ich habe auch los OOP - Letzteres ist jedoch nicht obligatorisch, OOP und FP sind orthogonal):

case class TablaItems(registros: List[Dato]) 

implicit class TablaItemsOperations(tabla: TablaItems){ 
    def withData(reg: List[Dato]) = TablaItems(tabla.registos :: reg) 
} 

... 


val tablaLibros = TablaItems(Registros1) 
tablaLibros.registros.foreach(println) 
println("----") 
val tablaLibrosUpdated = tablaLibros.withData(Registros2) 
tablaLibrosUpdated.registros.foreach(println) 
println("----") 
tablaLibrosUpdated.registros.sortBy(_.numeroDePaginas)