[黑马程序员]7 JAVA基础- 集合

——- android培训、java培训、期待与您交流！ ———

特点：
1：集合用于存储对象。
2：集合是可变长度的。

集合和数组的区别：
1：数组是固定长度的；集合可变长度的。
2：数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。
3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。

数据结构：就是容器中存储数据的方式。

对于集合容器，有很多种。因为每一个容器的自身特点不同，其实原理在于每个容器的内部数据结构不同。
集合容器在不断向上抽取过程中。出现了集合体系。

Collection：

Collection：
|–List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。
|–Set：无序(存入和取出顺序有可能不一致)，不可以存储重复元素。必须保证元素唯一性。

集合中的共性方法：
1，添加：
add(object)：添加一个元素
addAll(Collection) ：添加一个集合中的所有元素。
2，删除：
clear()：将集合中的元素全删除，清空集合。
remove(obj) ：删除集合中指定的对象。注意：删除成功，集合的长度会改变。
removeAll(collection) ：删除部分元素。部分元素和传入Collection一致。
3，判断：
boolean contains(obj) ：集合中是否包含指定元素 。
boolean containsAll(Collection) ：集合中是否包含指定的多个元素。
boolean isEmpty()：集合中是否有元素。
4，获取：
int size()：集合中有几个元素。
5，取交集：
boolean retainAll(Collection) ：对当前集合中保留和指定集合中的相同的元素。如果两个集合元素相同，返回flase；如果retainAll修改了当前集合，返回true。
6，获取集合中所有元素：
Iterator iterator()：迭代器
7，将集合变成数组：
toArray();

ListIterator 列表迭代器

特点：
允许遍历、迭代期间修改列表。
方法：
void add(E e)
将指定的元素插入列表（可选操作）。
boolean hasNext()
以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
boolean hasPrevious()
如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E next()
返回列表中的下一个元素。
int nextIndex()
返回对 next 的后续调用所返回元素的索引。
E previous()
返回列表中的前一个元素。
int previousIndex()
返回对 previous 的后续调用所返回元素的索引。
void remove()
从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
void set(E e)
用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

List

    List是Collection接口的子接口

特点：
List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。
|–ArrayList：底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素
的速度快。
|–LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。
|–Vector：底层的数据结构就是数组，线程同步的，Vector无论查询和增删都慢。
共性方法：

1. 添加：
   add(index,element) ：在指定的索引位插入元素。
   addAll(index,collection) ：在指定的索引位插入一堆元素。
2. 删除：
   remove(index) ：删除指定索引位的元素。 返回被删的元素。
3. 获取：
   Object get(index) ：通过索引获取指定元素。
   int indexOf(obj) ：获取指定元素第一次出现的索引位，如果该元素不存在返回-1；
   所以，通过-1，可以判断一个元素是否存在。
   int lastIndexOf(Object o) ：反向索引指定元素的位置。
   List subList(start,end) ：获取子列表。
4. 修改：
   Object set(index,element) ：对指定索引位进行元素的修改。
5. 获取所有元素：
   ListIterator listIterator()：list集合特有的迭代器。

List集合支持对元素的增、删、改、查。

List集合的另一种取出方式： 遍历。

for(int x=0; x<list.size(); x++){    sop("get:"+list.get(x));}

ArrayList

List 接口的大小可变数组的实现， 线程不同步
数据结构是数组结构

方法：
boolean add(E e)
将指定的元素添加到此列表的尾部。
void add(int index, E element)
将指定的元素插入此列表中的指定位置。
boolean addAll(Collection

LinkedList

底层数据几个是链表数据结构。

特点：
增删速度快， 查询慢

方法：
1. 增
offFirst();
offLast();
2. 获取
//获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
3. 删
//获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();

/** *  */package humiao;/**模拟堆栈先进先出和队列（先进慢出） *  * @author HM * */import java.util.*;public class LinkedListDemo {        public static void main(String[] args)        {            Queue link = new Queue();            link.myAdd("java01");            link.myAdd("java007");            link.myAdd("java008");            while(!link.isNull())            {                System.out.println(link.myGet());            }        }    }    class Stack  //先进先出    {        private LinkedList link;        Stack()        {            link = new LinkedList();        }        public void myAdd(Object obj)        {            link.addFirst(obj);        }        public Object myGet()        {            return link.removeLast();        }        public boolean isNull()        {            return link.isEmpty();        }    }    class Queue   //先进慢出    {        private LinkedList link;        Queue()        {            link = new LinkedList();        }        public void myAdd(Object obj)        {            link.addFirst(obj);        }        public Object myGet()        {            return link.removeFirst();        }        public boolean isNull()        {            return link.isEmpty();        }    }

Set

特点：
元素是无序的（存入取出顺序），元素不可以重复
下层体系：
|–HashSet：底层数据结构是哈希表，线程是不同步的。通过判断元素的
hashCode值是否相同&&equals()返回值来保证元素唯一性。
|–TreeSet：底层的数据结构是二叉树，默认对元素进行字典排序。
根据其compareTo()方法判断元素唯一性。

HashSet

特点：
线程不同步，存取速度快

方法：
boolean add(E e)
如果此 set 中尚未包含指定元素，则添加指定元素。
void clear()
从此 set 中移除所有元素。
Object clone()
返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。
boolean contains(Object o)
如果此 set 包含指定元素，则返回 true。
boolean isEmpty()
如果此 set 不包含任何元素，则返回 true。
Iterator iterator()
返回对此 set 中元素进行迭代的迭代器。
boolean remove(Object o)
如果指定元素存在于此 set 中，则将其移除。
int size()
返回此 set 中的元素的数量（set 的容量）。

package humiao;/** * 自定义一个“Person”对象 复写hashCode和equals方法 * 以便将对象往集合中存放时，不存入相同name和age的元素。 * @author HM * */import java.util.*;class Person1{    private String name;    private int age;    Person1(String name, int age)    {        this.name = name;        this.age = age;    }    public String getName()    {        return name;    }    public int getAge()    {        return age;    }    public int hashCode()    {        //利用String的hashCode方法返回name的哈希值再加上对象的age        //也就是说，当name和age都相同时，返回同样的hashCode值。        return this.name.hashCode() + this.age;    }    // 对象的hashCode值相同时，将调用此方法判断内容是否相同。    public boolean equals(Object obj)    {        if( !(obj instanceof Person1))            return false;        Person1 p = (Person1)obj;        return this.name.equals(p.name) && this.age == p.age;    }}class HashSetTest{    public static void main(String[] args)    {        HashSet  h = new HashSet();        h.add(new Person1("zhangsan", 10));        h.add(new Person1("zhangsan",11));        h.add(new Person1("lisi", 10));        h.add(new Person1("zhangsan",10));        Iterator it = h.iterator();        while(it.hasNext())        {            Person1 p = (Person1)it.next();            System.out.println(p.getName()+"  "+p.getAge());        }    }}

TreeSet

特点：
底层数据结构是二叉树，线程不同步。

方法：
boolean add(E e)
将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
boolean addAll(Collection

package humiao;/** * 存入TerrSet集合中的元素需要具备比较性， * 方法一： 让元素自身具备比较性：实现Comparable接口，复写compareto方法 * 当你元素自身的比较方法不是你所需要的，建立TreeSet集合时，可以自定义比较方法 *   让集合具备比较性： *  util包中有一个Comparator接口，建立自定义的比较器实现Comparator，将比较器 * 作为集合构造的参数传入。 */import java.util.*;public class TreeSetDemo {    public static void main(String[] args)    {        TreeSet t = new TreeSet();        t.add(new Student("zhang",12));        t.add(new Student("zhang1",12));        t.add(new Student("zhang2",12));        t.add(new Student("zhang3",12));        t.add(new Student("zhang",12));        for(Iterator it = t.iterator(); it.hasNext();)        {            Student s = (Student)it.next();            System.out.println(s.getName()+"  "+s.getAge());        }    }}class Student implements Comparable{    public int compareTo (Object obj)    {        if(!(obj instanceof Student) )            throw new RuntimeException("不是学生对象");        Student s = (Student)obj;        if(this.age == s.age)        {            return this.name.compareTo(s.name);        }        return this.age - s.age;    }    private String name;    private int age;    Student(String name, int age)    {        this.age = age;        this.name = name;    }    public String getName()    {        return name;    }    public int getAge()    {        return age;    }    //复写equals方法    public boolean equals(Object obj)    {        if(!(obj instanceof Student))            throw new RuntimeException();        Student s = (Student)obj;        return this.name.equals(s.getName()) && this.age ==s.getAge();    }}class MyStudentComparator implements Comparator<Student>{    //自定义的比较器    public int compare(Student s1, Student s2)    {        //用String 的compareTo() 比较s1和s2 的顺序（按字典顺序）。         int x =s1.getName().compareTo(s2.getName());        if(x == 0)        {            //如果name相同，再比较Age.            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));        }        return x;    }}

Iterator接口：

迭代器：是一个接口。作用：用于取集合中的元素。

共性方法：
boolean hasNext() //如果仍有元素可以迭代，则返回 true。
next() // 返回迭代的下一个元素。
remove() //移除迭代返回的元素

每一个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素。将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator接口。
也就说，只要通过该接口就可以取出Collection集合中的元素，至于每一个具体的容器依据自己的数据结构，如何实现的具体取出细节，这个不用关心，这样就降低了取出元素和具体集合的耦合性。

Iterator it = coll.iterator();//获取容器中的迭代器

public static void main(String[] args) {        Collection coll = new ArrayList();        coll.add("abc0");        coll.add("abc1");        coll.add("abc2");        //利用迭代器取出集合中元素的第一种方式        Iterator it = coll.iterator();        while(it.hasNext()){            System.out.println(it.next());        }        //利用迭代器取出集合中元素的第二种方式        for(Iterator it = coll.iterator();it.hasNext(); ){            System.out.println(it.next());        }    }

Map

特点：
Map

package test;/** * 描述一个学生对象，包含姓名，年龄 * 实现comparable接口，复写comparaTo方法 * 复写hashCode， equals ，头String方法 */import java.util.*;public class MapTest {    public static void main(String[] args)    {        TreeMap<Student,String> hm = new TreeMap<Student,String>();        hm.put(new Student("alisi1", 22), "beijing");        hm.put(new Student("blisi1", 20), "tianjing");        hm.put(new Student("abdlisi1", 21), "shenzhen");        //hm.put(new Student("lisi1", 21), "changsha");        //Key(hm);        Value(hm);    }    //使用keySet方法取出集合中键值对（对象引用）的键存入到Set集合中，使用Set的迭代器取出    public static void Key(TreeMap<Student, String> map)    {        Set<Student>  ks = map.keySet();        Iterator<Student> it = ks.iterator();        while(it.hasNext())        {            Student k = it.next();            String v = map.get(k);     //使用map的get()方法取出值。            System.out.println("Key: "+ k +"Value: " + v );        }    }    //通过HashMap的entrySet（）方法获得另外一个集合Set,Set集合中存放的数据是    //集合中键值对的映射关系。这个关系是Map.Entry类型。    //通过这个类中的getKey，getValue可以取出键值对。    public static void Value(TreeMap<Student, String> map)    {        Set<Map.Entry<Student, String>> m = map.entrySet();        Iterator<Map.Entry<Student, String>> it = m.iterator();        while(it.hasNext())        {            Map.Entry<Student, String> me = it.next();            Student k = me.getKey();            String v = me.getValue();            System.out.println("k:  "+ k+"  v: "+v);        }    }}class Student implements Comparable<Student>{    private String name;    private int age;    Student(String name, int age)    {        this.age = age;        this.name = name;    }    public String getName()    {        return name;    }    public int getAge()    {        return age;    }    public void setAge(int age)    {        this.age = age;    }    public void setName(String name)    {        this.name = name;    }    public boolean equals(Object obj)    {        if (!(obj instanceof Student))            throw new ClassCastException("类型不一致");        Student s = (Student) obj;        return  this.name.equals(s.name) && this.age == s.age;    }    public int hashCode()    {        return name.hashCode()+ age*7;    }    public int compareTo(Student s)    {        //先比较年龄大小，再比较姓名的字典顺序。        int num = new Integer(this.age).compareTo(new Integer(s.age));        if (num == 0)        {            return this.name.compareTo(s.name);        }        return num;    }    public String toString()    {        return name+":"+age;     }}

HashMap

特点：

底层是哈希表数据结构。允许使用null键null值，线程不同步

方法：

void clear()
从此映射中移除所有映射关系。
Object clone()
返回此 HashMap 实例的浅表副本：并不复制键和值本身。
boolean containsKey(Object key)
如果此映射包含对于指定键的映射关系，则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
Set

TreeMap

特点：
底层是二叉树数据结构。线程不同步。按键对元素进行排序存储。
方法：
Map.Entry

Hashtable

特点：
底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。
方法：

void clear()
将此哈希表清空，使其不包含任何键。
Object clone()
创建此哈希表的浅表副本。
boolean contains(Object value)
测试此映射表中是否存在与指定值关联的键。
boolean containsKey(Object key)
测试指定对象是否为此哈希表中的键。
boolean containsValue(Object value)
如果此 Hashtable 将一个或多个键映射到此值，则返回 true。
Enumeration elements()
返回此哈希表中的值的枚举。
Set

package com.itheima;/*map扩展知识。map集合被使用是因为具备映射关系。"yureban"   Student("01" "zhangsan");"yureban" Student("02" "lisi");"jiuyeban" "01" "wangwu";"jiuyeban" "02" "zhaoliu";一个学校有多个教室。每一个教室都有名称。*/import java.util.*;class Student{    private String id;    private String name;    Student(String id,String name)    {        this.id = id;        this.name = name;    }    public String toString()    {        return id+":::"+name;    }}class  MapDemo{    public static void demo()    {        HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();        List<Student> reyu = new ArrayList<Student>();        List<Student> jiuye = new ArrayList<Student>();        czbk.put("yureban",reyu);        czbk.put("jiuyeban",jiuye);        reyu.add(new Student("01","zhagnsa"));        reyu.add(new Student("04","wangwu"));        jiuye.add(new Student("01","zhouqi"));        jiuye.add(new Student("02","zhaoli"));        Iterator<String> it = czbk.keySet().iterator();        while(it.hasNext())        {            String roomName = it.next();            List<Student> room = czbk.get(roomName);            System.out.println(roomName);            getInfos(room);        }    }    public static void getInfos(List<Student> list)    {        Iterator<Student> it = list.iterator();        while(it.hasNext())        {            Student s = it.next();            System.out.println(s);        }    }    public static void main(String[] args)     {         demo();        /*        HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();        HashMap<String,String> yure = new HashMap<String,String>();        HashMap<String,String> jiuye = new HashMap<String,String>();        czbk.put("yureban",yure);        czbk.put("jiuyeban",jiuye);        yure.put("01","zhagnsan");        yure.put("02","lisi");        jiuye.put("01","zhaoliu");        jiuye.put("02","wangwu");        //遍历czbk集合。获取所有的教室。        Iterator<String> it = czbk.keySet().iterator();        while(it.hasNext())        {            String roomName = it.next();            HashMap<String,String> room = czbk.get(roomName);            System.out.println(roomName);            getStudentInfo(room);        }//      getStudentInfo(jiuye);//      getStudentInfo(yure);*/    }    public static void getStudentInfo(HashMap<String,String> roomMap)    {        Iterator<String> it = roomMap.keySet().iterator();        while(it.hasNext())        {            String id = it.next();            String name = roomMap.get(id);            System.out.println(id+":"+name);        }    }}