Scala中递归遍历列表行，添加数据类型字段的实现问题

Hey there! Let's walk through how to build a recursive solution to append your computed data type as a fourth element to every string in your input list. I'll break this down step by step with concrete code examples.

Step 1: Let's Define Your Existing Type-Checking Function First #

Since you mentioned you already have a function to calculate the data type from the third element, let's use a sample implementation (adjust this to match your actual logic):

def determineDataType(thirdElement: String): String = {
  // Replace this with your real type-detection logic
  thirdElement match {
    case s if s.startsWith("7(") => "Numeric"
    case s if s.startsWith("S(") => "String"
    case _ => "Unknown"
  }
}

This example maps elements starting with 7( to "Numeric" and S( to "String"—swap this out for whatever rules you've already built.

Step 2: Implement the Recursive Processing Function #

Scala lists are inherently recursive structures, so we can use that to our advantage to process each element one by one:

val input = List( 
  "17 SD1-MONT_FF_13 7(14)", 
  "17 QXRI1-SEDDS_13 S(01)", 
  "17 XFDRI1-MONDT_TT_14 7(18)", 
  "17 SQXI1-SSENS_14 S(01)", 
  "12 CRI1-MSONT_TT_15 7(18)", 
  "13 QSDRI1-SEDNS_15 S(01)", 
  "14 WSQSRI1-DEVSISE S(05)"
)

def addDataTypeRecursively(list: List[String]): List[String] = {
  // Base case: stop recursion when the list is empty
  list match {
    case Nil => Nil
    case head :: tail =>
      // Split the current string into its components (handles multiple spaces with \\s+)
      val parts = head.split("\\s+")
      // Grab the third element (arrays are 0-indexed, so index 2)
      val thirdElement = parts(2)
      // Calculate the data type using your existing function
      val dataType = determineDataType(thirdElement)
      // Build the new string with the fourth element appended
      val newHead = s"$head $dataType"
      // Recursively process the rest of the list and combine results
      newHead :: addDataTypeRecursively(tail)
  }
}

// Test the function
val result = addDataTypeRecursively(input)
result.foreach(println)

How the Recursion Works #

Let's demystify the recursive flow:

1. Base Case: When we hit an empty list (Nil), we return an empty list—this is the stop condition for the recursion.
2. Recursive Case: For a non-empty list (head :: tail, where head is the first element and tail is the rest of the list):
   • Split the first string into its parts.
   • Extract the third element to feed into your type-checking function.
   • Append the computed data type to the original string to create a new entry.
   • Recursively process the remaining elements and prepend the new entry to the result of that recursion.

Optional: Handle Edge Cases #

If there's a chance some lines might not have a third element (even though your input doesn't show this), add a safety check to avoid errors:

val newHead = if (parts.length >= 3) {
  val dataType = determineDataType(parts(2))
  s"$head $dataType"
} else {
  s"$head InvalidEntry" // Customize this error handling as needed
}

Alternative: Tail-Recursive Version (For Large Lists) #

If your list is very long, a tail-recursive implementation prevents stack overflow by reusing the same stack frame for each call:

import scala.annotation.tailrec

@tailrec
def addDataTypeTailRecursive(list: List[String], accumulator: List[String] = Nil): List[String] = {
  list match {
    case Nil => accumulator.reverse // Reverse to keep original order
    case head :: tail =>
      val parts = head.split("\\s+")
      val dataType = if (parts.length >=3) determineDataType(parts(2)) else "Unknown"
      val newHead = s"$head $dataType"
      // Pass the tail and updated accumulator to the next recursive call
      addDataTypeTailRecursive(tail, newHead :: accumulator)
  }
}

val tailRecResult = addDataTypeTailRecursive(input)

内容的提问来源于stack exchange，提问作者user9683185