集合框架一

学习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中有有多种不同的集合，每一种集合的数据结构不一样，

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

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

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

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