我认为设置inferSchema == true可能是问题所在，因为它是在驱动程序中执行的。那么为什么要在阅读时推断模式（需要额外的数据传递，需要更多的驱动程序资源）呢？也许在这个玩具示例中找不到原因，但也许你可以尝试一下？
首先...你的第二个文件格式工作正常（第一个没有）...我创建了几个这样的文件，并把它们都粘在S3上的一个文件夹中。

[{
  "RecordNumber": 2,
  "Zipcode": 704,
  "ZipCodeType": "STANDARD",
  "City": "PASEO COSTA DEL SUR",
  "State": "PR"
},
{
  "RecordNumber": 10,
  "Zipcode": 709,
  "ZipCodeType": "STANDARD",
  "City": "BDA SAN LUIS",
  "State": "PR"
}]

我尝试的另一种方法是在阅读时自己提供模式。

import org.apache.spark.sql.types.{ IntegerType, StringType, StructField, StructType }

val schema = {
    new StructType()
      .add(StructField("RecordNumber", IntegerType, false))
      .add(StructField("Zipcode", IntegerType, true))
      .add(StructField("ZipCodeType", StringType, true))
      .add(StructField("City", StringType, true))
      .add(StructField("State", StringType, true))
  }

val df = spark.read.option("multiline", value = true).schema(schema).json("s3://bucket/path/")

还有一件事要尝试......只是跳过在阅读时推断模式。我不知道下面的代码是否以同样的方式使用驱动程序资源，但我似乎记得它可能使用了行的一个小子集。

val df = spark.read.option("multiline", value = true).json("s3://bucket/path/")

val schema = df.schema
schema.printTreeString

df.printSchema

EDIT-回应指出上述内容不好的评论

最后一件要尝试的事情...在这里，我只是想让司机出来的混合，所以我做以下...
1.以纯文本形式阅读，JSON记录跨多行
1.使用.mapPartitions迭代每个分区，并将拆分为多行的JSON合并为每个JSON字符串一条记录
1.最后......使用您最喜欢的解析器解析为JSON（我使用json 4s没有特别的原因）
如果在此之后，您仍然遇到内存错误，它应该在执行器上，在那里您有更多的选择。
当然，如果你想让Spark自动地把它读入一个200列的 Dataframe ，也许你需要一个更大的驱动程序。
这里有一个函数可以遍历文本行，并尝试将每行合并成一条记录，这个函数在玩具例子中是有效的，但是你可能需要做一些更聪明的事情。
.mapPartitions将每个分区视为一个迭代器......因此，您需要为它提供一个Iterator[A] => Iterator[B]类型的函数，在本例中，该函数只是一个.foldLeft，它使用regex来判断它是否是记录的结尾。

import org.apache.spark.rdd.RDD // RDD because that's what I use; probably similar on dataframes
import org.json4s._             // json4s for no particular reason
import org.json4s.jackson.JsonMethods._

/** `RDD.mapPartitions` treats each partition as an iterator
  * so use a .foldLeft on the partition and a little regex
  * merge multiple lines into one
  * 
  * probably need something a smarter for more nested JSON
  */
val mergeJsonRecords: (Iterator[String] => Iterator[String]) = (oneRawPartition) => {
  // val patternStart = "^\\[?\\{".r
  val patternEnd = "(.*?\\})[,\\]]?$".r // end of JSON record
  oneRawPartition
    .foldLeft(List[String]())((list, next) => list match {
      case Nil => List(next.trim.drop(1))
      case x :: Nil => { 
        x.trim match {
          case patternEnd(e) => List(next.trim, e)
          case _ => List(x + next.trim)
        }
      }
      case x :: xs => {
        x.trim match {
          case patternEnd(e) => next.trim :: e :: xs
          case _ => x.trim + next.trim :: xs
        }
      }
    })
    .map { case patternEnd(e) => e; case x => x } // lame way to clean up last JSON in each partitions
    .iterator
}

这里只是读取数据...合并行...然后解析。同样，我使用RDD是因为它是我通常使用的，但我相信如果需要的话，你可以把它保存在 Dataframe 中。

// read JSON in as plain text; each JSON record over multiple lines
val rdd: RDD[String] = spark.read.text("s3://bucket/path/").rdd.map(_.getAs[String](0))
rdd.count // 56 rows == 8 records

// one record per JSON object
val rdd2: RDD[String] = rdd.mapPartitions(mergeJsonRecords)
rdd2.collect.foreach(println)
rdd2.count // 8

// parsed JSON
object Parser extends Serializable {
  implicit val formats = DefaultFormats
  val func: (String => JValue) = (s) => parse(s)
}
val rddJson = rdd2.map(Parser.func)