集合框架

              Collection                   Map       List                 Set            HashMap ArrayList      LinkedLisr   HashSet        

1.  List的方法                

　　List<元素类型> list = new LinkedList<元素类型>();   

　　list.add(元素);//增加元素                

　　list.add(index，元素)；//向指定位置插入元素                

　　list.remove(下标)；//删除指定下标的元素                

　　list.remove(元素)；删除指定元素                

　　list.get(index)；//获取指定下标元素                

　　list.contains(元素)//集合中是否包含指定元素  

public class Test5 {
    public static void main(String[] args){
        Collection col = new LinkedList();
        col.add(10);
        col.add(11);
        System.out.println(col);
        
        System.out.println(col.size());
        
        List<String> list = new LinkedList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ddd");
        list.add(2,"ccc");
        String val = list.get(0);
        String val1 = list.remove(1);
        boolean flag = list.contains("bbb");
        System.out.println(val);
        System.out.println(list);
        System.out.println(flag);
    }
}

public class Test4 {
    public static void main(String[] args){
//        Collection col = new ArrayList();
//        //增加元素
//        col.add(10);
//        col.add(11);
//        System.out.println(col);
//        //集合长度
//        System.out.println(col.size());
        
        //可重复.有序，(不唯一，有序)
        List <String> list = new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ddd");
        //向指定位置，插入元素
        list.add(1,"ccc");
        String val = list.get(0);
        //删除指定位置值(返回删除掉的值)
        String val1 = list.remove(1);
        //是否包含指定元素
        boolean flag = list.contains("bbb");
        System.out.println(val);
        System.out.println(list);
        System.out.println(flag);
    }
}

      

2.   Collection，List，Set的区别             

　　Collection:不唯一，无序             

　　List：不唯一，有序             

　　Set：唯一，无序        

3.   ArrayList和LinkedList的区别              

　　a.都实现了List              

　　b.ArrayList是可边长数组方式实现，查询效率高.                

　　LinkedList是链表方式实现，增加和删除效率高.        

        

4.   Map 常用方法（键值对方式存储数据）                

　　Map<Object,Object> maps = new HashMap<Object,Object>();                

　　maps.put（key，value）//增加元素                

　　maps.get（key）//获取指定key的值                

　　maps.size（）//长度                

　　maps.remove（key）//删除指定元素                

　　maps.containsKey（key）//是否包含指定key             

　　注意：key是唯一的，如果重复那么后面的会覆盖前面的.value是可以重复的.    

    

public class TestMap {
    public static void main(String[] args){
        //key -> value
        //名字-->企鹅
        Map<String,Penguin> maps = new HashMap<String,Penguin>();
        //增加
        Penguin p = new Penguin();
        p.setName("小刘");
        p.setSex("女");
        maps.put("小刘", p);
        Penguin p1 = maps.get("小刘");
        p1.print();
        //System.out.println(maps);
        //大小
        System.out.println(maps.size());
        //是否包含key
        System.out.println(maps.containsKey("小刘"));
        //删除
        maps.remove("小刘");
    }
}

5.   Vector和ArrayList的异同              

　　实现原理、功能相同、可以互用              

　　Vector线程安全，ArrayList重速度轻安全，线程非安全              

　　长度需增长时，Vector默认增长一倍，ArrayList增长50%             

　　Hashtable和HashMap的异同              

　　Hashtable继承Dictionary类，HashMap实现Map接口              

　　Hashtable线程安全，HashMap线程非安全              

　　Hashtable不允许null值，HashMap允许null值  

6.   集合的迭代             

　　语法： Iterator<Object> it = 集合.iterator（）；                          

　　while（it.hasNext）{

                                  Object  obj = it.next（）；                               

　　　　}                         

　　it.hasNext（）；判断下个是否有值                         

　　it.next（）；//移动指针，返回指针指向元素             

　　注意：集合在遍历的过程中不能进行修改，如果进行了修改操作，那么就会抛出                   

　　ConcurrentModificationException异常.如果需要进行删除                   

　　使用迭代器的it.remove（）方法.

package 二期第六章;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Text7 {
    public static void main(String[] args){
        Map<String,String> maps = new HashMap<String,String>();
        maps.put("a", "A");
        maps.put("b", "B");
        maps.put("c", "C");
        
        Set<String> sets = maps.keySet();
        for(String str : sets){
            System.out.println(maps.get(str));
        }
        
        System.out.println(sets);
        Collection<String> value = maps.values();
        for(String str : value){
            System.out.println(str);
        }
        System.out.println(value);
        Iterator<String> it = maps.keySet().iterator();
        //hasNext:判断下个是否有值
        while(it.hasNext()){
            //移动下标,并返回当前值
            String str = it.next();
            
            if(str.equals("a")){
                it.remove();
            }
            
        }
        System.out.println(maps);
        Iterator<String> value1 = maps.values().iterator();
        while(value1.hasNext()){
            String str = value1.next();
            System.out.println(str);
        }
    }
}