一个简单的递归就可以做到。

def isSame[T](arrA:Array[T], arrB:Array[T]) :Boolean =
  arrA.length == arrB.length &&
    (arrA.isEmpty || isSame(arrA.filterNot(_ == arrA.head)
                           ,arrB.filterNot(_ == arrA.head)))

但@蒂姆的问题是有效的：你对这个显而易见的简单分类的解决方案有什么异议？

下面将对两个数组进行排序，然后使它们相等：

test("test ignoring order"){
  assert(Array(1,2,4,5).sorted sameElements Array(1,4,2,5).sorted)
}

注：
1.如果您正在使用Array以外的其他集合，则可以使用==而不是sameElements。
1.如果其中一个数组有重复项，而另一个没有，则array1.toSet == array2.toSet将不起作用。

这是否按预期工作？

import scala.annotation.tailrec
def equalsIgnoringOrder(first:Array[Int], second:Array[Int]) : Boolean = {

  def removeAtIndex(i:Int, array: Array[Int]) : Array[Int] = {
    val buffer = array.toBuffer
    buffer.remove(i)
    buffer.toArray
  }

  @tailrec
  def firstEqualSecondRec(i:Int, other:Array[Int]) : Boolean = {
    if(other.isEmpty) true
    else {
      val el = first(i)
      val index = other.indexOf(el)
      if(index == -1) false
      else firstEqualSecondRec(i+1, removeAtIndex(index, other))
    }
  }

  if (first.length != second.length) false
  else {
    val startingIndex = 0
    firstEqualSecondRec(startingIndex, second)
  }
}

这是一个更老的线程，但我只是有同样的问题。
所提出的答案包括排序（只对可比较对象有效）或具有O（n^2）运行时行为（和/或非平凡递归）的方法。
另一种（简单但可理解且功能强大）方法是使用Scala的diff函数：

def hasSameElementsUnordered[T](arrA: Array[T], arrB: Array[T]): Boolean = {
    (arrA.length == arrB.length) && (arrA diff arrB).isEmpty
}

顺便说一句，这适用于任何集合和元素类型，而不仅仅是数组和可比较对象。diff（）在内部构建了一个出现计数散列Map，因此运行时行为对于更大的集合会更好。