Arrays

ပြီးခဲ့သော အခန်းဆက်ဖြင့် Collections Framework နှင့် ၎င်းတွင်ပါဝင်သော Interface များ အကြောင်းကို ဖော်ပြခဲ့၏။ ယခု အခန်းတွင် ကိန်းစဉ် (Array) များအား အသုံးချနိုင်သော Utility Class အကြောင်းကို ဖော်ပြသွားပါမည်။

ကိန်းစဉ်များအား အသုံးပြုသော Class

java.util.Arrays သည် ကိန်းစဉ်များအား အသုံးပြုရာတွင် အသုံးဝင်သော လုပ်ဆောင်ချက်များအား စုစည်းထားသော Utility Class တစ်မျိုး ဖြစ်၏။ int, double အစရှိသော Primitive Type ကိန်းစဉ် (Array) များအား အသုံးပြုနိုင်ရန် လုပ်ဆောင်ချက်များကို Overload လုပ်ထားသော်လည်း အခြေခံအားဖြင့် လုပ်ဆောင်ချက် ၅မျိုးကို ပံ့ပိုးထား၏။



ကိန်းစဉ်များအား Sort လုပ်ခြင်း


ကိန်းစဉ်အတွင်းရှိ ကိန်းများအား အကြီးအသေး စီစဉ်ရာတွင် အသုံးပြုပါသည်။

static void sort(Object [] obj)

အခြားသော Parameter များ မပါဝင်ပါက ကြီးရာသို့ စီစဉ်သွားမည်ဖြစ်ပြီး၊ အသုံးပြုသည့် အလဂိုရီဇင်မှာ Quick Sort ဖြစ်၏။

static <T> void sort(T [] t, Comparator<? super T> c)

Comparator အား အသုံးပြုခြင်းအားဖြင့် ကိန်းစဉ်အတွင်းရှိ Object များအား နှစ်သက်သလို ပြောင်းလည်း စီစဉ် (sort) နိုင်ပါသည်။

SortSample_01.java

import java.util.Arrays;
import java.util.Comparator;

public class SortSample_01 {

 public static void main(String[] args) {

  wirte("Before sorting:", DATAS);
  
  Arrays.sort(DATAS, new Comparator<Data>() {
   @Override
   public int compare(Data o1, Data o2) {
    return o2.getAge() - o1.getAge();
   }
  });
  
  wirte("After sorting:", DATAS);
  
 }
 
 static void wirte(String title, Data[] datas) {
  System.out.println(title);
  for(Data d : datas) {
   System.out.println(d.getAge() + " : " + d.getName());
  }
 }
 
 static Data [] DATAS;
 
 static {
  DATAS = new Data[3];
  DATAS[0] = new Data("Mg Mg",21);
  DATAS[1] = new Data("Mg BA",25);
  DATAS[2] = new Data("Mg HLA",20);
 }
 
 static class Data {
  String name;
  int age = 0;
  
  Data(String name, int age) {
   this.name = name;
   this.age = age;
  }
  
  String getName() {
   return this.name;
  }
  
  int getAge() {
   return this.age;
  }
 }
}

အထက်ပါ နမှုနာထဲတွင် Data Object ကိန်းစဉ်အား ၎င်း၏ age ၏ အစီအစဉ်အတိုင်း စီစဉ်စေပါသည်။ စီစဉ်ရာမှာကြီးရာမှ ငယ်ရာသို့ စီစဉ်စေလိုပါသဖြင့် စာကြောင်း ၁၀မှ ၁၅အထိ Comparator ကို အသုံးပြု ရေးသားထားပါတယ်။

ရလာသော ရလဒ်မှာ အောက်ပါအတိုင်း ဖြစ်ပါသည်။

Before sorting:
21 : Mg Mg
25 : Mg BA
20 : Mg HLA
After sorting:
25 : Mg BA
21 : Mg Mg
20 : Mg HLA

တဖန် အောက်ပါအတိုင်း ကိန်းစဉ်အတွင်းရှိ အချက်အလက်များကိုလည်း အစနံပါတ်နှင့် အဆုံးနံပါတ်ကို အသုံးပြုကာ အစိတ်အပိုင်းတစ်ခုတည်းကိုလည်း ပြန်လည်စီစဉ် နိုင်၏။

static void sort(Object[] a, int fromIndex, int toIndex)
static void sort(T[] a, int fromIndex, int toIndex, Comparator c)

Binary Search


ကိန်းစဉ်တစ်ခုအတွင်း အချက်အလက်တစ်ခုအား ရှာဖွေရာတွင် အသုံးပြုနိုင်ပါသည်။ ပဋ္ဌမမြောက် ပါရာမီတာ (Parameter) အတွင်းရှိ အချက်အလက်များအတွင်းမှ key object အား binary search အလဂိုရီဇင်အား အသုံးပြု၍ ရှာဖွေမည်ဖြစ်ပြီး၊ တွေ့ရှိသောအခါ ထို key ၏ နေရာအား ရလဒ်အဖြည် ပြန်ပေးမည် ဖြစ်သည်။ အကယ်၍ မတွေ့ရှိပါက အနှုတ်ကိန်းအား ရလဒ်အဖြစ် ပြန်ပေးမည် ဖြစ်ပါသည်။

static int binarySearch (Object [] a, Object key)
static int binarySearch (Object [] a, int fromIndex, int toIndex, Object key)
sttic <T> int binarySearch(T[] a, T key, Comparator<? super T> c) 

Binary Search အား အသုံးပြုရာတွင် အသုံးပြုသော ကိန်းစဉ်အား ကြိုတင်၍ Sort လုပ်ထားရန် လိုအပ်ပါသည်။ Sort လုပ်ထားခြင်းမရှိပါက ရရှိလာသောအဖြေသည် မှန်ကန်လိမ့်မည်ဟု အာမခံနိုင်မည် မဟုတ်ပေ။

လက်တွေ့စမ်းသပ်ကြည့်ပါမည်။ ဦးစွာ ကိန်း သုညမှ ၉၉၉အထိကို ကိန်းစဉ်အတွင်းသို့ ဖြည့်စွက်ပြီး၊ အစီအစဉ်ဖျက်ပါမည်။ ပြီးလျှင် ကိန်းများအား ရှာဖွေကြည့်ပါမည်။

import java.util.Arrays;
import java.util.Collections;

public class SearchSample {

 public static void main(String[] args) {
  Integer [] array = new Integer[1000];
  
  // add member to array
  for(int i=0; i<array.length; i++) {
   array[i] = i;
  }
  
  // shuffle
  Collections.shuffle(Arrays.asList(array));
  
  for(int i=501; i <= 505; i++) {
   System.out.println("Search Number :  " + i);
   System.out.println(Arrays.binarySearch(array, new Integer(i)));
  }
 }

}

ရလဒ်ကိုကြည့်သောအခါ အောက်ပါအတိုင်း တွေ့ရမည် ဖြစ်ပါသည်။

အမှန်အတိုင်း ဖော်ပြနိုင်ခြင်း မရှိပါသဖြင့် အနုတ်ကိန်းကို ဖော်ပြနေပါသည်။ Shuffle လုပ်သည့်နေရာကို Comment Out လုပ်၍ ပြန် Run ကြည့်ပါမည်။

Shuffleမလုပ်ထားပါသဖြင့် ကိန်းစဉ်အတွင်း အစီအစဉ်အလိုက် တည်ရှိနေသောကြောင့်၊ မှန်ကန်စွာ ဖော်ပြပေးနိုင်စွမ်း ရှိကြောင်းကို တွေ့ရပါသည်။

Arrays ရဲ့ အသုံးဝင်သော နောက်လုပ်ဆောင်ချက် တစ်ခုမှာ Array#asList ဖြစ်သည်။ အထက်ပါ နမှုနာထဲတွင် ရေးသားပြီး ဖြစ်သည်။ ကိန်းစဉ်တစ်ခုမှ List ကို ရရှိစေနိုင်သော လုပ်ဆောင်ချက်ဖြည်ပါသည်။


အခြား အသုံးဝင် လုပ်ဆောင်ချက်များ

static void fill(Object[] a, Object val)
static void fill(Object[] a, int fromindex, int toindex, Object val)

Arrays#fill လုပ်ဆောင်ချက်သည် ကိန်းစဉ်အတွင်းရှိ အချက်အလက်များအား val ၏ တန်ဖိုးဖြင့် အစားထိုးနိုင်မည် ဖြစ်ပါသည်။ တဖန် int fromindex, int toindex ပါရာမီတာများ ပါဝင်သည့် လုပ်ဆောင်ချက်ကို အသုံးပြုပါက ကိန်းစဉ်အတွင်းရှိ အချက်အလက်များအား နေရာသတ်မှတ်၍ အစားထိုးနိုင်မည် ဖြစ်ပါသည်။

static boolean equals(Object[] a, Object[] a2)

ကိန်းစဉ်တစ်ခုနှင့် တစ်ခု တူညီကြောင်းအား စမ်းသပ်ရာတွင် အသုံးပြုနိုင်ပါသည်။ တူညီပါက true ကို ရလဒ်အဖြစ် ရရှိမည်ဖြစ်ပြီး၊ မတူညီပါက false ကို ရရှိမည် ဖြစ်ပါသည်။

static <T> T[] copyOf(T[] original, int newLength)
static <T> T[] copyOfRange(T[] original, int from, int to)

အထက်ပါ copyOf အား အသုံးပြုပါက ကိန်းစဉ်တစ်ခုမှ အရေအတွက်အား သတ်မှတ်၍ ကော်ပီကူနိုင်မည်ဖြစ်ပြီး၊ အရေအတွက်သည် မှုရင်းကိန်းစဉ်ရှိ အရေးအတွက်ထက်နည်းနေပါက ပိုနေသည်များကို ဖြတ်ထုတ်မည်ဖြစ်ပြီး၊ များနေပါက လိုအပ်သည်များကို null ဖြင့် ဖြည့်စွက်၍ ကော်ပီကူးမည် ဖြစ်ပါသည်။

တဖန် copyOfRange အား အသုံးပြုပါက အစနေရာနှင့် အဆုံးနေရာအား သတ်မှတ်၍ ကော်ပီကူးနိုင်မည် ဖြစ်သည်။


ကိုးကား
http://www.techscore.com/tech/Java/JavaSE/Utility/5/
http://docs.oracle.com/javase/6/docs/api/java/util/Arrays.html

လေးစားစွာဖြင့်

မင်းလွင်