黑马程序员--集合框架

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

、集合类 &  容器

 

集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

 

集合框架的构成及分类

 

两大接口

Java集合类主要由两个接口派生出来：

Collection

Set          ：不能存放重复对象

List         ：可存放重复对象，有序

Queue     ：队列

SortedSet       ：可对集合数据排序

Map      

SortedMap      ：可对集合数据排序

 

 

2、Collection接口

 

方法：

boolean add(Object o):该方法用于向集合里面添加一个元素，若集合对象被添加操作改变了，返回true.

boolean addAll(Collection c):把集合c里面的所有元素添加到指定集合里面去，如果集合对象被添加操作改变了返回true.

void clear():清除集合里面的所有元素，将集合长度变为0。

boolean contains(Object o):返回集合里是否包含指定的元素。

boolean containsAll(Collection c):返回集合里是否包含集合c内所有的元素。

boolean isEmpty()：返回集合是否为空（长度是否为0）。

Iterator iterator():返回一个Iterator对象，用于遍历集合里的元素。

boolean remove(Object o)：删除集合中指定元素o。

boolean removeAll(Collection c):从集合中删除集合c里面的元素。若删除一个或以上返回true。

boolean retainAll(Collection c):从集合中删除集合c里不包含的元素。

int size()：得到集合元素的个数。

Object[] toArray():把集合转成一个数组，所有集合元素编程数组元素。

Eg：public class Demo10 {    public static void main(String[] args) {        Collection<String>c = new ArrayList<String>();               c.add("A");        c.add("A");        c.add("A");        c.add("A");        //c.add(new Date());上面写了泛型，这个语句就是错误的了，因为泛型规定了加进来的类型！        System.out.println(c);}}

 

3、Iterator接口

 

 

迭代是取出集合中元素的一种方式。

因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

迭代器的next方法返回值类型是Object，所以要记得类型转换。（学到泛型就可以消除强转！）

 

Eg：Iterator iter = l.iterator();while(iter.hasNext()){       System.out.println(iter.next());}

 

 

4、集合遍历输出方式

 

 

集合遍历输出方式：

1.        Iterable接口（迭代遍历） 注：优先选择Iterator接口，遍历Collection里所有元素，也称为迭代器和迭代精灵；迭代是取出集合中元素的一种推荐方式。

2.        Foreach循环 注：可以直接用，使用场合：数组和Iterable对象！

3.        For循环     注：在（）内实例化Iterable对象，进行遍历！

4.        先用toArray方法输出成为数组，再用Foreach循环！

 

Eg：package july7;//遍历输出的四种方式 import java.util.ArrayList;import java.util.Iterator;import java.util.List; public class Demo11 {    public static void main(String[] args) {         List<String> l = new ArrayList();         l.add("1");        l.add("2");        l.add("3");        l.add("4");         System.out.println(l);        /**         * 遍历输出：四种方式         */         // 1、推荐使用的Iterator对象，迭代输出！        Iterator it =l.iterator();        while (it.hasNext()) {            System.out.println("迭代输出：" + it.next());        }         // 2、对集合进行fore循环！        for (String str : l) {            System.out.println("fore集合迭代输出：" + str);        }         // 3、for循环迭代，在for方法体内部实例化Iterator对象！        int i = 0;// for方法体内定义项不能出现多种不同类型        for (Iterator iter = l.iterator(); i < l.size(); i++) {            System.out.println("for循环迭代实例化输出：" + iter.next());        }         // 4、先将集合转换为数组，再利用数组的遍历输出；        Object[] o =l.toArray();        for (Object object : o) {            System.out.println("转换数组迭代输出：" + object);        }    }}

 

5、Set接口（元素不可以重复）

 

Set是Collection子接口；

Set和Collection基本上一样，一点除外：

Set无法记住添加的顺序，不允许包含重复的元素。

当试图添加两个相同元素进Set集合，添加操作失败，add()方法返回false。

Set判断两个对象是否相等用equals,而不是使用==。

也就是说两个对象equals比较返回true，Set集合是不会接受这个两个对象的。

常用子类：

HashSet:散列存放

TreeSet:有序存放

 

hashCode方法对于HashSet的作用

 

HashSet类是Set接口最常用的实现类,采用hash算法存储数据,具有良好的存储和查找功能。

散列存储:不记录添加顺序;排列顺序时，顺序有可能发生变化;

线程不安全的，多个线程访问一个HashSet要使用同步代码;

HashSet集合元素值允许是null,但是最多只能有一个;//因为Set集合就不可以装重复的对象！

hash(翻译为哈希,或散列)算法的功能:

保证通过一个对象快速找到另一个对象;

其算法价值体现在速度,可以保证查询快速执行;

当从HashSet中访问元素时,HashSet先计算该元素的hashCode(也就是该对象的hashCode方法返回值),然后直接到该HashCode对应的位置取出该元素;

在这里对象的hashCode就好比是数组里的索引,但是不是索引;

 

HashSet元素添加

 

当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,判断已经存储在集合中的对象的hashCode值是否与添加的对象的hashCode值一致:若不一致:直接添加进去;若一致,再进行equals方法比较,equals方法如果返回true,表明对象已经添加进去了,就不会再添加新的对象了,否则添加进去;

如果我们重写了equals方法,也要重写hashCode方法,反之亦然;。

HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode方法返回值也相等。

如果需要某个类的对象保存到HashSet集合中，覆写该类的equals()和hashCode()方法，应该尽量保证两个对象通过equals比较返回true时,他们的hashCode返回也相等。

 

我的总结：

很重要的一点：理解！往HashSet集合里面存入数据，要先后调用两个方法：hashCode方法和equals方法！！！

备注：使用eclipse添加这两个方法。

 

Eg：package july7;//hashset方法和equals方法判断输入的对象是否重复！ import java.util.HashSet;import java.util.Set; class PersonDemo{    private String name;     public PersonDemo(String name) {        super();        this.name = name;    }     @Override    public String toString() {        return "name= " + name ;    }    //没有覆写hashcode和equals方法前，显示三次（一样的）。覆写后，只剩下一个了！说明覆写后方法起作用了，重复的输入不进去！    @Override    public int hashCode() {        final int prime = 31;        int result = 1;        result = prime * result+ ((name == null) ? 0 : name.hashCode());        return result;    }     @Override    public boolean equals(Object obj) {        if (this == obj)            return true;        if (obj == null)            return false;        if (getClass() != obj.getClass())            return false;        PersonDemo other =(PersonDemo) obj;        if (name == null) {            if (other.name != null)                return false;        } else if (!name.equals(other.name))            return false;        return true;    }} public class Demo12 {    public static void main(String[] args) {               Set s = new HashSet();               s.add(new PersonDemo("12122"));        s.add(new PersonDemo("3242"));        s.add(new PersonDemo("2342"));        System.out.println(s);    }}  

 

 

6、TreeSet

 

TreeSet是SortedSet接口唯一的实现，与HashSet相比额外的方法有：

Comparator comparator():返回当前Set使用的Comparator,若返回null,表示以自然顺序排序。

Object first() 返回此 set 中当前第一个(最低)元素。

Object last() 返回此 set 中当前最后一个(最高)元素。

SortedSet subSet(Object  fromElement, E toElement) 返回此 set 的部子集，其元素从 fromElement（包括）到 toElement（不包括）。

SortedSet headSet(Object  toElement)返回此 set 的部分子集，其元素严格小于toElement。

SortedSet tailSet(Object  fromElement) 返回此 set 的部分子集，其元素大于等于fromElement。

 

 

TreeSet的排序之自然排序

 

TreeSet会调用元素的compareTo(Object o)方法来比较元素之间的大小关系,然后将集合里的元素按升序排列.此时需要排序元素的类必须实现Compareble接口,并覆写其int compareTo(Objecto)方法;

该方法用于比较对象,若:obj1,compareTo(obj2),返回0,表示两个对象相等,若返回一个正整数,表示obj1大于obj2,若返回一个负整数,表示obj1小于obj2;

对于TreeSet集合而言,判断两个对象相等的标准是:

compareTo()方法比较返回 0;

 

package july7;//TreeSet可以自动进行排序！最简单的情况 import java.util.Set;import java.util.TreeSet; public class Demo13 {    publicstatic void main(String[] args) {               Set<Integer> s = newTreeSet<Integer>();        s.add(1);        s.add(192);        s.add(123);               s.add(56);        s.add(13);        s.add(96);        System.out.println(s);//[1, 13, 56, 96, 123,192]    }} 稍复杂点的 package july7;//TreeSet的自然排序，升序 import java.util.Set;import java.util.TreeSet; class Student implements Comparable{//必须实现接口    private Integer age;     public Student(Integer age) {        super();        this.age = age;    }     @Override    public int compareTo(Object o) {//比较的规则，运用泛型可以消除强转！        if(o instanceof Student){            Student s = (Student)o;            return this.age.compareTo(s.age);        }        return 0;    }     @Override    public String toString() {        return age+"" ;    }} public class Demo14 {    public static void main(String[] args) {               Set<Student> s = new TreeSet();        s.add(new Student(140));        s.add(new Student(15));        s.add(new Student(11));        s.add(new Student(63));        s.add(new Student(96));        System.out.println(s);//[11, 15, 63, 96, 140]    }}

 

 

TreeSet的排序之定制排序

 

TreeSet的自然排序是根据元素的大小进行升序排序的,若想自己定制排序,比如降序排序,就可以使用Comparator接口了:

该接口包含intcompare(Object o1,Object o2)方法,用于比较两个对象的大小,比较结果和compareTo方法一致;

要实现定制排序,需要在创建TreeSet集合对象时,提供一个一个Comparator对象,该对象里负责集合元素的排序逻辑;

TreeSet(Comparator comparator)

 

Eg：package july7;//定制排序的话，必须在创建TreeSet集合对象的时候提供一个Comparator方法 import java.util.Comparator;import java.util.Set;import java.util.TreeSet; class Student1{    private Integer age;       public Student1(Integer age) {        super();        this.age = age;    }     public Integer getAge() {        return age;    }     public void setAge(Integer age) {        this.age = age;    }     @Override    public String toString() {        return age + "";    }} class MyComparator implements Comparator{       @Override    public int compare(Object o1, Object o2) {        if(o1 instanceof Student1 & o2 instanceof Student1){            Student1 s1 = (Student1)o1;            Student1 s2 = (Student1)o2;            if(s1.getAge() >s2.getAge()){                return -1;            }else if(s1.getAge() < s2.getAge()){                return 1;            }        }        return 0;    }} public class Demo15 {    public static void main(String[] args) {        Set<Student1> s = new TreeSet(new MyComparator());        /**         * 要实现定制排序,需要在创建TreeSet集合对象时,提供一个一个Comparator对象,         * 该对象里负责集合元素的排序逻辑;         */        s.add(new Student1(140));        s.add(new Student1(15));        s.add(new Student1(11));        s.add(new Student1(63));        s.add(new Student1(96));               System.out.println(s);    }}