集合(List、Set、Map)與泛型(泛型類、泛型接口)代碼練習

List分爲兩種：

      ArrayList(查詢、更新)--數組

      LinkedList(增加、刪除)--鏈表

1.1ArrayList示例--ArrayList的5種遍歷形式，實際有三種：for循環、forEach、Iterator

    @Test
    /**
     * @author yto_yh
     * ArrayList示例
     * 適用於查詢、修改
     * 一下遍歷方式set通用
     */
    public void test() {
        List<Integer> num= Arrays.asList(1,2,3,4,5);
        System.out.println("初始："+num);
        Iterator<Integer> it=num.iterator();
        System.out.print("第一種遍歷：");
        while(it.hasNext()) {
            System.out.print(it.next()+" ");
        }
        System.out.print("\n第二種遍歷：");
        for(Iterator<Integer> it1=num.iterator();it1.hasNext();) {
            System.out.print(it1.next()+" ");
        }
        System.out.print("\n第三種遍歷：");
        for(int i:num) {
            System.out.print(i+" ");
        }
        System.out.print("\n第四種遍歷：");
        num.forEach(i->System.out.print(i+" "));
        System.out.print("\n第五種遍歷：");
        num.forEach(System.out::print);
    }

1.2LinkList示列

 @Test
    /**
     * LinkList示列
     * 適用於增加、刪除
     */
    public void test01() {
        LinkedList<Integer> LL=  new LinkedList<Integer>();
        LL.addFirst(11111111);
        LL.addFirst(11111112);
        LL.addFirst(11111113);
//        LL.removeLast();
        LL.removeFirst();
        System.out.println(LL.toString());
    }

Set分爲：

     HashSet：元素不重複，存取無序：不能保證元素的排列順序，順序有可能發生變化、不是同步的、集合元素可以是null,但只能放入一個null
     LinkedHashSet：元素不重複，存取有序：
    TreeSet：元素不重複：TreeSet類型是J2SE中唯一可實現自動排序的類型

2.HashSet、LinkedHashSet、TreeSet示例

@Test
    /**
     * Set分爲：Set集合的特點：元素不重複，存取無序
     * HashSet與TreeSet都是基於Set接口的實現類。其中TreeSet是Set的子接口SortedSet的實現類。
     * HashSet：元素不重複，存取無序：不能保證元素的排列順序，順序有可能發生變化、不是同步的、集合元素可以是null,但只能放入一個null
     * LinkedHashSet：元素不重複，存取有序：
     * TreeSet：元素不重複：TreeSet類型是J2SE中唯一可實現自動排序的類型
     */
    public void test02() {
        //-----------------HashSet-------------------------
        HashSet<Integer> hs=  new HashSet<Integer>();
        hs.add(1);
        hs.add(2);
        hs.add(1);
        System.out.println("第一種遍歷方式：");
        Iterator<Integer> iterator=hs.iterator();
        while (iterator.hasNext()) {
            Integer integer = (Integer) iterator.next();
            System.out.print(integer+" ");
        }
        System.out.println("\n第二種遍歷方式：");
        for (Integer integer : hs) {
            System.out.print(integer+" ");
        }
        //-----------------LinkedHashSet-------------------------
        LinkedHashSet<Integer> lhs=new LinkedHashSet<Integer>();
        lhs.add(1);
        lhs.add(3);
        lhs.add(2);
        lhs.add(1);
        System.out.println("第一種遍歷方式：");
        Iterator<Integer> iterator=lhs.iterator();
        while (iterator.hasNext()) {
            Integer integer = (Integer) iterator.next();
            System.out.print(integer+" ");
        }
        System.out.println("\n第二種遍歷方式：");
        for (Integer integer : lhs) {
            System.out.print(integer+" ");
        }
        //-----------------TreeSet-------------------------
        TreeSet<Integer> ts=  new TreeSet<Integer>();
        ts.add(1);
        ts.add(3);
        ts.add(2);
        ts.add(1);
        System.out.println("第一種遍歷方式：");
        Iterator<Integer> iterator1=ts.iterator();
        while (iterator1.hasNext()) {
            Integer integer = (Integer) iterator1.next();
            System.out.print(integer+" ");
        }
        System.out.println("\n第二種遍歷方式：");
        for (Integer integer : ts) {
            System.out.print(integer+" ");
        }
    }

 

3. Map的特點：
        HashMap：存取無序，鍵不可重複

        LinkedHashMap：存取有序，鍵不可重複

       TreeMap：自動排序

 @Test
    /**
     * Map的特點：是存取無序，鍵不可重複
     * HashMap，LinkedHashMap和TreeMap
     */
    public void test03() {
        //-----------------HashMap-------------------------
        HashMap<Integer,String> hm= new HashMap<Integer,String>();
        hm.put(1, "value1");
        hm.put(3, "value3");
        hm.put(2, "value2");
        hm.put(3, "value4");//覆蓋
        System.out.println("第一種遍歷方式：");
        Set<Entry<Integer, String>> se=  hm.entrySet();
        Iterator<Entry<Integer, String>> iterator = se.iterator();
        while (iterator.hasNext()) {
            Entry<Integer,String> entry =iterator.next();
            System.out.print(entry.getKey()+"  "+entry.getValue()+"\n");
        }
        System.out.println("\n第二種遍歷方式：");
        for(Entry<Integer, String> entry:hm.entrySet()) {
            System.out.print(entry.getKey()+"  "+entry.getValue()+"\n");
        }
        System.out.println("\n第三種遍歷方式：");
        for(Integer in:hm.keySet()) {
            System.out.print(hm.get(in)+" ");
        }
        System.out.println("\n第四種遍歷方式：");
        for(String v:hm.values()) {
            System.out.print(v+" ");
        }
    }

4.Collections自帶方法sort()、reverse()、同步等

@Test
    /**
     * 排序：reverse()(反轉集合元素順序)、shuffle()(隨機排列)、
     * sort()、swap()等方法。查找和替換：集合元素的出現次數)、
     * replaceAll()等方法
     */
    public void test04() {
        List<Integer> list=  Arrays.asList(1,2,5,3,7,6);
        list.forEach(s->System.out.print(s));
        System.out.println();
        Collections.sort(list);//排序
        list.forEach(s->System.out.print(s));
        System.out.println();
        Collections.reverse(list);//反轉
        list.forEach(s->System.out.print(s));
        //同步控制
        Collection c = Collections.synchronizedCollection(new ArrayList());
        List l = Collections.synchronizedList(new ArrayList());
         Set s = Collections.synchronizedSet(new HashSet());
        Map m = Collections.synchronizedMap(new HashMap());
        
    }

5.1 泛型 

 /**
     * 泛型 
     * Java泛型最簡單的方法是把它看成一種便捷語法,
     * 能節省你某些Java類型轉換( casting)上的操作
     */
    @Test
    public void test05() {
        ArrayList<User> aL  =new  ArrayList<User>(); 
        aL.add(new User("yoko","pswyoko"));
        User u=aL.get(0);
        System.out.println(u);
    }

5.2 泛型類   泛型接口

 @Test
    /**
     * 泛型類  
     * 泛型接口
     */
    public void test06() {
        Generic<Integer> g= new Generic<Integer>();
        g.setKey(111111111);
        System.out.println("泛型類："+g.getKey()+"\n泛型接口："+g.getKey("111","222"));
    }

/**
 * @author yto_yh
 *
 */
public class Generic<T> implements GenericInterface<String>{
    
    private T key;
    
    public Generic() {
        super();
    }

    public Generic(T key) {
        super();
        this.key = key;
    }

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    /* (non-Javadoc)
     * @see com.example.demo0810.test.GenericInterface#getKey(java.lang.Object, java.lang.Object)
     */
  //  @Override
    public Integer getKey(Integer t1, Integer t2) {
        // TODO Auto-generated method stub
        return t1+t2;
    }

    /* (non-Javadoc)
     * @see com.example.demo0810.test.GenericInterface#getKey(java.lang.Object, java.lang.Object)
     */
    @Override
    public String getKey(String t1, String t2) {
        // TODO Auto-generated method stub
        return t1+t2;
    }
    
    
}


/**
 * @author yto_yh
 *
 */
public interface GenericInterface<T> {
    
    T getKey(T t1,T t2); 
}

/**
 * @author yto_yh
 *
 */
public class Info<T> {
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }

    @Override
    public String toString() {
        return "var=" + this.var.toString();
    }
}



/**
 * @author yto_yh
 *
 */
public class GenericsDemo {
    
    public static void fun(Info<? super String> temp) {//泛型在父類String的子類之中
        System.out.println(temp);
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Info<String> info1=new Info<>();
        Info<Object> info2=new Info<>();
        info1.setVar("hello ");
        fun(info1);
        info2.setVar("hello world");
        fun(info2);
    }

}