Added list sorting technique in details

ashikuzzaman-ar · ashikuzzaman-ar · commit 49c8cb34c195 · 2016-11-04T02:04:31.000+06:00
diff --git a/11.md b/11.md
@@ -82,7 +82,7 @@ import java.util.LinkedList;
 import java.util.Vector;
 public class Main {
     public static void main(String[] args) {
-        List list;
+        List list, list2, list3;
         list = new ArrayList();
         list2 = new LinkedList();
         list3 = new Vector();
@@ -216,4 +216,260 @@ list.remove(new Integer(13));
 এরকম আরো বেশ কিছু মেথড এবং তাদের বিস্তর ব্যাখ্যা ওরাকলের অফিসিয়াল ডকুমেন্টেশন সাইটে পাওয়া যাবে । আগ্রহীরা সেখান থেকে দেখে নিতে পারেন । লিংকঃ http://docs.oracle.com/javase/8/docs/api/java/util/List.html 
 
 
+**লিস্ট সর্ট করা(Sort a List)**
 
+কোন একটি লিস্টকে সর্ট করার চেয়ে সহজ বিষয় আর কিছু হতেই পারেনা । তবে সমস্যা হল একটি লিস্টকে সর্ট করার নানাবিধ উপায় থাকায় আপনি কনফিউজ হয়ে যেতে পারেন যে আসলে কক্ষন কোন পদ্ধতিতে সর্ট করবেন । আমি নিজেও মাঝে মাঝে কনফিউজ হয়ে যাই । যাইহোক আমরা লিস্ট সর্টিং এর একেবারে বেসিক থেকে ধীরে ধীরে সামনের দিকে এগিয়ে যাব । বলে রাখা ভালো আমরা এখানে বেসিক্যালি ২ প্রকারের সর্টিং টেকনিক দেখবো এবং তাদের আবার ২ প্রকার সাব সর্টিং টেকনিক দেখবো । আগ্রহীরা আরো কিছুটা ঘাটাঘাটি করলে আরো অনেক কিছুই জানতে পারবে । 
+
+পদ্ধতি ১ঃ 
+
+```java
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+public class Main {
+
+    public static void main(String[] args) {
+
+        List<Integer> list = new ArrayList<>();
+        list.add(7);
+        list.add(5);
+        list.add(13);
+        list.add(17);
+        list.add(3);
+        
+        Collections.sort(list);
+        
+        list.forEach((x) -> {
+            System.out.println(x);
+        });
+    }
+}
+```
+
+এখানে আমরা `Collections` ক্লাসের একটি মেথড `sort` যেটি ইনপুট প্যারামিটার হিসাবে একটি লিস্ট অবজেক্ট নেয় এবং সেটিকে ইনপ্লেস সর্ট করে দেয় । অর্থাৎ এই মেথডের রিটার্ন টাইপ ভয়েড । এবং এটি অ্যাসেন্ডিং ( ছোট থেকে ক্রমান্বয়ে বড় ) অর্ডারে সর্ট করে । 
+
+আমরা যদি ডিসেন্ডিং অর্ডারে সর্ট করতে চাই তবে আমাদের আরেকটু কাজ বেশি করতে হবে । আর সেটি হল `sort` নামক মেথডে আরেকটি প্যারামিটার পাস করতে হবে যেটি আসলে একটি `Comparator` অবজেক্ট । যেটার মাধ্যমে আমরা বলে দিব যে আসলে সর্টটি কোন অর্ডারে হবে বা কোন এলিমেন্টের সাপেক্ষে হবে । কোডটিকে সেক্ষেত্রে আমরা এভাবে লিখতে পারতাম,
+
+```java
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        List<Integer> list = new ArrayList<>();
+        list.add(7);
+        list.add(5);
+        list.add(13);
+        list.add(17);
+        list.add(3);
+        
+        Comparator<Integer> comparator = new Comparator<Integer>() {
+            @Override
+            public int compare(Integer t1, Integer t2) {
+                return t2-t1;
+            }
+        };
+        
+        Collections.sort(list, comparator);
+        
+        list.forEach((x) -> {
+            System.out.println(x);
+        });
+    }
+}
+```
+
+উল্লেখ্য এখানে `Comparator` একটি ইন্টারফেস এবং এবং `compare` একটি `abstract` মেথড তাই আমাদের এটিকে ইমপ্লিমেন্ট করতে হয়েছে । ‍`compare` মেথডটি একটি ইন্টিজার নাম্বার রিটার্ন করে । দুটি অ্যাট্রিবিউটের মাঝে কম্পেয়ার করে পজেটিভ, নেগেটিভ বা শুন্য রিটার্ন করে । শুন্য রিটার্ন করা মানে দুটি সমান । পজেটিভ রিটার্ন করা মানে প্রথমটি বড় আর অন্যথায় ছোট । 
+আমরা আলাদা ভাবে `Comparator` এর অবজেক্ট ক্রিয়েট না করেও কাজটি করতে পারতাম ইনপ্লেসে । সেক্ষেত্রে এরকম হতে পারত,
+
+```java
+        Collections.sort(list, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer t, Integer t1) {
+                return t1-t;
+            }
+        });
+```
+
+বর্তমান সময় যেহেতু ল্যামডা এক্সপ্রেশনের যুগ চলছে তাই এটিকে আরো সহজে এবং খুব সংক্ষেপে এভাবেও লেখা যেত,
+
+```java
+        Collections.sort(list, (Integer t1, Integer t2) -> t2-t1);
+```
+
+কাজ বেসিক্যালি সব একই ভাবে করছে । 
+
+
+এতক্ষন আমরা দেখলাম প্রিমিটিভ টাইপের ডাটার একটি লিস্ট সর্ট করা । এমনতো হতেই পারে যে আপনার কাছে একটি কাষ্ট টাইপের অবজেক্ট কনটেইন করে এমন একটি লিস্ট সর্ট করতে হবে ওই অবজেক্টের নির্দিষ্ট কোন এক বা একাধিক প্রপার্টির সাপেক্ষে । সেক্ষেত্রে করনীয় কি সেটা এবার চলুন দেখে ফেলি ।
+
+
+```java
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+class Employee {
+
+    int id;
+    String name;
+    int age;
+    int salary;
+
+    public Employee(int id, String name, int age, int salary) {
+        this.id = id;
+        this.name = name;
+        this.age = age;
+        this.salary = salary;
+    }
+}
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        List<Employee> list = new ArrayList<>();
+        list.add(new Employee(1, "Abul", 27, 35000));
+        list.add(new Employee(2, "Babul", 25, 37000));
+        list.add(new Employee(3, "Kabul", 29, 30000));
+        list.add(new Employee(4, "Mofiz", 24, 36000));
+        list.add(new Employee(5, "Hafiz", 28, 34000));
+
+        Collections.sort(list, new Comparator<Employee>(){
+            @Override
+            public int compare(Employee t, Employee t1) {
+                return t.age - t1.age;
+            }
+        });
+
+        list.forEach((x) -> {
+            System.out.println(x.salary);
+        });
+    }
+}
+```
+
+ঠিক আগের মতই কাজ করতে পারবেন । তবে এখানে অবজেক্ট নিয়ে কাজ করতে হবে । এবং অবজেক্টের কোন ফিল্ডের রেসপেক্টে সর্ট করতে চাচ্ছেন সেটাও ডিফাইন করে দিতে হবে । অ্যাসেন্ডিং বা ডিসেন্ডিং যেকোন ভাবেই সর্ট করতে পারবে । এমনকি একাধিক ফিল্ডের রেসপেক্টে যদি সর্ট করতে চান সেটাও করতে পারবে । আপনারা চাইলে ল্যামডা এক্সপ্রেশন ব্যাবহার করতে পারতেন সেক্ষেত্রে এরকম হতো কোডটি,
+
+```java
+        Collections.sort(list, (Employee t, Employee t1) -> t1.age – t.age);//descending order
+```
+
+
+এবার আমরা একটু ভিন্ন একটা পদ্ধতি দেখবো । যদি এমন হয় যে আমাদের এই ক্লাসটি প্রায়ই সর্ট করতে হয় এবং নির্দিষ্ট একটা অর্ডারে সর্ট করতে হয় , সেক্ষেত্রে আমরা একটা বিশেষ কাজ করতে পারি । আমরা `Comparable` ইন্টারফেসটি ইমপ্লিমেন্ট করতে পারি । `Comparable` ইন্টারফেসের মাঝে `compareTo` মেথডটি অভাররাইড করলেই কাজ শেষ । অ্যাসেন্ডিং বা ডিসেন্ডিং আগের মতই । তবে চলুন দেখি কিভাবে সেটি করা যায় সেটি দেখে ফেলি ।
+
+
+```java
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+class Employee implements Comparable<Employee> {
+
+    int id;
+    String name;
+    int age;
+    int salary;
+
+    public Employee(int id, String name, int age, int salary) {
+        this.id = id;
+        this.name = name;
+        this.age = age;
+        this.salary = salary;
+    }
+
+    @Override
+    public int compareTo(Employee t) {
+        return this.age - t.age;
+    }
+}
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        List<Employee> list = new ArrayList<>();
+        list.add(new Employee(1, "Abul", 27, 35000));
+        list.add(new Employee(2, "Babul", 25, 37000));
+        list.add(new Employee(3, "Kabul", 29, 30000));
+        list.add(new Employee(4, "Mofiz", 24, 36000));
+        list.add(new Employee(5, "Hafiz", 28, 34000));
+
+        Collections.sort(list);
+
+        list.forEach((x) -> {
+            System.out.println(x.id + ", " + x.name + ", " + x.age + ", " + x.salary);
+        });
+    }
+}
+```
+
+এভাবে খুব সহজেই আমরা একটি অবজেক্টের লিস্ট সর্ট করতে পারি । তবে একটি বিষয় লক্ষ করার মত বিষয় হচ্ছে যে আপনাদের যে ২ প্রকারের সর্ট দেখানো হয়েছে অবজেক্টের লিস্টের ক্ষেত্রে এই দুই প্রকার কিন্তু একত্রেও ব্যাবহার করতে পারবেন । তবে সেক্ষেত্রে প্রায়োরিটি পাবে ক্লোজার ফাংশন । চলুন দেখি বিষয়টা কি একটু দেখে নেই । 
+
+```java
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+class Employee implements Comparable<Employee> {
+
+    int id;
+    String name;
+    int age;
+    int salary;
+
+    public Employee(int id, String name, int age, int salary) {
+        this.id = id;
+        this.name = name;
+        this.age = age;
+        this.salary = salary;
+    }
+
+    @Override
+    public int compareTo(Employee t) {
+        return this.age - t.age;
+    }
+}
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        List<Employee> list = new ArrayList<>();
+        list.add(new Employee(1, "Abul", 27, 35000));
+        list.add(new Employee(2, "Babul", 25, 37000));
+        list.add(new Employee(3, "Kabul", 29, 30000));
+        list.add(new Employee(4, "Mofiz", 24, 36000));
+        list.add(new Employee(5, "Hafiz", 28, 34000));
+
+        Collections.sort(list, ((Employee e1, Employee e2) -> (e2.salary + e1.salary)));
+
+        list.forEach((x) -> {
+            System.out.println(x.id + ", " + x.name + ", " + x.age + ", " + x.salary);
+        });
+    }
+}
+```
+
+এখানে যদিও `Employee` ক্লাস `Comparable` ইন্টারফেস ইমপ্লিমেন্ট করেছে এবং `compareTo` মেথডে বলে দেওয়া হয়েছে `age` এর অ্যাসেন্ডিং অর্ডারে সর্ট করতে হবে কিন্তু এটি সর্ট করবে `salary` এর ডিসেন্ডিং অর্ডারে । কেন সেটা করছে সেটা নিশ্চয় বুঝতে পেরেছেন । 
+
+আপনারা চাইলে কিন্তু `List` এর অন্তর্গত `sort` মেথড ব্যাবহার করেও সর্ট করতে পারতেন । সেটা করার জন্য খুব বেশি কিছুই করতে হতনা । সেটি অলরেডি আপনারা জানেন কিভাবে সেটি করা যায় ।
+
+```java
+        list.sort(new Comparator<Employee>(){
+            @Override
+            public int compare(Employee t, Employee t1) {
+                return t1.age - t.age;
+            }
+            
+        });
+```
+
+বেসিক্যালি এভাবে খুব সহজেই একটি লিস্ট সর্ট করা যায় । আপনারা আরো বেশি আগ্রহী হলে ওরাকলের ডকুমেন্টেশন পড়তে পারেন । আরো বেশি পরিষ্কার হবে ধারনা । 
+
+
+#–-------চলবে--------#
