시소당

String 및 int 배열에서 중복제거하는 메소드

        /**
          *  <pre>
          *  입력받은  String[n]  값에  중복된  값을  제거하여  String[n]를  반환한다.
          *
          *  @param  strArray      중복제거  할  String  배열
          *  @return  String  []  중복제거된  String  배열
          *
          *  <b>Example)</b>
          *      String[]  strArr  =  ArrayUtil.removeDup(new  String  []  {"A","D","B","D","E"});
          *      결과값  A  D  B  E
          *  </pre>
          */
        public  static  String[]  removeDup(String  []  strArray)
        {
         if(strArray  ==  null  ||  strArray.length  ==  0)  return  (String[])null;
        
         LinkedHashSet<String>  hSet  =  new  LinkedHashSet<String>();

                for(String  str  :  strArray){
                 hSet.add(str);
                }
                
//                Iterator<String>  it  =  hSet.iterator();
//                while(it.hasNext()){
//                 //("Str  :  "  +  it.next());
//                }
                
                return  (String  [])hSet.toArray(new  String  [hSet.size()]);
        }
        
        
        /**
          *  <pre>
          *  입력받은  int[n]  값에  중복된  값을  제거하여  int[n]를  반환한다.
          *
          *  @param  intArray  int  배열
          *  @return  int  []  중복제거  된  int  배열
          *
          *  <b>Example)</b>
          *      int[]  intArr  =  ArrayUtil.removeDup(new  int  []  {1,3,2,4,2,2,3,9});
          *      결과값  1  3  2  4  9
          *  <pre>
          */
        public  static  int[]  removeDup(int  []  intArray)
        {
         if(intArray  ==  null  ||  intArray.length  ==  0)  return  (int[])null;
        
         LinkedHashSet<Integer>  hSet  =  new  LinkedHashSet<Integer>();

                for(int  i  :  intArray){
                 hSet.add(new  Integer(i));
                }
                
                Iterator<Integer>  it  =  hSet.iterator();
                int  []  rtnIntArr  =  new  int[hSet.size()];
                for  (int  i=0  ;  i<hSet.size()  ;  i++){
                 rtnIntArr[i]  =  it.next();
                }
                
                return  rtnIntArr;
        }
        
        
        
        /**
          *  <pre>
          *  입력받은  String[n]  값에  중복된  값을  제거하여  Sort  후  String[n]를  반환한다.
          *
          *  @param  strArray      중복제거  할  String  배열
          *  @return  String  []  중복제거  후  Sort  된  String  배열
          *
          *  <b>Example)</b>
          *      String[]  strArr  =  ArrayUtil.removeDupNSort(new  String  []  {"A","D","B","D","E"});
          *      결과값  A  B  D  E
          *  </pre>
          */
        public  static  String[]  removeDupNSort(String  []  strArray)
        {
         if(strArray  ==  null  ||  strArray.length  ==  0)  return  (String[])null;
        
                TreeSet<String>  tSet  =  new  TreeSet<String>();

                for(String  str  :  strArray){
                 tSet.add(str);
                }
                
//                Iterator<String>  it  =  tSet.iterator();
//                while(it.hasNext()){
//                 //("Str  :  "  +  it.next());
//                }
                
                return  (String  [])tSet.toArray(new  String  [tSet.size()]);
        }

        /**
          *  <pre>
          *  입력받은  int[n]  값에  중복된  값을  제거하여  Sort  후  int[n]를  반환한다.
          *
          *  @param  intArray  int  배열
          *  @return  int  []  중복제거  후  Sort  된  int  배열
          *
          *  <b>Example)</b>
          *      int[]  intArr  =  ArrayUtil.removeDup(new  int  []  {1,3,2,4,2,2,3,9});
          *      결과값  1  2  3  4  9
          *  <pre>
          */
        public  static  int[]  removeDupNSort(int  []  intArray)
        {
         if(intArray  ==  null  ||  intArray.length  ==  0)  return  (int[])null;
        
                TreeSet<Integer>  tSet  =  new  TreeSet<Integer>();

                for(int  i  :  intArray){
                 tSet.add(new  Integer(i));
                }
                
                Iterator<Integer>  it  =  tSet.iterator();
                int  []  rtnIntArr  =  new  int[tSet.size()];
                for  (int  i=0  ;  i<tSet.size()  ;  i++){
                 rtnIntArr[i]  =  it.next();
                }
                
//                while(it.hasNext()){
//                 //("i  :  "  +  it.next());
//                }
                

                return  rtnIntArr;
        }