【黑马程序员】java中----------Collection集合框架

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

一、集合容器描述

1. 集合是容器，主要是用于存储对象。容器有很多种，主要是因为对数据的存储结构不同而不同

2. 数据多了可以用数字存储，对象多了可以用集合存储，数组长度固定，而集合是可变长度的

3. 集合中存储的是对象的引用（就是内存地址）

4. collection是顶层接口，其中有两大实现类List集合和Set集合

二、集合和数组的区别

数组：同一个数组只能存储同一种数据，一但声明就不可以改变，可以存储数组对象也可以存储基本数据类型

多数情况下都是用数组存储基本数据

集合：只可以存储对象，长度是可以改变的，类型可以多样

三、集合的特点

1. 只用于存储对象，长度可变，可以存储不同类型的对象

2. 集合是一个接口，是众多集合的共性内容

四、数据结构

每种容器对数据 的存储方式是不一样的，所以出现不同容器的数据结构不相同。

五、集合框架体系图

六、集合中的共性方法

1.增加

boolean  add（objectobj）添加元素

boolean addAll（collection<? extends  E>c）将指定collection集合中的所有元素添加到此集合中

2.删除

void  clear()移除集合中所有的元素

boolean  remove(object   obj)  为真的条件下将元素移除

boolean   removeAll(collection<?> c)

3.判断

boolean   contains(object  o)判断指定元素是否存在

booleanisEmpty();判断集合是否为空

4.获取

int  size（）；获取集合长度

booleanretainAll(collection <?>  c);获取两个集合的交集

5.对元素的取出方式：迭代器

Iterator<E>  iterator();返回此集合中的迭代器

booleanhasNext();判断是否有下一个元素

Enext();返回迭代的下一个元素

void  remove（）；异常迭代器返回的元素

6.集合转换成数组

toArray()；

List接口

一、List接口继承Collection接口，List接口中最常用的3个已实现的集合类：ArrayList、LinkedList、Vector

二、ArrayList、LinkedList、Vector集合的区别

ArrayList集合：底层是数据结构是数组结构，查询速度快，增删慢，线程不同步

LinkedList集合：底层数据结构是链表数据结构，增加删除快，查询比较慢，线程不同步

Vector集合：底层数据结构是数组结构，增删改查都比较慢，被ArrayList所替代。jdk1.2版本出现

三、List接口提供的特有共性方法

1. 增加

booleanadd（intindex，E element）；在指定位置增加元素

booleanaddAll(collection<?  extendsE>c);将指定集合中的元素添加进集合的末尾处

2. 删除

Eremove（intindex）；删除指定位置上的元素

void  removeRage（int   fromIndex，inttoIndex）删除指定开始索引到指定位置的元素

3. 修改

E   set(int   index, E   element);替换指定位置上的元素

4. 获取

E  get(int  index);  获取指定位置上的元素

intindexOf(objectelement);返回指定元素的角标

intlastIndexOf(object     element);返回指定元素最后一次出现的角标

List<E>subList(int  fromIndex,int  toIndex);返回指定开始位置到指定结束位置上的元素的集合

注意事项：

1. listIterators是List集合特有的迭代器，是Iterator子接口。

2. 操作集合中的元素，要注意避免发生并发修改异常（ConcurrentModficationException）

所以操作集合中的元素，需要用到迭代器Iterator，但是Iterator中的方法只有3个，

不满足需求的情况下使用：listIterator迭代器（包括增删改查方法）

3. 要注意，迭代器的使用时，hasNext()判断一次，只能调用一次next（）；

4. List中提供了contains（objecto）方法，判断元素是否包含,依据的是equals()方法

四、Vector集合

Vector集合中特有的取出方式，即为枚举。

1. 枚举与Iterator都是取出元素的方式，为了简化书写，Iterator代替了枚举

Enumeration<?>elements();返回此向量组件的枚举

练习代码：

class VectorDemo{public static void main(String[] args) {Vector v = new Vector();v.add("java01");v.add("java02");v.add("java03");v.add("java04");Enumeration en = v.elements();while(en.hasMoreElements()){System.out.println(en.nextElement());}}}

五、LinkedList集合

jdk1.2中的方法

1. 增加：

addFirst(E   e);将指定元素添加到集合的第一个位置

addLast(Ee);将指定元素添加到集合的末尾处

2. 获取：

EgetFirst();返回集合中第一个元素，不删除元素

EgetLast();返回集合中最后一个元素，不删除元素

如果元素不存在，则发生没有这个元素异常：NoSuchElementsException
3. 删除

EremoveFirst();移除集合中第一个元素，元素被删除

EremoveLast();移除集合中最后一个元素，元素被删除

jdk1.6版本出现的替代方法；

增加；

offerFirst(E e);将指定元素添加进集合中的开头

offerLast(E e); 将指定元添加进集合的末尾处

获取：

peakFirst(); 获取集合的第一个元素，不删除元素

peakLast（）； 获取集合的最后一个元素，不删除元素

 删除：

pollFirst();移除集合中第一个元素，并且返回

pollLast（）；返回最后一个元素，并且删除元素

代码练习：

/*用LinkedList模拟堆栈或者队列结构堆栈：先进先出队列：先进后出*///将我们要的功能封装成一个类，在开发中，经常这样做import java.util.*;class duiLie{private LinkedList link;duiLie(){link =new LinkedList();}public void myAdd(Object obj){link.addFirst(obj);//先进//link.addLast(obj);}public Object myGet(){return link.removeFirst();//后出//return link.removeLast();//先出}public boolean isNull(){return link.isEmpty();}}class LinkedListTest{public static void main(String[] args){duiLie dl=new duiLie();dl.myAdd("云1");dl.myAdd("云2");dl.myAdd("云3");dl.myAdd("云4");while(!dl.isNull()){System.out.println(dl.myGet());}}}

set集合

一、特点

集合中不可以存储重复元素，，

元素是无序的（存入和取出的顺序不一致），

线程不同步

二、HashSet集合

数据结构是哈希表结构，元素不可重复，线程同步，唯一的取出元素的方式

Iterator迭代器，

1. 保证元素的唯一性的依据：

通过元素的两个方法：hashCode()和equals（object    o）方法

如果元素的hashCode()值相同，才会去判断equals（）方法是否为真；

如果hashCode ()值相同，就不会去判断equals（）方法，间接的提供了比较效率

注意：对于判断元素是否存在，添加和删除操作，都是依赖元素的hashCode()和equals（0方法

练习代码：

/*Set:元素是无序的（存入和取出的顺序是不一致的），元素不可以重复hashSet集合，是哈希表数据结构它保证元素唯一是通过两个方法，hashCode方法和equals方法如果元素的hashCode值相同，才会调用equals方法进行比较*/import java.util.*;class HashSetDemo{public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args){HashSet hs=new HashSet();//sop(hs.add("java1"));//add方法的返回值是boolean:true//sop(hs.add("java1"));//false,,hashCode值相同，所以hs.add("java3");hs.add("java2");hs.add("java2");hs.add(new Person("zhangsan1",20));hs.add(new Person("zhangsan2",26));hs.add(new Person("zhangsan3",25));hs.add(new Person("zhangsan3",25));Iterator it=hs.iterator();while(it.hasNext()){Object obj=it.next();if(obj instanceof Person){Person p=(Person)obj;sop(p.getName()+"====="+p.getAge());}else {sop(obj);}}}}class Person{private String name;private int age;Person(String name,int age){this.name=name;this.age=age;}public int hashCode(){System.out.println(this.name+"-----hashCode");        //查看对象自动调用此方法return  this.name.hashCode()+age*8;//为了避免不同的两个对象的哈希值相同，age可以乘一个数}public boolean equals(Object obj){if(!(obj instanceof Person)){return false;}Person p=(Person)obj;System.out.println(this.name+"-----equals+++++++++"+p.name);//查看对象自动调用此方法return this.name.equals(p.name)&&this.age==p.age;}public String getName(){return name;}public int getAge(){return age;}}

TreeSet集合

特点：

此集合数据结构是二叉树结构，

元素不可以重复

此集合会按照元素的自然顺序进行排序

线程不同步

如果存入的集合不具备比较性，会发生异常：ClassCastException

保证元素唯一性的依据：

根据元素的调用compareTo()方法的返回值（正、负、零）判断元素是否为同一个元素；

返回值为：0，视为元素相同，不存储

元素不具备比较性怎么办：

第一种方式：让元素实现Comparable接口，覆盖compareTo()方法。让元素具备比较性

练习代码：

/*TreeSet集合：元素具备自然排序；如果元素不具备比较性需要让元素具备比较性实现接口：Comparable;  复写compareto()方法,就这一个方法学生按照age排序，如果age相同，则判断次要条件：this.name.compareTo(s.name);name是字符串，compareTo()方法*/import java.util.*;class TreeSetTest{public static void main(String[] args){TreeSet ts=new TreeSet();ts.add(new Student("云01",22));ts.add(new Student("云07",20));ts.add(new Student("云08",20));ts.add(new Student("云04",40));Iterator it=ts.iterator();while(it.hasNext()){Student stu=(Student)it.next();System.out.println(stu.getName()+"---"+stu.getAge());//System.out.println(it.next());}}}//让学生具备比较性，实现Comoarable接口class Student implements Comparable{private String name;private int age;Student(String name,int age){this.name=name;this.age=age;}public String getName(){return name;}public int getAge(){return age;}//覆盖compareTo()方法public int compareTo(Object obj){if(!(obj instanceof Student))throw new RuntimeException("不是学生");Student s=(Student)obj;System.out.println(this.name+"----compareto---"+s.name);if(this.age>s.age)    return 1;if(this.age==s.age)     return this.name.compareTo(s.name);return -1;}}

第二种方式：定义比较器

如果让元素自身具备比较性不是我们所需要的，这是可以让集合自身具备比较性；

自定义一个比较器，并且实现Comparator接口，并且覆盖compare（object   o）方法

根据：此方法的返回值（零、正数、负数）来判断存入的元素是否相同

注意事项：两种排序方式都存在时，以比较器为主，排序时，主要条件相同时，比较次要条件

练习代码：

/*在TreeSet集合中：如果元素的排序方式不是所需要的，（即使是实现的comparable）那么就需要自定义：比较器，实现comparator接口；自定义比较器，让集合自身具备比较性；并通过treeset集合的构造函数传进去两种排序方式都在时，以比较器为主。*/import java.util.*;class TreeSetTest1{public static void main(String[] args){TreeSet ts=new TreeSet(new MyComparator());ts.add(new Student("huchangsheng01",23));ts.add(new Student("huchangsheng03",25));ts.add(new Student("huchangsheng01",40));ts.add(new Student("huchangsheng05",27));ts.add(new Student("huchangsheng07",29));  Iterator it=ts.iterator();while(it.hasNext()){Student stu=(Student)it.next();System.out.println(stu.getName()+".........."+stu.getAge());}}}//自定义比较器，让集合自身具备比较性class MyComparator implements Comparator{public int compare(Object o1,Object o2){Student s1=(Student)o1;Student s2=(Student)o2;int num=s1.getName().compareTo(s2.getName());if(num==0)return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));return num;}}//让学生具备比较性，实现Comoarable接口class Student implements Comparable{private String name;private int age;Student(String name,int age){this.name=name;this.age=age;}public String getName(){return name;}public int getAge(){return age;}//覆盖此方法public int compareTo(Object obj){if(!(obj instanceof Student))throw new RuntimeException("不是学生");Student s=(Student)obj;//System.out.println(this.name+"----compareto---"+s.name);//查看TreeSet底层自动调用此方法if(this.age>s.age)    return 1;if(this.age==s.age)     return this.name.compareTo(s.name);return -1;}}

练习代码：自定义比较器，一length长度排序

/*以lenhth()来排序,用的是集合比较器*/import java.util.*;class TreeSetTest2{public static void main(String[] args){TreeSet ts=new TreeSet(new StringLengthComparator());    //参数可以改写匿名类部类ts.add("云ad");ts.add("云badc");ts.add("云ce");ts.add("云abc");Iterator it=ts.iterator();while(it.hasNext()){//Student stu=(Student)it.next();//System.out.println(stu.getName()+"---"+stu.getAge());System.out.println(it.next());}}}class StringLengthComparator implements Comparator{public int compare(Object o1,Object o2){String s1=(String)o1;                 //向下强转String s2=(String)o2;int num=new Integer(s1.length()).compareTo (new Integer(s2.length()));if (num==0){//如果有相同length()需要判断return s1.compareTo(s2);}return num;/*if(s1.length()>s2.length());return 1;if(s1.length()<s2.length());return -1;return 0;*/}}

练习代码：

/*泛型在比较器当中的应用泛型的出现，用于解决安全问题，也避免了强转麻烦*/  import java.util.*;class TreeSetTest3{public static void main(String[] args){TreeSet<String> ts=new TreeSet<String>(new StringLengthComparator());   ts.add("abcd");ts.add("cc");ts.add("cba");ts.add("aaa");ts.add("z");ts.add("hahahaha");//通过TreeSet集合获取迭代器Iterator<String> it=ts.iterator();while(it.hasNext()){String s =it.next();System.out.println(s);}}}class StringLengthComparator implements Comparator<String>{public int compare(String o1,String o2){//String s1=(String)o1;                 //泛型不用向下强转//String s2=(String)o2;int num=new Integer(o1.length()).compareTo (new Integer(o2.length()));if (num==0){//如果有相同length()需要判断return o1.compareTo(o2);//如果想顺序互换，可以o1,o2换位置}return num;}}

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