Set 去重

import scala.collection.mutable

//定义一个Book类
//实例化两本相同的书，把他们放入Set中（看是否能去重）

class Book(val id: String,val name:String,val stock:Int){
  //判断两个对象是否相等
  override def equals(obj: Any): Boolean = {
    val o = obj.asInstanceOf[Book]
    o.id == id
  }

  //获取 hashCode
  override def hashCode(): Int = {
    id.hashCode
  }

}

//测试类
object Test_caseclass {
  def main(args: Array[String]): Unit = {
    val book1 =new Book(id = "001", name = "红楼梦", stock = 3)
    val book2 =new Book(id = "001", name = "红楼梦", stock = 3)
    val book3 =new Book(id = "001", name = "红楼梦", stock = 6)

//    book1 ==book1
//    book2 ==book1
    println(book1 ==book2)
    //定义一个用来装入书的可变的Set
    val books=mutable.Set[Book]()

    //Set可以去重，但是，它需要去比较两个元素是否相等
    //添加一本书
    books += book1
    books += book2
    books += book3

    println(books)
  }
}

case class 特点

1、创建的对象的属性都是不能被修改的

2、创建对象可以不用写new

3、自动重写方法：toString , equals , hashCode , copy

package scala_mianx

import scala.collection.mutable
package Test_caseclass1 {
  // case class
  //1、创建的对象的属性都是不能被修改的
  //2、创建对象可以不用写new
  //3、自动重写方法：toString , equals , hashCode , copy

  case class Book(val id: String, val name: String, val stock: Int)

  //测试类
  object Test_caseclass {
    def main(args: Array[String]): Unit = {
      val book1 = new Book(id = "001", name = "红楼梦", stock = 3)

      println(book1)
//      book1.id = "002"
      val book2 = new Book(id = "001", name = "红楼梦", stock = 3)
      val book3 = new Book(id = "001", name = "红楼梦", stock = 3)

      //coye 用来复制一份数据
      val book4 = book1.copy(id = "004",name = "西游记")
      //    book1 ==book1
      //    book2 ==book1
      println(book1 == book2)
      //定义一个用来装入书的可变的Set
      val books = mutable.Set[Book]()

      //Set可以去重，但是，它需要去比较两个元素是否相等
      //添加一本书
      books += book1
      books += book2
      books += book3
      books += book4

      println(books)
    }
  }
}

【课后小答】

1、case class 的定义语法是？

case class ClassName(parameter1: Type1, parameter2: Type2, /*...*/)

2、case class 有哪些作用？

数据封装        模式匹配支持        自动生成有用方法

3、case class  的特点有哪些？

        1、创建的对象的属性都是不能被修改的

        2、创建对象可以不用写new

        3、自动重写方法：toString , equals , hashCode , copy

4、case class 和普通的class在哪些方面有区别？

【实训】

1.使用case class 创建图书信息类Book： 包含四个属性:ID，书名，作者，价格，数量。
2.创建一个名为BookList的可变List,它只能用来保存Book的实例。
3.初始化三本不同的书(注意id不同就是不同的书)，加入到Booklist中。
4.添加一本已经存在的书。此时应该去修改Booklist中对应书目的数量，而不是去添加一条新数据。
5.根据图书名称查询是否在列表中(通过遍历列表对比名称）
6.删除指定书名的书
7.删除指定ID的书
8.对于图书按价格从高到低排序。
9.遍历图书列表，并打印每本书的详细信息
10.展示全部的总的金额

// 1. 使用case class创建图书信息类Book
case class Book(ID: Int, title: String, author: String, price: Double, quantity: Int)

object BookOperations {
    def main(args: Array[String]) {
        // 2. 创建一个名为BookList的可变List，它只能用来保存Book的实例
        import scala.collection.mutable.ListBuffer
        var BookList: ListBuffer[Book] = ListBuffer[Book]()

        // 3. 初始化三本不同的书，加入到Booklist中
        val book1 = Book(1, "Scala编程之道", "张三", 55.0, 3)
        val book2 = Book(2, "Java进阶之路", "李四", 65.0, 2)
        val book3 = Book(3, "Python实战指南", "王五", 45.0, 5)

        BookList += book1
        BookList += book2
        BookList += book3

        // 4. 添加一本已经存在的书，修改Booklist中对应书目的数量
        val existingBook = Book(1, "Scala编程之道", "张三", 55.0, 2)
        addExistingBook(existingBook, BookList)

        // 5. 根据图书名称查询是否在列表中
        val searchTitle = "Java进阶之路"
        val isInListByName = isBookInListByName(searchTitle, BookList)
        println(s"图书 '$searchTitle' 是否在列表中: $isInListByName")

        // 6. 删除指定书名的书
        val bookToDeleteByName = "Python实战指南"
        deleteBookByName(bookToDeleteByName, BookList)

        // 7. 删除指定ID的书
        val bookToDeleteByID = 2
        deleteBookByID(bookToDeleteByID, BookList)

        // 8. 对于图书按价格从高到低排序
        val sortedBooks = sortBooksByPriceDesc(BookList)

        // 9. 遍历图书列表，并打印每本书的详细信息
        println("排序后的图书列表详细信息:")
        sortedBooks.foreach(book => println(book))

        // 10. 展示全部的总的金额
        val totalAmount = calculateTotalAmount(sortedBooks)
        println(s"全部图书的总金额: $totalAmount")
    }

    // 辅助方法：添加一本已经存在的书，修改数量
    def addExistingBook(existingBook: Book, bookList: ListBuffer[Book]): Unit = {
        bookList.find(_.ID == existingBook.ID) match {
            case Some(book) =>
                val updatedBook = book.copy(quantity = book.quantity + existingBook.quantity)
                bookList -= book
                bookList += updatedBook
            case None =>
                bookList += existingBook
        }
    }

    // 辅助方法：根据图书名称查询是否在列表中
    def isBookInListByName(title: String, bookList: ListBuffer[Book]): Boolean = {
        bookList.exists(_.title == title)
    }

    // 辅助方法：删除指定书名的书
    def deleteBookByName(title: String, bookList: ListBuffer[Book]): Unit = {
        bookList -= bookList.find(_.title == title).get
    }

    // 辅助方法：删除指定ID的书
    def deleteBookByID(ID: Int, bookList: ListBuffer[Book]): Unit = {
        bookList -= bookList.find(_.ID == ID).get
    }

    // 辅助方法：对图书按价格从高到低排序
    def sortBooksByPriceDesc(bookList: ListBuffer[Book]): ListBuffer[Book] = {
        bookList.sortBy(-_.price)
    }

    // 辅助方法：计算全部图书的总金额
    def calculateTotalAmount(bookList: ListBuffer[Book]): Double = {
        bookList.map(book => book.price * book.quantity).sum
    }
}