黑马程序员_java集合<七>

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！
----------------------




1，集合类的特点：只能存储对象，可以是不同类型的对象，长度是可变的。

接口Collection方法
   
添加：                           
        boolean add(E e)                           
        boolean addAll(Collection c)
   
删除：
       void clear():清空容器
       boolean remove(Objec object):
       boolean removeAll(Collection c):
   
判断：
       boolean contains(Object object):判断是否包含此元素
       boolean containsAll(Collection c):判断是否包含一堆元素
       boolean equals(Object object):比较此collection与指定对象是否相等
       boolean isEmpty():判断是否集合为空
   
获取：
       Iterator iterator():取出
       int hashCode():返回此collection的哈希值
       int size():返回此collection中元素的个数

       boolean retainAll(Collection c):取交集
       Object toArray():返回此collection中所有元素的数组
       
T[] toArray(T[] a):返回包含此collection中所有元素的数值。
 Collection:

            List:元素是有序的(元素带角标索引)，可以有重复元素,可以有null元素。

                   ArrayList:底层的数据结构是数组数据结构，特点是查询速度快(带角标)，但是增删速度稍慢,因为当元素多时，增删一个元素则所有元素的角标都得改变 线程不同步。默认长度是10，当超过长度时，按50%延长集合长度。                  

             
   LinkedList:底层数据结构式链表数据结构(即后面一个元素记录前一个)， 特点：查询速度慢，因为每个元素只知道前面一个元素，但增删速度快因为元素再多，增删一个，只要让其前后的元素重新相连即可。线程是不同步的。 
                         
            Vector（线程同步）：  底层数据结构是数组数据结构.特点是查询和增删速度都很慢。默认长度是10，当超过长度时,按100%延长集合长度。(Vector功能跟ArrayList功能一模一样，已被ArrayList替代)
ArrayList: 元素要求有序，元素要求不重复。
               public boolean equals(Object obj) {
                if(!(obj instanceof Student))
                    return false;

                Student stu = (Student)obj;
                return this.name.equals(st
4000
u.name) && this.age==stu.age;
               }
              则往ArrayList集合通过add存入学生对象时，集合底层自己会调用学生类的equals方法， 判断重复学生则不存入。  注：对于List集合，无论是add、contains、还是remove方法，判断元素是否相同，都是通过复写equals方法来判断！

LinkedList特有方法：
                 boolean offerFirst(E e); 在此列表的开头插入指定的元素。
                 boolean offerLast(E e);在此列表末尾插入指定的元素。
                 E peekFirst();获取但不移除此列表的第一个元素；列表为空，返回 null。
                 E peekLast();最后一个元素；列表为空，返回 null。

                 E pollFirst();获取并移除此列表的第一个元素；列表为空，返回 null。
                 E pollLast();最后一个元素；列表为空，返回 null。
           如果要求增删快，考虑使用LinkedList；如果要求查询快，考虑使用ArrayList； 如果要求线程安全，考虑使用Vector。

Set:集合:元素是无序的(因为没有索引)，元素不可以重复。可以有null元素。
              HashSet(JDK1.2):底层数据结构是哈希表、存取速度快、元素唯一、线程不同步。
                     保证性元素唯一的原理:先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true (往HashSet里面存的自定义元素要复写hashCode和equals方法，以保证元素的唯一性！)
               TreeSet:底层数据结构式二叉树。可以对Set集合中的元素进行排序。元素有序、线程不同步。 保证元素唯一性的依据：compareTo方法return
.
                     TreeSet排序的一种方式:让元素自身具备比较性，比如八种基本数据类型或则字符串，实现Compareble接口,覆盖compareTo方法， 此方式是元素的自然顺序 
    
                     TreeSet排序的另一种方式:当元素自身不具备比较性(比如存储学生对象时)或者具备的 比较性不是我们所需要的比较性时(比如想字符串的长度排序), 此时就需要让集合自身具备自定义的比较性。
              让集合自身具备比较性，可在集合初始化时，就让集合具备比较方式。即定义一个类，实现Comparator接口，覆盖compare方法。
 
Set
           HashSet:
                 通过new的方式往HashSet里面存的元素的hashCode都不同，但通常我们定义对象，为了保证元素的唯一性，我们通常在往HashSet集合里面存储元素时，在定义对象的类中通常复写hashCode和equals方法。
                  public int hashCode()  {
                return   name.hashCode()+age*39;
                  }
                  public boolean equals(Object obj)  {
                if(!(obj instanceof Student))
                    return  false;
                Student  stu = (Student)obj;
                return this.name.equals(stu.name) && this.age==stu.age;
                  }
         -如果两元素的hashCode值不同，则不会调用equals方法
         -如果两元素的hashCode值相同，则继续判断equals是否返回true；

    (2)TreeSet:要求往里面存的元素具备比较性，否则会报错。
TreeSet让元素自身具备比较性
                 定义对象类，实现Compareble接口,复写compareTo方法，此方式是元素的自然顺序
                  class Student implements Comparable {
                    privateStringname;
                    privateintage;
              publicStudent(String name,int age)  {
                        this.name=name;
                        this.age=age;
                    }
                    publicString getName() {
                        returnname;
                    }
                    publicint getAge() {
                        returnage;
                    }
                    public  int compareTo(Object obj)  {
                        if(!(objinstanceof Student))
                            thrownew RuntimeException("不是学生对象！");
                        Studentstu = (Student)obj;
                        intnum = this.age-stu.age;
                        if(num==0)
                            returnthis.name.compareTo(stu.name);
                        returnnum;
                    }
                  }
TreeSet让集合具备比较性
                     即定义一个类，实现Comparator接口，覆盖compare方法。
                 class String LengthComparator implements Comparator {
                    public int compare(Object obj1,Object obj2) {
                        String s1 = (String)obj1;
                        String s2 = (String)obj2;
                        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
                        if(num==0)
                        return s1.compareTo(s2);
                        return num;
                    }
                 }
                 class TreeSetTest  {
                    public  static void main(String[] args) {
                        TreeSet ts = new TreeSet(new StringLengthComparator());
                        ts.add("addfg");
                        ts.add("dfg");
                        sop(ts);
                    }
               
 }                  
           基本数据类型或字符串对象均实现了Comparable接口，故同种类型基本数据间具备比较性（自然顺序）。

Map:顶层接口,该集合存储的是键值对,而且键是唯一的,Map和Set很像,Set集合底层就是使用了Map集合。
        Map集合没有迭代器，要取出元素必须先将Map集合转换成Set集合才能遍历元素。
     
 HashTable： 底层是哈希表数据结构； 不可以使用null键和null值； 线程同步，效率低；
       
       用作键的对象必须实现hashCode和equals方法来保证键的唯一性。
       
       HashMap：底层是哈希表数据结构；允许使用null键和null值；线程不同步，效率高；
       保证元素的唯一性：先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true 。
        classStudent {
            private String name;
            private int age;
            public Student(String name, int age) {
                super();
                this.name= name;
                this.age= age;
            }
            public  int getAge() {
                return  age;
            }
            public  void setAge(int age) {
                this.age= age;
            }
 
   publicString getName() {
                return  name;
            }
            public  void setName(String name) {
                this.name= name;
            }   
            @Override
            public  int hashCode(){
                return  name.hashCode()+age*34;
            }
            @Override
            public  boolean equals(Object obj){       
                if(!(objinstanceof Student))
                    return  false;
                Student  stu = (Student)obj;
                return  this.name.equals(stu.name)&&this.age==stu.age;
            }
        public  class HashMapDemo1 {
            public  static void main(String[] args) {
                Map<Student, String> hmap = new HashMap<Student , String>();
                hmap.put(newStudent("001",20), "beijing");
                hmap.put(newStudent("002",25), "hebei");
                hmap.put(newStudent("003",50), "hainan");
                hmap.put(newStudent("001",20), "beijing");
                System.out.println(hmap.size());

                Set<Student>keySet = hmap.keySet();
                Iterator<Student>it = keySet.iterator();
                while(it.hasNext()){
                    Student  stu = it.next();
                    String  addr = hmap.get(stu);
                   
System.out.println(stu.getName()+".."+stu.getAge()+"::"+addr);
                }  
            }  
        }          
       TreeMap：底层是二叉树结构； 允许使用null键和null值； 线程不同步；可以给Map集合中的键进行排序。
让元素自身具备比较性。
       
当元素自身不具备比较性(比如存储学生对象时)或者具备的比较性不是我们所需要的比较性时，让集合具备比较方式，即定义一个类， 实现Comparator接口，覆盖compare方法。
        class  Student implements Comparable<Student>{
            private  String name;
     
    private int age;
            public  Student(String name, int age) {
                super();
                this.name= name;
                this.age= age;
            }
            public  int getAge() {
                return  age;
            }
            public  void setAge(int age) {
                this.age= age;
            }
            public  String getName() {
                return  name;
            }
            public  void setName(String name) {
                this.name= name;
            }
            @Override
            public  int compareTo(Student stu) {
                int  num = new   Integer(this.age).compareTo(new  Integer(stu.age));
                if(num==0)
                    return  this.name.compareTo(stu.name);
                return  num;
            }          
        }
    public class HashMapDemo1 {
            publicstatic void main(String[] args) {            
                Map<Student, String> tmap = new TreeMap<Student , String>();
                tmap.put(new Student("001",20), "beijing");
                tmap.put(new Student("002",25), "wuhan");
                System.out.println(tmap.size());
                Set<Student>keySet1 = tmap.keySet();
                Iterator<Student> it1 = keySet1.iterator();
                while(it1.hasNext()){
                    Student stu = it1.next();
                    String addr = tmap.get(stu);
                    System.out.println(stu.getName()+".."+stu.getAge()+"::"+addr);     
                }
            }
        }
 
Iterator：对collection进行迭代的迭代器.迭代器取代了Enumeration。

        迭代器和枚举的区别：

        迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的collection移除元素，方法名称得到了改进，简化书写。

LisIterator：允许程序员按任一方向遍历列表、迭代期间修改列表。       
Comparable：进行整体自然排序，使其具备比较性。
Comparator：强行进行整体排序，使其具备比较性。
Collections：collection工具类，由静态方法组成。
Arrays：array工具类，由静态方法组成。
 

泛型：将运行时期出现的类型转换异常问题转移到编译时期，避免了强制转换的麻烦。
定义格式：通过<>来定义要操作的引用数据类型
       ArrayList<String>al = new ArrayList<String>;

泛型限定
           向上限定：? extends E  ;E可以接收E类型或者E的子类
           向下限定：? super E  ;E可以接收E类型或者E的父类

高级for循环
只用于集合和数组的遍历，集合只能用Collection不能用Map集合；只能把Map集合转化成Set集合，才能用for循环。
   
格式：
        for(数据类型 变量名:被遍历的集合(Collection)或者数组) {
           ······
        }
     局限性：
       
必须要有遍历的目标， 对集合或者数组进行遍历时，只能获取集合元素，不能对集合元素进行操作， 迭代器除了遍历，还可以进行remove操作集合中的元素 列表迭代器还可以在遍历过程中进行增删改查的操作。
   
传统for循环和高级for循环的区别：
       
高级for循环有一个局限性，就是必须要有遍历的目标(集合或者数组)， 遍历数组时建议使用传统for循环，因为可以定义角标，比如打印100次helloworld时用传统for循环方便。

可变参数
       
格式：
            publicstatic void show(String str，int... arr) {
 ······
            }
       注意：可变参数一定要放在参数列表的最后面。

静态导入：
        import语句可以导入一个类或某个包中的所有类。
        import  static语句导入一个类中的某个静态方法或所有静态方法 静态导入后，静态方法前面就不用写类名.方法的方式类调用。
       
例：
            import  static java.lang.Math.sin;//导入一个静态方法
            import  static java.lang.Math.*; //导入一个类中的所有静态方法
       注意：当类名重复时，需要制定具体的包名；当方法重名时，需要制定具体所属的对象或者类

Collections类：collection工具类，由静态方法组成。
        static <T> boolean addAll(Collection<? super T> c, T... elements); 将所有指定元素添加到指定
collection中。
        static <T> void fill(List<? super T> list, T obj); 使用指定元素替换指定列表中的所有元素。
        static <T> boolean replaceAll(List<T> list, T oldVal, T newVal); 使用另一个值替换列表中出现的所有某一指定值。
        static void reverse(List<?> list);反转指定列表中元素的顺序。
        static <T> Comparator<T> reverseOrder();返回一个比较器，它强行逆转实现了 Comparable接口的对象
collection的自然顺序
        static <T> Comparator<T> reverseOrder(Comparator<T> cmp); 返回一个比较器，它强行逆转指定比较器的顺序。

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！
----------------------

详细请查看：<a href="http://edu.csdn.net" target="blank">http://edu.csdn.net</a>