集合框架一

学习Collection类的时候先看一下API怎么解释的：

Collection类：


public interface Collection<E>extends Iterable<E>


Collection层次结构中的根接口。

下面我们要学习的两个子接口：List<E>  Set<E>


–Collection


-List


-ArrayList


-LinkedList


-Set


-HashSet


-TreeSet

Map类：


public interface Map<k,v>;


将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值

要学习的实现类：


HashMap   LinkedHashMap   TreeMap




Collection 接口，针对的集合是单层集合

而Map<k,v>接口是以键值对出现的。我个人称为多层集合

第一步：学习Collection类：《父接口》

一：Collection类的概述：

Collection类：

位于：java.util包下，所以在使用的时候结的导入这个包。

public interface Collection<E>extends Iterable<E>，是根接口。

Collection类表示一组对象，这些对象也称为Collection的元素。


一些 collection 允许有重复的元素，而另一些则不允许。


一些 collection 是有序的，而另一些则是无序的




注意：哪些集合类可以重复？哪些集合类不能重复？


List集合可以重复——Set集合不能重复


 哪些集合类表示有序？哪些集合类不表示有序了？


List集合有序——-Set集合无序





说明：有序表示谁先存储，谁先出来

Collection是从1.2版本开始使用的

二、集合和数组的区别：


1.长度的区别：


A:数组的长度是固定的


B:集合的长度是可变的


2.存储的内容不一样，


A:数组存储的是同一种数据类型的元素


B:集合可以存储不同的类型的元素


3.存储的数据类型不一样：


A:数组可以存储基本数据类型，也可以存储引用数据类型


B:集合只能存储引用数据类型

关键代码：


Collection c = new ArrayList();


c.add(1);//自动转换成Integer类，调用的valueOf（）方法


c.add(2);


c.add(3);


c.add(‘a’);


c.add(“a”);//自动转换成包装类 调用的valueOf（）方法


c.add(false);


System.out.println(“c:”+c);








—————————-

源码：


Collection c = new ArrayList();


c.add(Integer.valueOf(1));


c.add(Integer.valueOf(2));


c.add(Integer.valueOf(3));


c.add(Character.valueOf(‘a’));


c.add(“a”);


c.add(Boolean.valueOf(false));


System.out.println(“c:” + c);

补充：在分析问题的时候：


从具体到抽象


在实现代码的时候：


从抽象到具体


在使用的时候：


使用具体

三、Collection接口的成员方法：


1.添加方法：


boolean add(Object obj):添加一个元素;


boolean addAlll(Collection c);添加一个集合元素；谁调用就往哪个里面添加所有


2.删除功能：


void clear();移除所有的元素


boolean remove(Object o);移除一个元素


boolean removeAll(Collection c）移除一个集合的元素《只要移除了一个元素，都返回true》


3判断功能：


boolean contains(Object o):判断集合中是否包含指定的元素


boolean containsAll(Collection c):判断集合中是否包含指定的集合元素（包含了所有元素才返回true）


boolean isEmpty();是否为空


4.长度：


集合的长度是通过：int size()方法


而数组是通过length属性来获取数组的长度的


字符串中有length方法。


5.把集合转换成数组：


Object[] toArray();


6.交集功能：


boolean retainAll(Collection c);两个集合是否有交集


思考：


思考元素去哪了，返回的boolean又是什么意思呢?


如果有两个集合A和B


A对B做交集，最终的结果保存在A中，


返回值表示的是A是否发生过改变


7.集合框架的节点：Iterator


Collection<String> c = new ArrayList<String>();


c.add(“hello”);


c.add(“world”);


c.add(“java”);


c.add(“kevin”);


c.add(“cidy”);





Iterator<String> it = c.iterator();


while(it.hasNext()){//判断是否存在下一个元素


String s = it.next();


System.out.println(s):


}

案例：用集合存储5个学生对象，并把学生对象进行遍历：


/*

 * 学生类：

 */

public class Student {


//姓名


private String name;


//年龄：


private int age;


public Student() {


super();


// TODO Auto-generated constructor stub


}


public Student(String name, int age) {


super();


this.name = name;


this.age = age;


}


public String getName() {


return name;


}


public void setName(String name) {


this.name = name;


}


public int getAge() {


return age;


}


public void setAge(int age) {


this.age = age;


}


//重写了toString()方法


@Override


public String toString() {


return name+”—–“+age;


}


}

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

/*

 * 用集合存储5个学生对象，并把学生对象进行遍历

 */

public class CollectionTest {


public static void main(String[] args) {


Collection<Student> c = new ArrayList<Student>();

Student s1 = new Student(“tom”, 24);


Student s2 = new Student(“kevin”, 28);


Student s3 = new Student(“cidy”, 22);


Student s4 = new Student(“Jon”, 24);


Student s5 = new Student(“Dive”, 29);

c.add(s1);


c.add(s2);


c.add(s5);


c.add(s4);


c.add(s3);

Object[] arr = c.toArray();


for (int i = 0; i < arr.length; i++) {


// 如果不重写toString()方法，打印的是地址值，在Studnet类中重写toString方法


System.out.println(arr[i]);


}


System.out.println(“———————-“);


// 转换成数组后可以使用增强for


for (Object o : arr) {


System.out.println(o);

System.out.println(“————————–“);


Iterator<Student> it = c.iterator();


while (it.hasNext()) {


Student s = it.next();


System.out.println(s.getName() + “—” + s.getAge());


//java.util.NoSuchElementException


//不要多次调用it.next();汇报上面的错误的


//System.out.println(it.next().getName()+”—“+it.next().getAge());





}


}


}

}

思考：迭代器为什么定义成一个接口，而不是类了？


假如把迭代器定义一个类，那么都可以创建对象，通过对象调用方法


从而来遍历集合，但是在java中有有多种不同的集合，每一种集合的数据结构不一样，


存储数据和遍历方式应该不一样，所以把迭代器定义为一个接口。




无论你是哪种集合的遍历，都应该具备判断和获取功能，每种集合遍历的方式不一样，

我们把具有相同功能抽取出来，并不提供具体的实现。

那么正直的实现，应该在子类中，以内部类的方式体现