मेरे पास एक केस क्लास नोड है जिसे मैंने लिखा है, और इससे एक सूची बनाएं और मुझे उस नोड को खोजने की ज़रूरत है जिसमें अधिकतम डिस्क है। मैंने नीचे कोड लिखा है, क्या ऐसा करने का कोई बेहतर तरीका है? साथ ही, मेरे वास्तविक उत्पादन कोड में, मेरा "नोडलिस्ट" चर केवल Option[List[Node]] नहीं बल्कि Future[Option[List[Node]]] होगा। मुझे लगता है कि अभी भी उत्तर/कोड इस तथ्य को छोड़कर ज्यादा नहीं बदलेगा कि मैं भविष्य के अंदर जाने के लिए एक नक्शा/फ्लैटमैप करूँगा और वही काम करूंगा। अगर किसी के पास कोड को और अधिक स्कैला तरीके से लिखने का बेहतर सुझाव है, तो कृपया अपने विचार साझा करें।

scala> case class Node(disk: Integer, name: String)

परिभाषित वर्ग नोड

scala> val nodeList = Option(List(Node(40, "node1"), Node(200, "node3"),Node(60, "node2")))
nodeList: Option[List[Node]] = Some(List(Node(40,node1), Node(200,node3), Node(60,node2)))

scala> val maxDisk = nodeList match {
| case None => println("List is empty"); None
| case Some(lst) => {
| Some(lst.max(Ordering.by((_:Node).disk)))
| }
| }`
maxDisk: Option[Node] = Some(Node(200,node3))
0
curiousengineer 27 अगस्त 2017, 05:19

2 जवाब

सबसे बढ़िया उत्तर

आपके द्वारा लिखे गए कोड को देखते हुए, मुझे यकीन नहीं है कि आपको वास्तव में Optional[List[Node]] का उपयोग करना चाहिए। आप None को एक खाली List मानते हैं, और आप Some मामले में खाली सूची की जांच नहीं करते हैं। आप शायद यह देखना चाहें कि क्या केवल एक सादा List[Node] आपके उपयोग के लिए बेहतर है (जहां None Nil बन जाएगा, और Some(lst) केवल lst है, और अप्रयुक्त Some(Nil) मामला अब किसी को भ्रमित करने के लिए मौजूद नहीं है)।

अगर आप Optional[List[Node]] रखते हैं, तो मैं इसे इस तरह से करूंगा:

nodeList
  .filterNot(_.isEmpty) // maxBy throws if the list is empty; check for it
  .map(_.maxBy(_.disk)) // maxBy looks nicer than max(Ordering.by)

यदि आप List[Node] पर स्विच करते हैं, तो यह थोड़ा अधिक बदसूरत है:

Some(nodeList)
  .filterNot(_.isEmpty) // We're using the filter utility of Option here,
  .map(_.maxBy(_.disk)) // so I wrap with Some to get access to filterNot.
1
HTNW 27 अगस्त 2017, 05:33

आप सूची पैटर्न मिलान के साथ रिकर्सन का उपयोग कर सकते हैं।

  case class Node(disk: Integer, name: String)
  val nodeList = Option(List(Node(40, "node1"), Node(200, "node3"),Node(60, "node2")))

  def findMaxValue(list: List[Node]): Option[Node] = list match {
    case Nil => None
    case List(x) => Some(x)
    case first :: second :: rest => if(first.disk > second.disk) findMaxValue(first::rest) else findMaxValue(second::rest)
  }

  val node:Option[Node] = findMaxValue(nodeList.getOrElse(Nil))
  println(node.get.disk)  //print 200
1
Ra Ka 27 अगस्त 2017, 05:39