集合(List、Set、Map)与泛型(泛型类、泛型接口)代码练习

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_37722734/article/details/82184054

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);
    }

}