String可以（通过这里隐式转换为StringOps）被认为是一个 * 字符 * 的集合，所以你的填充应该是：

val s = s1 + s2.padTo(padLength, ' ') + s3 // note the single quotes: a char

在String上调用.padTo(padLength, " ")实际上会返回Seq[Any]，因为在序列中会同时出现字符和字符串。

你还没说你想往左还是往右。只需使用格式：

val s = f"$s1%s$s2%20s$s3"

或者，在Scala 2.10之前（或者如果你需要“20”作为参数）：

val s = "%s%"+padLength+"s%s" format (s1, s2, s3)

使用负填充将填充空间添加到右侧而不是左侧。

有人应该提到你应该打开警告：

apm@mara:~$ skala -Ywarn-infer-any
Welcome to Scala version 2.11.0-20130524-174214-08a368770c (OpenJDK 64-Bit Server VM, Java 1.7.0_21).
Type in expressions to have them evaluated.
Type :help for more information.

scala> "abc".padTo(10, "*").mkString
<console>:7: warning: a type was inferred to be `Any`; this may indicate a programming error.
       val res0 =
           ^
res0: String = abc*******

请注意，这样做（本身）没有错。
也许有一个用例：

scala> case class Ikon(c: Char) { override def toString = c.toString }
defined class Ikon

scala> List(Ikon('#'),Ikon('@'),Ikon('!')).padTo(10, "*").mkString
res1: String = #@!*******

或更好

scala> case class Result(i: Int) { override def toString = f"$i%03d" }
defined class Result

scala> List(Result(23),Result(666)).padTo(10, "---").mkString
res4: String = 023666------------------------

由于这不是您的用例，也许您应该询问是否希望使用冗长且充满危险的API。
所以丹尼尔的答案才是正确的。我不知道为什么他的例子中的格式字符串看起来如此可怕，但它通常看起来更温和，因为在大多数可读的字符串中，您只需要在少数地方格式化字符。

scala> val a,b,c = "xyz"

scala> f"$a is followed by `$b%10s` and $c%.1s remaining"
res6: String = xyz is followed by `       xyz` and x remaining

需要添加虚假格式化程序的一种情况是需要换行符：

scala> f"$a%s%n$b$c"
res8: String = 
xyz
xyzxyz

我认为这个函数应该处理f”$a%n$B”。哦，等等，2.11年就修好了。

scala> f"$a%n$b"  // old
<console>:10: error: illegal conversion character
              f"$a%n$b"

scala> f"$a%n$b"  // new
res9: String = 
xyz
xyz

所以现在真的没有理由不插进去了。

有一个formatted方法可用。举例来说：

val s = s1 + s2.formatted("%-10s") + s3

format：

val s = s1 + "%-10s".format(s2) + s3

但我只会使用它，如果padLength可以直接嵌入。
如果在其他地方定义了它（如在您的示例中），您可以使用padTo，就像Ellaysama指出的那样。
如果你想“向左填充”，你可以使用一个隐式类：

object Container {
  implicit class RichChar(c: Char) {
    def repeat(n: Int): String = "".padTo(n, c)
  }

  implicit class RichString(s: String) {
    def padRight(n: Int): String = {
      s + ' '.repeat(n - s.length)
    }

    def padLeft(n: Int): String = {
      ' '.repeat(n - s.length) + s
    }
  }
}

object StringFormat1Example extends App {
  val s = "Hello"

  import Container._

  println(s.padLeft(10))
  println(s.padRight(10))
}

这一方法：

val s = s1 + s2.padTo(padLength, " ").mkString + s3

但感觉不太稳定

这一点值得添加到Misc重新表述中：

scala> val a = "A"; val b="B";val c="C"
a: String = A
b: String = B
c: String = C

scala> b.padTo(10, " ").mkString(a, "", c)
res1: String = AB         C

这样就能为周日的教堂节省一些钱
我开始相信在这个非常不稳定的提交中利用mkString。

s1 + s2 + " "*(padLength - s2.size) + s3

我相信Scala最惯用的方法是在一个由.toString方法转换为String的单个空格Char上使用*操作符，所以它是：

// for right padding
val sr = s1 + s2 + ' '.toString * padLength + s3

// for left padding
val sl = s1 + ' '.toString * padLength + s2 + s3