Arrays Swift-对数组的子集进行排序

我目前有一个有很多用户的tableview，但我想按照特定的顺序对用户进行排序，而不仅仅是升序或降序。假设我有一个包含以下用户的数组

"User1", "1st grade"
"User2", "1st grade"
"User3", "kids"
"User4", "6th grade"
"User5", "5th grade"
"User6", "2nd grade"
"User7", "kids"
"User8", "juniors"

我如何对数组进行排序，以便首先显示儿童班的所有学生，然后是所有带数字的班级（按顺序），然后是所有大三学生

我想要一个可以显示此内容的数组

"User3", "kids"
"User7", "kids"
"User1", "1st grade"
"User2", "1st grade"
"User6", "2nd grade"
"User5", "5th grade"
"User4", "6th grade"
"User8", "juniors"

编辑： 更新了文本以明确数组有两列，而不仅仅是一个字符串

我们能够通过使用下面的行来实现它

let sortedArray = 
self.userArray.sorted(by: { $0.SchoolGrade!.gradeLongName().contains("Kids") || 
$1.SchoolGrade!.gradeLongName().contains("Juniors") })

---

您应该创建三个单独的数组，使用

filter

获得适当的结果，然后分别对它们进行排序。然后，您应该通过一个简单的附加操作将这三个数组连接起来。

您应该创建三个单独的数组，使用

过滤器获得适当的结果，然后分别对它们进行排序。之后，您应该通过一个简单的附加操作将三个数组连接起来。
您尝试排序的不是常见的排序例程。因此，首先，检查您的数据结构以获得更好的排序解决方案

但是，如果您坚持使用字符串列表进行排序，那么您可以尝试以下代码（非常难看），这些代码可以在操场上运行：

import UIKit

var array = [String]()
array.append("User1, 1st grade")
array.append("User2, 1st grade")
array.append("User3, kids")
array.append("User4, 6th grade")
array.append("User5, 5th grade")
array.append("User6, 2nd grade")
array.append("User7, kids")
array.append("User8, Juniors")

let kidsArray = array.filter { $0.lowercased().contains("kids") }.sorted()
let gradeArray = array.filter { $0.lowercased().contains("grade") }.sorted { $0.components(separatedBy: ",").last! < $1.components(separatedBy: ",").last! }
let juniorArray = array.filter { $0.lowercased().contains("juniors") }.sorted()

var finalArray = [String]()
finalArray.append(contentsOf: kidsArray)
finalArray.append(contentsOf: gradeArray)
finalArray.append(contentsOf: juniorArray)

print(finalArray)

导入UIKit
变量数组=[String]（）
array.append（“User1，一年级”）
array.append（“User2，1年级”）
append（“User3，kids”）
array.append（“User4，6年级”）
array.append（“User5，5年级”）
array.append（“User6，二年级”）
append（“User7，kids”）
append（“User8，Juniors”）
让kidsArray=array.filter{$0.lowercased（）.contains（“kids”）}.sorted（）
让gradeArray=array.filter{$0.lowercased（）。包含（“grade”）}。已排序的{$0.components（分隔符：“，”）。last！<$1.components（分隔符：“，”）。last！}
让juniorArray=array.filter{$0.lowercased（）.contains（“juniors”）}.sorted（）
var finalArray=[String]（）
追加（内容：kidsArray）
追加（contentsOf:gradeArray）
append（contentsOf:juniorArray）
打印（最终版本）

打印：

[“用户3，孩子”，“用户7，孩子”，“用户1，一年级”，“用户2，一年级”，“用户6，二年级”，“用户5，五年级”，“用户4，六年级”，“用户8，三年级学生”]
您尝试排序的不是常见的排序例程。因此，首先，检查您的数据结构以获得更好的排序解决方案

但是，如果您坚持使用字符串列表进行排序，那么您可以尝试以下代码（非常难看），这些代码可以在操场上运行：

import UIKit

var array = [String]()
array.append("User1, 1st grade")
array.append("User2, 1st grade")
array.append("User3, kids")
array.append("User4, 6th grade")
array.append("User5, 5th grade")
array.append("User6, 2nd grade")
array.append("User7, kids")
array.append("User8, Juniors")

let kidsArray = array.filter { $0.lowercased().contains("kids") }.sorted()
let gradeArray = array.filter { $0.lowercased().contains("grade") }.sorted { $0.components(separatedBy: ",").last! < $1.components(separatedBy: ",").last! }
let juniorArray = array.filter { $0.lowercased().contains("juniors") }.sorted()

var finalArray = [String]()
finalArray.append(contentsOf: kidsArray)
finalArray.append(contentsOf: gradeArray)
finalArray.append(contentsOf: juniorArray)

print(finalArray)

导入UIKit
变量数组=[String]（）
array.append（“User1，一年级”）
array.append（“User2，1年级”）
append（“User3，kids”）
array.append（“User4，6年级”）
array.append（“User5，5年级”）
array.append（“User6，二年级”）
append（“User7，kids”）
append（“User8，Juniors”）
让kidsArray=array.filter{$0.lowercased（）.contains（“kids”）}.sorted（）
让gradeArray=array.filter{$0.lowercased（）。包含（“grade”）}。已排序的{$0.components（分隔符：“，”）。last！<$1.components（分隔符：“，”）。last！}
让juniorArray=array.filter{$0.lowercased（）.contains（“juniors”）}.sorted（）
var finalArray=[String]（）
追加（内容：kidsArray）
追加（contentsOf:gradeArray）
append（contentsOf:juniorArray）
打印（最终版本）

打印：

[“User3，kids”，“User7，kids”，“User1，1年级”，“User2，1年级”，“User6，2年级”，“User5，5年级”，“User4，6年级”，“User8，Juniors”]
Swift有一种排序算法，允许您使用闭包进行排序。如果第一个参数在第二个参数之前，则闭包应返回true

let sortedArray = user.sorted(by: {

    ($0.gradeLongName().contains("kids") 
     || $1.gradeLongName()contains("juniors")  
     || $0.gradeLongName() < $1.gradeLongName())
    && !($0.gradeLongName().contains("kids") && $1.gradeLongName().contains("kids"))
    && !($0.gradeLongName().contains("juniors") && $1.gradeLongName().contains("juniors"))
})

让sortedArray=user.排序（按：{
（$0.gradeLongName（）.contains（“孩子”）
||$1.gradeLongName（）包含（“juniors”）
||$0.gradeLongName（）<$1.gradeLongName（））
&&！（$0.gradeLongName（）.contains（“kids”）和&$1.gradeLongName（）.contains（“kids”））
&&！（$0.gradeLongName（）.contains（“juniors”）和&$1.gradeLongName（）.contains（“juniors”））
})

我们应该做到这一点。结束语说两个元素的顺序是正确的，如果第一个元素中有孩子，第二个元素中有大三学生，或者它们的字母顺序是正确的。当两个元素都有子元素或都有JUnitor（这是API的要求）时，最后两个子表达式使闭包返回false

您也可以在此处使用尾随闭包语法：

let sortedArray = user.sorted{ ($0.gradeLongName().contains("kids") 
     || $1.gradeLongName()contains("juniors")  
     || $0.gradeLongName() < $1.gradeLongName())
    && !($0.gradeLongName().contains("kids") && $1.gradeLongName().contains("kids")
    && !(($0.gradeLongName().contains("juniors") && $1.gradeLongName().contains("juniors")) }

let sortedArray=user.sorted{（$0.gradeLongName（）.contains）（“kids”）
||$1.gradeLongName（）包含（“juniors”）
||$0.gradeLongName（）<$1.gradeLongName（））
&&！（$0.gradeLongName（）.contains（“儿童”）和&$1.gradeLongName（）.contains（“儿童”）
&&！（$0.gradeLongName（）.contains（“juniors”）和&$1.gradeLongName（）.contains（“juniors”））

您还可以使用
sort（by:）

API文档在这里：
Swift有一个排序算法，允许您使用闭包进行排序。如果第一个参数在第二个参数之前，则闭包应返回true

let sortedArray = user.sorted(by: {

    ($0.gradeLongName().contains("kids") 
     || $1.gradeLongName()contains("juniors")  
     || $0.gradeLongName() < $1.gradeLongName())
    && !($0.gradeLongName().contains("kids") && $1.gradeLongName().contains("kids"))
    && !($0.gradeLongName().contains("juniors") && $1.gradeLongName().contains("juniors"))
})

让sortedArray=user.排序（按：{
（$0.gradeLongName（）.contains（“孩子”）
||$1.gradeLongName（）包含（“juniors”）
||$0.gradeLongName（）<$1.gradeLongName（））
&&！（$0.gradeLongName（）.contains（“kids”）和&$1.gradeLongName（）.contains（“kids”））
&&！（$0.gradeLongName（）.contains（“juniors”）和&$1.gradeLongName（）.contains（“juniors”））
})

应该这样做。闭包说两个元素的顺序正确，如果第一个元素中有子元素，第二个元素中有junior，或者它们的字母顺序正确。当两个元素都有子元素或都有junior时，后两个子表达式使闭包返回false，这是API的要求

您也可以在此处使用尾随闭包语法：

let sortedArray = user.sorted{ ($0.gradeLongName().contains("kids") 
     || $1.gradeLongName()contains("juniors")  
     || $0.gradeLongName() < $1.gradeLongName())
    && !($0.gradeLongName().contains("kids") && $1.gradeLongName().contains("kids")
    && !(($0.gradeLongName().contains("juniors") && $1.gradeLongName().contains("juniors")) }

let sortedArray=user.sorted{（$0.gradeLongName（）.contains）（“kids”）
||$1.gradeLongName（）包含（“juniors”）
||0.5美元