[SCALA] 어떻게 스칼라에서 배열을 정렬합니까?

어떻게 스칼라에서 배열을 정렬합니까?

나는 정렬 객체 정렬은 그것에 퀵 방법, 퀵, 함께, 거기에 볼 수 있습니다.

어떤 임의의 유형의 오브젝트의 배열을 정렬을 사용하는 코드 예제 있을까? 내가 주문 가능한 특성의 구현에 전달해야 할 것 같습니다,하지만 난 구문의 확신입니다.

또한, 나는 이것을 '스칼라 방법'하고 대답을 선호하는 것이다. 난 그냥 자바 라이브러리를 사용할 수 있습니다 알고 있습니다.

해결법

1. ==============================

   1.Sorting.quickSort는 숫자 나 문자열의 배열을내어 기능을 선언,하지만 난 당신이 당신이 당신의 자신의 클래스의 개체 목록을 정렬 할 의미 겠지?

   Sorting.quickSort는 숫자 나 문자열의 배열을내어 기능을 선언,하지만 난 당신이 당신이 당신의 자신의 클래스의 개체 목록을 정렬 할 의미 겠지?

   기능 당신이보고있는 생각

   quickSort [K](a : Array[K])(implicit view$1 : (K) => Ordered[K]) : Unit
   

   어느, 나는이 권리를 읽고 있어요 경우, 수단이 배열의 개체가 정렬 된 특성이 있어야합니다. 클래스가 순서가 확장해야합니다 (또는 그것을 혼합해야한다), 그래서 때문에 그 특성의 비교 방법을 구현해야합니다.

   그래서이 책에서 예를 벗어 버리고 :

   class MyClass(n: Int) extends Ordered[MyClass] {
      ...
     def compare(that: MyClass) =
       this.n - that.n
   }
   

   그래서 [MyClass에, 다음 Sorting.quickSort 작동합니다 배열을 제공.

2. ==============================

   2.스칼라 2.8 이상은 할 수 있습니다 :

   스칼라 2.8 이상은 할 수 있습니다 :

   List(3,7,5,2).sortWith(_ < _)
   

   즉 java.util.Arrays.sort, 퀵의 구현을 사용한다.

3. ==============================

   3.요즘 이것도 작동합니다 :

   요즘 이것도 작동합니다 :

   목록 (3,7,5,2) .sorted

4. ==============================

   4.당신은 단지 물건을 정렬 할하지만, 특히 정렬 개체에 결혼을하지 않은 경우에는 목록의 정렬 방법을 사용할 수 있습니다. 당신은 당신이 원하는 어떤 종류에 사용할 수 있도록 그것은 인수로 비교 기능을합니다 :

   당신은 단지 물건을 정렬 할하지만, 특히 정렬 개체에 결혼을하지 않은 경우에는 목록의 정렬 방법을 사용할 수 있습니다. 당신은 당신이 원하는 어떤 종류에 사용할 수 있도록 그것은 인수로 비교 기능을합니다 :

   List("Steve", "Tom", "John", "Bob").sort((e1, e2) => (e1 compareTo e2) < 0)
   
   List(1, 4, 3, 2).sort((e1, e2) => (e1 < e2))
   

   목록 아마 배열보다는 "더 scalaish"자격.

   스칼라 API 문서에서 :

5. ==============================

   5.

   val array = Array((for(i <- 0 to 10) yield scala.util.Random.nextInt): _*)
   scala.util.Sorting.quickSort(array)
   

   스칼라의 "기본"배열은 매우 가까운 자바의 배열에, 변경 가능한 데이터 구조입니다. 일반적으로, 그 의미 "배열"가변 데이터 구조가 갈 것 같이 매우 스칼라 틱 없습니다. 그것은 비록 목적을 제공합니다. 배열이 당신의 필요에 맞는 데이터 형식이면 그게 일종의 방법이다. 그런데 객체 정렬 다른 정렬 방법이 있습니다.

   나는 당신이 (이 모든 후, 암시 적이다) 어떤 암시 적 매개 변수를 전달 할 필요가 없습니다 ... 난 그냥 질문이 무엇인지 깨달았다 생각합니다. 즉, 매개 변수는 정렬 된 [K]에 K 타입으로 변환 할 수있는 방법이 있어야한다는 말을하기 위해 존재한다. 당신이 그들을 필요가 없습니다 이러한 정의는 이미 스칼라의 클래스가 존재한다.

   임의의 클래스의 경우 당신은이 방법을 정의 할 수 있습니다 :

   scala> case class Person(name: String)
   defined class Person
   
   scala> val array = Array(Person("John"), Person("Mike"), Person("Abe"))
   array: Array[Person] = Array(Person(John), Person(Mike), Person(Abe))
   
   scala> scala.util.Sorting.quickSort(array)
   <console>:11: error: no implicit argument matching parameter type (Person) => Ordered[Person] was found.
          scala.util.Sorting.quickSort(array)
                                      ^
   scala> class OrderedPerson(val person: Person) extends Ordered[Person] {
        | def compare(that: Person) = person.name.compare(that.name)
        | }
   defined class OrderedPerson
   
   scala> implicit def personToOrdered(p: Person) = new OrderedPerson(p)
   personToOrdered: (p: Person)OrderedPerson
   
   scala> scala.util.Sorting.quickSort(array)
   
   scala> array
   res8: Array[Person] = Array(Person(Abe), Person(John), Person(Mike))
   

   사람은 시작에 주문 된 경우 이제,이 문제가되지 않을 것입니다 :

   scala> case class Person(name: String) extends Ordered[Person] {
        | def compare(that: Person) = name.compare(that.name)
        | }
   defined class Person
   
   scala> val array = Array(Person("John"), Person("Mike"), Person("Abe"))
   array: Array[Person] = Array(Person(John), Person(Mike), Person(Abe))
   
   scala>  scala.util.Sorting.quickSort(array)
   
   scala> array
   res10: Array[Person] = Array(Person(Abe), Person(John), Person(Mike))
   

6. ==============================

   6.허용 대답이 잘못되지 동안, 퀵 방법은보다 더 많은 유연성을 제공한다. 나는 당신을 위해이 예제를 썼다.

   허용 대답이 잘못되지 동안, 퀵 방법은보다 더 많은 유연성을 제공한다. 나는 당신을 위해이 예제를 썼다.

   import System.out.println
   import scala.util.Sorting.quickSort
   
   class Foo(x:Int) {
   def get = x
   }
   
   //a wrapper around Foo that implements Ordered[Foo]
   class OrdFoo(x:Foo) extends Ordered[Foo] {
   def compare(that:Foo) = x.get-that.get
   }
   //another wrapper around Foo that implements Ordered[Foo] in a different way
   class OrdFoo2(x:Foo) extends Ordered[Foo] {
   def compare(that:Foo) = that.get-x.get
   }
   //an implicit conversion from Foo to OrdFoo
   implicit def convert(a:Foo) = new OrdFoo(a)
   
   //an array of Foos
   val arr = Array(new Foo(2),new Foo(3),new Foo(1))
   
   //sorting using OrdFoo
   scala.util.Sorting.quickSort(arr)
   arr foreach (a=>println(a.get))
   /*
   This will print:
   1
   2
   3
   */
   
   //sorting using OrdFoo2
   scala.util.Sorting.quickSort(arr)(new OrdFoo2(_))
   arr foreach (a=>println(a.get))
   /*
   This will print:
   3
   2
   1
   */
   

   일부 클래스에 피트에서 암시 적 및 명시 적 변환 주문을 확장하는 방법이 쇼 [식품] 다른 정렬 순서를 얻을 수 있습니다.

7. ==============================

   7.나는 util을 정렬 사용자에게 선호

   나는 util을 정렬 사용자에게 선호

   예 :

   val arr = Array(7,5,1, 9,2)
   
   scala.util.Sorting.quickSort(arr)
   

   추가 정보를 정렬 UTIL이 읽어 보시기 바랍니다

from https://stackoverflow.com/questions/1131925/how-do-i-sort-an-array-in-scala by cc-by-sa and MIT license