集 合 框 架

一、集合
        1. 概念：一个对象（容器）用来存储多个对象  //钱包里面装的Money  书架对象存储多个书本对象
            String[] str=new String[5];
            str[0]="zs";
            str[1]="ls";
            str[2]="ww";
            str[3]="zl";
            str[4]="王五";
            System.arraycopy(str,0,str1,0,str.length);
            str1[5]="赵六";
            str=str1;
        2. import java.util.*;
二、集合框架
        集合框架是由接口和类构成的
        1. Collection接口 （java.util.Collection）
            特点：存储所有Object数据，元素是Object类型
            方法：
                a. boolean add(Object o);          //将一个对象添加到集合中，添加成功返回true，不成功返回false
                b. boolean addAll(Collection c); //将原c集合中所有元素添加到新集合中
                c. void clear();                  //清空集合
                d. boolean contains(Object o);   //判断此集合中是否有对象o
                e. boolean isEmpty();               //判断集合是否为空，为空返回true，不为空则为false
                f. Iterator iterator();          //迭代器
                g. boolean remove(Object o);     //从集合中移除单个对象，移除成功返回true 移除失败返回false
                h. int size();                   //集合中对象元素的个数
                i. Object[] toArray();           //将一个集合转换成一个数组
            遍历：实现类中详解
            实现类：没有实现类
        2. List接口（extends Collection 子接口）
            特点:元素有顺序、有下标、元素可重复
            方法:List接口中特有的方法都跟下标有关
                a. void add(int index,Object o); //将对象o插入集合指定下标index位置
                b. Object get(int index);          //获取集合index下标位置对象
                c. int indexOf(Object o);          //从前往后返回对象o在集合中的下标，如果没有对象匹配上则返回-1
                d. int lastIndexOf(Object o);    //从后往前返回对象o在集合中的下标
                e. Object remove(int index);     //删除index下标位置对象，并把删除的对象作为返回值返回
                f. set(int index,Object o);      //将集合下标index位置中对象用对象o替换掉
            遍历：
                a. for 循环遍历 ---> 类比数组  集合 元素个数 list.size();  元素访问 list.get(index);
                   //集合创建   接口List指向实现类ArrayList
                   list.add("zs");
                   list.add("ls");
                   for(int i=0;i<list.size();i++){
                       Object o=list.get(i);
                       
                   }
                b. Iterator 迭代器遍历 
                   Iterator it=list.iterator();  //迭代器 对集合调用此方法，集合中所有对象按照一定规则存放在迭代器里面
                   it.hasNext(); //文件指针 判断指针右边有没有对象，有true，没有返回false
                   it.next(); //指针右移一位，返回跳过的对象
                   while(it.hasNext()){
                       Object o=it.next();
                       String s=(String)o;
                       System.out.println(s);
                   }
                c. forEach jdk5.0
                   List list=new ArrayList();
                    语法： 
                    for(Object o : 集合名){
                       
                    }
                    for(Object o:list){  //Object o=new String("zs");
                        String s=(String)o;
                        System.out.println(s);
                    }
            实现类：
                1. ArrayList implements List（***重点***）
                    a. 数组结构存储
                    b. JDK1.2 轻量级 线程不安全 操作速度快
                    c. 查询快、增删慢
                    d. 自动扩容50%
                2. Vector implements List
                    a. 数组结构存储
                    b. JDK1.0 重量级 线程安全 操作速度慢
                    c. 自动扩容100%
                3. LinkedList implements List
                    a. 链表结构存储 （元素是节点，分两部分一部分存数据，一部分存地址，地址指向下一个节点）
                    b. 增删快、查询慢
            补充：泛型
                    List<String> list=new ArrayList<String>();
                    泛型限制元素类型必须是声明类型，声明泛型不需要做类型的强转
                    List<Student> list=new ArrayList<Student>();  //声明集合中只能从存放Student对象
                    List<Dog> list=new ArrayList<Dog>();  //声明集合中只能从存放Dog对象
        3. Set接口（extends Collection 子接口）
            特点：元素没有下标、元素不可重复、无顺序
            方法：没有特有方法，所有方法都继承自父接口Collection
            遍历：
                a. 迭代器遍历
                    Set<String> set=new HashSet<String>(); //接口Set指向实现类HashSet  多态用法
                    Iterator it=set.iterator();            //将set集合中所有元素放在迭代器里面
                    while(it.hasNext()){                   //遍历迭代器等同于遍历set集合
                        System.out.println(it.next());
                    }
                b. forEach循环遍历
                    for(String s : set){   //String s    泛型类型  引用名
                        System.out.println(s);
                    }
            实现类：
                1. HashSet implements Set （***重点***）
                    a. 将自定义对象放入Set集合中，无法保证元素不重复
                    b. 必须重写hashCode()方法  equals()方法
                        1. public int hashCode();  //保证相同对象返回相同整数
                            例：return name.hashCode()+age;  
                        2. public boolean equals();    //保证相同对象返回true
                2. TreeSet
                    a. 实现SortedSet接口，会对集合中元素自动排序
        4. Map集合
            特点：存储一对数据  key---value  "zs"---123456  "ls"---666666  "ww"---123456
                  键值对  键位key 值为value 成对出现
                  无序、无下标、键不可重复值可重复
            方法：
                a. put(Object key,Object value); //将一对键值对添加到Map集合中   put("zs",123456);
                b. get(Object key);                 //返回Map集合中key对应的Value值 int i=(int)get("zs");
                c. remove(Object key);             //删除以key为键对应的键值对     remove("zs");
                d. size();                         //返回Map集合中键值对个数
                e. containsKey(Object key);         //判断是否存在key  存在返回true  不存在返回false
                f. containsValue(Object value);  //判断是否存在value    
            遍历：
                1. 键遍历
                Set keySet=map.keySet();   //keySet集合中存放的是Map集合中所有的键
                for(Object o: keySet){
                    String s=(String)o;   // Object o="zs"; 
                                          //键有了  如：第一次  键位"zs"
                    Object o1=map.get(s); //通过键拿值   方法是map.get(Object key);
                    Integer i=(Integer)o1;//值有了
                    System.out.println("键位："+s+"   值："+i);
                }
                2. 值遍历
                Collection c=map.values();   //map.values()会将Map集合中所有的值都放入到一个Collection
                Iterator it=c.iterator();
                while(it.hasNext()){
                    Object o=it.next();
                    Integer i=(Integer)o;
                    System.out.println(i);
                }
                3. 键值遍历
                Set entrySet = map.entrySet();
                for (Object o : entrySet) {
                    System.out.println(o);
                }
            实现类：
                1. HashMap（***重点***）
                    a. JDK1.2 操作速度快 线程不安全
                    b. 键可以为 null 但只能出现一次 否则覆盖， 值可以为null 可以重复
                       Map map=new HashMap();
                       map.put(null,"zs");
                2. HashTable
                    a. JDK1.0 操作速度慢 线程安全
                    b. 键key和值value都不允许为null
                3. Properties
                    a. HashTable的子类
                    b. 键值都为String类型
                4. TreeMap
                    自动对key排序