程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> 數組與List之間互相轉換的辦法詳解

數組與List之間互相轉換的辦法詳解

編輯:關於JAVA

數組與List之間互相轉換的辦法詳解。本站提示廣大學習愛好者:(數組與List之間互相轉換的辦法詳解)文章只能為提供參考,不一定能成為您想要的結果。以下是數組與List之間互相轉換的辦法詳解正文


成績:好比我有一個數組(元素個數為0哈),願望添加出來元素不克不及反復。

  拿到如許一個成績,我能夠會疾速的寫下代碼,這裡數組用ArrayList.

private static void testListSet(){
        List<String> arrays = new ArrayList<String>(){
            @Override
            public boolean add(String e) {
                for(String str:this){
                    if(str.equals(e)){
                        System.out.println("add failed !!!  duplicate element");
                        return false;
                    }else{
                        System.out.println("add successed !!!");
                    }
                }
                return super.add(e);
            }
        };

        arrays.add("a");arrays.add("b");arrays.add("c");arrays.add("b");
        for(String e:arrays)
            System.out.print(e);
    }

這裡我甚麼都不關,只關懷在數組添加元素的時刻做下斷定(固然添加數組元素只用add辦法),能否已存在雷同元素,假如數組中不存在這個元素,就添加到這個數組中,反之亦然。如許寫能夠簡略,然則面對宏大數組時就顯得愚笨:有100000元素的數組天家一個元素,豈非要挪用100000次equal嗎?這裡是個基本。

      成績:參加曾經有一些元素的數組了,怎樣刪除這個數組裡反復的元素呢?

  年夜家曉得java中聚集總的可以分為兩年夜類:List與Set。List類的聚集裡元素請求有序但可以反復,而Set類的聚集裡元素請求無序但不克不及反復。那末這裡便可以斟酌應用Set這個特征把反復元素刪除不就到達目標了,究竟用體系裡已有的算法要優於本身現寫的算法吧。


public static void removeDuplicate(List<People> list){
       HashSet<People> set = new HashSet<People>(list);
       list.clear();
       list.addAll(set);
    }  private static People[] ObjData = new People[]{
        new People(0, "a"),new People(1, "b"),new People(0, "a"),new People(2, "a"),new People(3, "c"),
    }; 


public class People{
    private int id;
    private String name;

    public People(int id,String name){
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return ("id = "+id+" , name "+name);
    }   
}

下面的代碼,用了一個自界說的People類,當我添加雷同的對象時刻(指的是含有雷同的數據內容),挪用removeDuplicate辦法發明如許其實不能處理現實成績,依然存在雷同的對象。那末HashSet裡是怎樣斷定像個對象能否雷同的呢?翻開HashSet源碼可以發明:每次往外面添加數據的時刻,就必需要挪用add辦法:


@Override
     public boolean add(E object) {
         return backingMap.put(object, this) == null;
     }

這裡的backingMap也就是HashSet保護的數據,它用了一個很奇妙的辦法,把每次添加的Object看成HashMap外面的KEY,自己HashSet對象看成VALUE。如許就應用了Hashmap裡的KEY獨一性,天然而然的HashSet的數據不會反復。然則真實的能否有反復數據,就得看HashMap裡的怎樣斷定兩個KEY能否雷同。


@Override public V put(K key, V value) {
        if (key == null) {
            return putValueForNullKey(value);
        }

        int hash = secondaryHash(key.hashCode());
        HashMapEntry<K, V>[] tab = table;
        int index = hash & (tab.length - 1);
        for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
            if (e.hash == hash && key.equals(e.key)) {
                preModify(e);
                V oldValue = e.value;
                e.value = value;
                return oldValue;
            }
        }

        // No entry for (non-null) key is present; create one
        modCount++;
        if (size++ > threshold) {
            tab = doubleCapacity();
            index = hash & (tab.length - 1);
        }
        addNewEntry(key, value, hash, index);
        return null;
    }

總的來講,這裡完成的思緒是:遍歷hashmap裡的元素,假如元素的hashcode相等(現實上還要對hashcode做一次處置),然後去斷定KEY的eqaul辦法。假如這兩個前提知足,那末就是分歧元素。那這裡假如數組裡的元素類型是自界說的話,要應用Set的機制,那就得本身完成equal與hashmap(這裡hashmap算法就不具體引見了,我也就懂得一點)辦法了:


public class People{
    private int id; //
    private String name;

    public People(int id,String name){
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return ("id = "+id+" , name "+name);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof People))
            return false;
        People o = (People)obj;
        if(id == o.getId()&&name.equals(o.getName()))
            return true;
        else
            return false;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return id;
        //return super.hashCode();
    }
}

這裡在挪用removeDuplicate(list)辦法就不會湧現兩個雷同的people了。

      好吧,這裡就測試它們的機能吧:


public class RemoveDeplicate {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //testListSet();
        //removeDuplicateWithOrder(Arrays.asList(data));
        //ArrayList<People> list = new ArrayList<People>(Arrays.asList(ObjData));

        //removeDuplicate(list);

        People[] data = createObjectArray(10000);
        ArrayList<People> list = new ArrayList<People>(Arrays.asList(data));

        long startTime1 = System.currentTimeMillis();
        System.out.println("set start time --> "+startTime1);
        removeDuplicate(list);
        long endTime1 = System.currentTimeMillis();
        System.out.println("set end time -->  "+endTime1);
        System.out.println("set total time -->  "+(endTime1-startTime1));
        System.out.println("count : " + People.count);
        People.count = 0;

        long startTime = System.currentTimeMillis();
        System.out.println("Efficient start time --> "+startTime);
        EfficientRemoveDup(data);
        long endTime = System.currentTimeMillis();
        System.out.println("Efficient end time -->  "+endTime);
        System.out.println("Efficient total time -->  "+(endTime-startTime));
        System.out.println("count : " + People.count);
       

       

    }
    public static void removeDuplicate(List<People> list)
    {
     HashSet<People> set = new HashSet<People>(list);
     list.clear();
     list.addAll(set);
    }

    public static void removeDuplicateWithOrder(List<String> arlList)
    {
       Set<String> set = new HashSet<String>();
       List<String> newList = new ArrayList<String>();
       for (Iterator<String> iter = arlList.iterator(); iter.hasNext();) {
          String element = iter.next();
          if (set.add( element))
             newList.add( element);
       }
       arlList.clear();
       arlList.addAll(newList);
    }

   
    @SuppressWarnings("serial")
    private static void testListSet(){
        List<String> arrays = new ArrayList<String>(){
            @Override
            public boolean add(String e) {
                for(String str:this){
                    if(str.equals(e)){
                        System.out.println("add failed !!!  duplicate element");
                        return false;
                    }else{
                        System.out.println("add successed !!!");
                    }
                }
                return super.add(e);
            }
        };

        arrays.add("a");arrays.add("b");arrays.add("c");arrays.add("b");
        for(String e:arrays)
            System.out.print(e);
    }

    private static void EfficientRemoveDup(People[] peoples){
        //Object[] originalArray; // again, pretend this contains our original data
        int count =0;
        // new temporary array to hold non-duplicate data
        People[] newArray = new People[peoples.length];
        // current index in the new array (also the number of non-dup elements)
        int currentIndex = 0;

        // loop through the original array...
        for (int i = 0; i < peoples.length; ++i) {
            // contains => true iff newArray contains originalArray[i]
            boolean contains = false;

            // search through newArray to see if it contains an element equal
            // to the element in originalArray[i]
            for(int j = 0; j <= currentIndex; ++j) {
                // if the same element is found, don't add it to the new array
                count++;
                if(peoples[i].equals(newArray[j])) {

                    contains = true;
                    break;
                }
            }

            // if we didn't find a duplicate, add the new element to the new array
            if(!contains) {
                // note: you may want to use a copy constructor, or a .clone()
                // here if the situation warrants more than a shallow copy
                newArray[currentIndex] = peoples[i];
                ++currentIndex;
            }
        }

        System.out.println("efficient medthod inner  count : "+ count);

    }

    private static People[] createObjectArray(int length){
        int num = length;
        People[] data = new People[num];
        Random random = new Random();
        for(int i = 0;i<num;i++){
            int id = random.nextInt(10000);
            System.out.print(id + " ");
            data[i]=new People(id, "i am a man");
        }
        return data;
    }

測試成果:


set end time -->  1326443326724
set total time -->  26
count : 3653
Efficient start time --> 1326443326729
efficient medthod inner  count : 28463252
Efficient end time -->  1326443327107
Efficient total time -->  378
count : 28463252

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved