I have a data class with about 20 fields:
data class Entry {
entryType: string,
order: int
....
}
now an array is created with the class
val entries = listOf<Entry>(...);
basically, I want to sort the array but user can specify any field they want to sort by. My current attempt appears to be repetitive.
fun sortByOrder(){
entries.sortedWith {f: Entry, s: Entry ->
if (f.order != s.order) {
f.order - s.order
} else {
f.entryType.compareTo(s.entryType)
}
}
}
I couldn’t find away of having one method like below that can do it dynamically:
fun sortEntries(fieldName: string, fieldType: string, backUpField: string){
if (fieldType == 'number'){
entries.sortedWith {f: Entry, s: Entry ->
if (f[fieldName] != s[fieldName]) {
f[fieldName] - s[fieldName]
} else {
f[backUpField].compareTo(s[backUpField])
}
}
}
}
how can I achieve something like the above?
>Solution :
To sort an array dynamically based on a specific field, you can use the Comparator interface and reflection to access the values of the specified field.
Here’s an example implementation:
fun sortEntries(fieldName: String, fieldType: String, backUpField: String) {
val comparator = Comparator<Entry> { f, s ->
val field = Entry::class.members.find { it.name == fieldName }
if (field != null && field.returnType.toString() == fieldType) {
val fValue = field.call(f)
val sValue = field.call(s)
if (fValue != sValue) {
when (fieldType) {
"Int" -> (fValue as Int) - (sValue as Int)
"Double" -> (fValue as Double).compareTo(sValue as Double)
else -> (fValue as String).compareTo(sValue as String)
}
} else {
val backupField = Entry::class.members.find { it.name == backUpField }
if (backupField != null) {
(backupField.call(f) as String).compareTo(backupField.call(s) as String)
} else {
0
}
}
} else {
0
}
}
entries = entries.sortedWith(comparator)
}
The sortEntries function takes three parameters: fieldName, the name of the field to sort by; fieldType, the type of the field (either "Int", "Double", or "String"); and backUpField, the name of a backup field to use in case two entries have the same value for the field being sorted.
The function first creates a Comparator that compares two Entry objects based on the specified field and backup field. It uses reflection to access the field values of the two objects, and compares them using the appropriate comparison function based on the field type.
The sortedWith function is then called on the entries list, passing in the comparator to sort the list based on the specified field and backup field.
Note that using reflection can be slow, so if performance is a concern, you may want to consider other alternatives, such as using a switch statement instead of a when expression to compare values of different types, or creating a separate Comparator implementation for each field type.
Here’s a refactored version of the code that should be more optimized:
fun sortEntries(fieldName: String, fieldType: String, backupFieldName: String) {
val comparator = Comparator<Entry> { first, second ->
val field = Entry::class.memberProperties.find { it.name == fieldName }
val backupField = Entry::class.memberProperties.find { it.name == backupFieldName }
if (field == null || field.returnType.toString() != fieldType) {
return@Comparator 0
}
val fieldValue = field.get(first) as? Comparable<*> ?: return@Comparator 0
val secondFieldValue = field.get(second) as? Comparable<*> ?: return@Comparator 0
if (fieldValue != secondFieldValue) {
fieldValue.compareTo(secondFieldValue)
} else {
val backupFieldValue = backupField?.get(first) as? String ?: ""
val secondBackupFieldValue = backupField?.get(second) as? String ?: ""
backupFieldValue.compareTo(secondBackupFieldValue)
}
}
entries = entries.sortedWith(comparator)
}
Here are the changes that I made:
- used memberProperties instead of members to only consider the properties of the Entry class, not its functions.
- combined the two checks for field being null and field.returnType being equal to fieldType into a single if statement.
- used
as? Comparable<*>to safely cast the field values to Comparable, and returned 0 if the cast failed. - used null-safe operators (?.) to safely access the backup field values, and used an empty string as a default value if the backup field was not found.
- simplified the if statement to return the result of fieldValue.compareTo(secondFieldValue) directly if the two field values are not equal.
Here’s a version that eliminates the duplication:
fun sortEntries(fieldName: String, fieldType: String, backupFieldName: String) {
val comparator = Comparator<Entry> { first, second ->
val field = Entry::class.memberProperties.find { it.name == fieldName }
val backupField = Entry::class.memberProperties.find { it.name == backupFieldName }
fun getValue(entry: Entry, property: KProperty1<Entry, *>): Any? {
return property.get(entry)?.takeIf { it is Comparable<*> } ?: null
}
val fieldValue = getValue(first, field) as? Comparable<*>
val secondFieldValue = getValue(second, field) as? Comparable<*>
if (fieldValue == null || secondFieldValue == null) {
return@Comparator 0
}
if (fieldValue != secondFieldValue) {
fieldValue.compareTo(secondFieldValue)
} else {
val backupFieldValue = backupField?.let { getValue(first, it) as? String } ?: ""
val secondBackupFieldValue = backupField?.let { getValue(second, it) as? String } ?: ""
backupFieldValue.compareTo(secondBackupFieldValue)
}
}
entries = entries.sortedWith(comparator)
}
Here are the changes I made:
I extracted the common logic for getting the field values to a separate getValue function that takes an Entry object and a KProperty1 object representing the field to get the value for. This function returns the value of the field if it is a Comparable type, and returns null otherwise.
I used let to safely call getValue on the backup field, and used an empty string as a default value if the backup field was not found.
Regarding the time complexity of the algorithm, the sortedWith function uses a stable sorting algorithm, which typically has an average-case time complexity of O(n log n), where n is the size of the entries list. The comparator function is called for every comparison during the sort, so its complexity is also O(n log n) in the average case. The getValue function is called for each field and entry, so its complexity is O(mn), where m is the number of fields and n is the size of the entries list. In practice, however, the performance will depend on the specific data and the hardware it’s run on.
We can avoid code duplication and improve performance by extracting the logic for getting the values of the fields and backup fields into separate functions, and then using those functions in the comparator. Here’s an updated version of the code that does that:
fun sortEntries(fieldName: String, fieldType: String, backupFieldName: String) {
fun getField(entry: Entry, fieldName: String): Any? {
val field = Entry::class.memberProperties.find { it.name == fieldName }
return field?.get(entry)?.takeIf { it is Comparable<*> }
}
fun getBackupField(entry: Entry, backupFieldName: String): String {
val backupField = Entry::class.memberProperties.find { it.name == backupFieldName }
return backupField?.get(entry) as? String ?: ""
}
val comparator = Comparator<Entry> { first, second ->
val fieldValue = getField(first, fieldName) as? Comparable<*>
val secondFieldValue = getField(second, fieldName) as? Comparable<*>
if (fieldValue == null || secondFieldValue == null) {
return@Comparator 0
}
if (fieldValue != secondFieldValue) {
fieldValue.compareTo(secondFieldValue)
} else {
val backupFieldValue = getBackupField(first, backupFieldName)
val secondBackupFieldValue = getBackupField(second, backupFieldName)
backupFieldValue.compareTo(secondBackupFieldValue)
}
}
entries = entries.sortedWith(comparator)
}
By using these optimizations, the code should be faster and more concise, while still maintaining its functionality.
The getField function takes an Entry object and a field name, and returns the value of the field if it is a Comparable type, or null otherwise.
The getBackupField function takes an Entry object and a backup field name, and returns the value of the backup field as a string. If the backup field is not found or its value is not a string, it returns an empty string.
The sortEntries function uses these two functions to get the field values and backup field values, and then compares them to sort the entries.
With these changes, we have eliminated the code duplication, improved the readability of the code, and also slightly improved the performance by avoiding unnecessary calls to reflection.
The time complexity of the sortEntries function remains O(n log n), where n is the size of the entries list, since the sorting algorithm has a time complexity of O(n log n).
The complexity of the getField function is O(1) on average, since it only needs to perform a linear search through the list of properties once to find the field, and then it simply returns the value of the field.
The complexity of the getBackupField function is also O(1) on average, since it only needs to perform a linear search through the list of properties once to find the backup field, and then it either returns the string value of the field, or an empty string if the field is not a string.
Therefore, the overall time complexity of the comparator function used in the sortedWith method is O(1) for getting the field values and backup field values, and O(log n) for comparing them. In practice, the performance will depend on the specific data and hardware it’s run on.