# Sorting in Collection

In computer science, sorting refers to the process of arranging a collection of items in a specific order. In programming, sorting is a fundamental operation that is used in many different applications, such as searching, data analysis, and database management.

There are many algorithms that can be used for sorting a collection of items, including bubble sort, selection sort, insertion sort, merge sort, quicksort, and heapsort. Each algorithm has its own advantages and disadvantages, and the choice of algorithm will depend on the specific requirements of the application.

In Python, the built-in `sorted()` function can be used to sort a collection of items. The `sorted()` function can sort a list, tuple, or any other iterable object. The function takes an iterable as an argument and returns a new sorted list. For example:

```my_list = [4, 2, 1, 3, 5]
sorted_list = sorted(my_list)
print(sorted_list)
```

This will output:

```[1, 2, 3, 4, 5]
```

In addition to the `sorted()` function, Python also provides several other functions for sorting collections, such as the `list.sort()` method, which can be used to sort a list in-place, without creating a new list.

### Method of Collections class for sorting List elements:

In Java, the `Collections` class provides a set of utility methods for working with collections, including sorting lists. The `Collections` class has a static method called `sort()` that can be used to sort the elements of a list in ascending order.

Here is an example of using the `sort()` method to sort a list of integers:

```import java.util.ArrayList;
import java.util.Collections;

public class Main {
public static void main(String[] args) {
ArrayList<Integer> myList = new ArrayList<Integer>();

Collections.sort(myList);

System.out.println(myList);
}
}
```

This will output:

```[1, 2, 3, 4, 5]
```

Note that the `sort()` method modifies the list in place, so the original list is sorted, and no new list is created. The `sort()` method uses the natural ordering of the elements, which means that it will work for any type of object that implements the `Comparable` interface.

If you want to sort the elements in descending order, you can use the `Collections.reverse()` method after sorting the list in ascending order:

```Collections.sort(myList);
Collections.reverse(myList);
```

Alternatively, you can use the overloaded version of the `sort()` method that takes a `Comparator` object. You can create a `Comparator` object that defines the custom ordering you want, and pass it to the `sort()` method:

```Collections.sort(myList, Collections.reverseOrder());
```

This will sort the list in descending order.

### Example to sort string objects:

Sorting strings in Java is similar to sorting other types of objects. You can use the `sort()` method of the `Collections` class to sort a list of strings in ascending order.

Here is an example of sorting a list of strings:

```import java.util.ArrayList;
import java.util.Collections;

public class Main {
public static void main(String[] args) {
ArrayList<String> myList = new ArrayList<String>();

Collections.sort(myList);

System.out.println(myList);
}
}
```

This will output:

```[apple, banana, cherry, date, elderberry]
```

Note that the `sort()` method uses the natural ordering of the strings, which is alphabetical order. If you want to sort the strings in a different order, you can use a `Comparator` object to define the custom ordering.

For example, you can sort the strings in descending order of length, like this:

```import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Main {
public static void main(String[] args) {
ArrayList<String> myList = new ArrayList<String>();

Comparator<String> lengthComparator = new Comparator<String>() {
public int compare(String s1, String s2) {
return s2.length() - s1.length();
}
};

Collections.sort(myList, lengthComparator);

System.out.println(myList);
}
}
```

This will output:

```[elderberry, banana, cherry, apple, date]
```

Here, we define a `Comparator` object that compares strings based on their length, in descending order. We pass this `Comparator` object to the `sort()` method to sort the list of strings accordingly.

### Example to sort string objects in reverse order:

To sort a list of strings in reverse order, you can use the `sort()` method of the `Collections` class, along with the `Comparator.reverseOrder()` method to reverse the natural ordering.

Here is an example of sorting a list of strings in reverse order:

```import java.util.ArrayList;
import java.util.Collections;

public class Main {
public static void main(String[] args) {
ArrayList<String> myList = new ArrayList<String>();

Collections.sort(myList, Collections.reverseOrder());

System.out.println(myList);
}
}
```

This will output:

```[elderberry, date, cherry, banana, apple]
```

Note that we pass `Collections.reverseOrder()` as the second argument to the `sort()` method to sort the list in reverse order.

Alternatively, you can use a custom `Comparator` object to define the reverse ordering. Here is an example:

```import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Main {
public static void main(String[] args) {
ArrayList<String> myList = new ArrayList<String>();

Comparator<String> reverseComparator = new Comparator<String>() {
public int compare(String s1, String s2) {
return s2.compareTo(s1);
}
};

Collections.sort(myList, reverseComparator);

System.out.println(myList);
}
}
```

This will output the same result as before:

```[elderberry, date, cherry, banana, apple]
```

Here, we define a custom `Comparator` object that compares strings in reverse order, by comparing them using the `compareTo()` method in reverse order. We pass this `Comparator` object to the `sort()` method to sort the list of strings accordingly.

### Example to sort Wrapper class objects:

Sorting wrapper class objects in Java is similar to sorting other types of objects. You can use the `sort()` method of the `Collections` class to sort a list of wrapper class objects in ascending order.

Here is an example of sorting a list of `Integer` wrapper class objects:

```import java.util.ArrayList;
import java.util.Collections;

public class Main {
public static void main(String[] args) {
ArrayList<Integer> myList = new ArrayList<Integer>();

Collections.sort(myList);

System.out.println(myList);
}
}
```

This will output:

```[1, 2, 3, 4, 5]
```

Note that the `sort()` method uses the natural ordering of the integers, which is numerical order. If you want to sort the integers in a different order, you can use a `Comparator` object to define the custom ordering.

For example, you can sort the integers in descending order, like this:

```import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Main {
public static void main(String[] args) {
ArrayList<Integer> myList = new ArrayList<Integer>();

Comparator<Integer> reverseComparator = new Comparator<Integer>() {
public int compare(Integer i1, Integer i2) {
return i2 - i1;
}
};

Collections.sort(myList, reverseComparator);

System.out.println(myList);
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Main {
public static void main(String[] args) {
ArrayList<Integer> myList = new ArrayList<Integer>();

Comparator<Integer> reverseComparator = new Comparator<Integer>() {
public int compare(Integer i1, Integer i2) {
return i2 - i1;
}
};

Collections.sort(myList, reverseComparator);

System.out.println(myList);
}
}
```

This will output:

```[5, 4, 3, 2, 1]
```

Here, we define a `Comparator` object that compares integers in reverse order, by subtracting the second integer from the first integer. We pass this `Comparator` object to the `sort()` method to sort the list of integers accordingly.

### Example to sort user-defined class objects:

To sort a list of user-defined objects in Java, you can use the `sort()` method of the `Collections` class, along with a custom `Comparator` object that defines the ordering of the objects.

Here is an example of sorting a list of `Person` objects based on their age:

```import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class Person {
private String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}
}

public class Main {
public static void main(String[] args) {
ArrayList<Person> people = new ArrayList<Person>();

Comparator<Person> ageComparator = new Comparator<Person>() {
public int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
};

Collections.sort(people, ageComparator);

for (Person person : people) {
System.out.println(person.getName() + " " + person.getAge());
}
}
}
```

This will output:

```Charlie 20
Alice 25
Eve 27
Bob 30
Dave 35
```

Here, we define a `Person` class with `name` and `age` fields. We then create a list of `Person` objects and add them to an `ArrayList`. We define a `Comparator` object that compares `Person` objects based on their age. We pass this `Comparator` object to the `sort()` method to sort the list of `Person` objects based on their age.

You can modify the `Comparator` object to define the ordering of the `Person` objects based on different criteria, such as their name or a combination of their name and age.