温州做微网站设计/武汉seo主管

JCF

JCF(Java Collection Framework)

容器：能存放数据的空间结构(数组、树)

容器框架：为表示和操作容器而规定的一种标准体系结构(C++中的STL、java中的JCF)

对外的接口：容器中能存放抽象的数据类型

接口的实现：可复用的数据结构

算法：对数据的查找和排序

JCF主要数据结构实现类：

列表(List、Arraylist、LinkedList)

集合(Set、HashSet、TreeSet、LinkedHashSet)

映射(HashMap、TreeMap、LinkedHashMap)

JCF主要的算法类：

Arrays：对数组进行查找和排序等操作

Collections：对Collection及其子类进行排序和查找操作

Colletction接口定义的方法：

返回类型

方法名(参数类型，参数)

描述

int

Size()

容器中对象的数目

boolean

isEmpty()

是否为空

void

clear()

清空

boolean

contains(Object element)

是不是包含element对象

boolean

add(Object element)

添加element的对象

boolean

remove(Object element)

移除element对象

iterator

iterator()

返回一个Iterator对象，用于遍历容器中的对象

boolean

containsAll(Collection c)

是否包含c容器中的所有对象

boolean

addAll(Collection c)

把c容器中的所有对象添加到容器中

boolean

removeAll(Collection c)

从容器中移除C容器中存在的所有对象

boolean

retainAll(Collection c)

求当前的集合类与C容器的交集

Object[]

toArray()

把容器中的所有对象转换到对应的数组中

List(列表)

list的两个特征：

有序的Collections

允许重复的元素

List主要实现的三种类：

ArrayList(非同步的)

LinkedList(非同步的)

Vector(用的比较少)

ArrayList

以数组实现的列表，但不支持同步。

利用索引位置可以快速定位访问

不适合指定位置的插入、删除操作。

和java数组相比，其容量可以动态调整的。

Arraylist在元素填满容器时会自动扩充容器大小的50%

命名原则：

例如：ArrayList al=new ArrayList()；其中<>是泛型表示al这个数据结构里只能容纳Integer的对象，其他对象无法放入。

public classArrayListTest {public static voidmain(String[] a) {

ArrayList al = new ArrayList();

al.add(3);

al.add(2);

al.add(1);

al.add(4);

al.add(5);

al.add(6);

al.add(new Integer(6));for(Integer i:al) {

System.out.println(i);

}

自动装箱：

尽管ArrayList只能装对象，但是上面代码中有add(3)会将普通的int变量3自动装箱为Integer(3)的对象放入；

所以上面al.add(6)和al.add(new Integer(6))其实是一样的效果。

LinkedList

以双向链表实现的列表，不支持同步

可以被当作堆栈、队列、双端队列进行操作

随机访问较差，中间插入删除高效

适合经常变化的数据

命名规则和自动装箱机制与Arraylist一样不做过多介绍

集合(Set)

集合的三大特性：

确定性：对任意对象都能判定是否属于某一个集合

互异性：集合内每个元素都是不相同的

无序性：集合内顺序无关

java中的集合类：

HashSet(基于散列函数的集合，无序，不支持同步)

TreeSet(基于树结构，可排序，不支持同步)

LinkedHashSet(基于散列函数和双向链表的集合，可排序，不支持同步)

HashSet

示例代码：

public classHashSetTest {public static voidmain(String[] args) {

HashSet hs = new HashSet();

hs.add(null);

hs.add(1000);

hs.add(20);

hs.add(3);

hs.add(40000);

hs.add(5000000);

hs.add(3); //3 重复

hs.add(null); //null重复

System.out.println(hs.size()); //6

for(Integer i:hs) {

System.out.print(i+" ");

}

可以看出来，重复的元素不会被放入容器中，容器中的元素顺序也跟放入顺序无关是无序的。(ArrayList容器跟元素放入顺序一样的)

TreeSet

基于TreeMap实现，不可以容纳null元素，不支持同步

方法(add、clear、contains、remove、size)

根据compareTo方法或者指定所存储对象大小升序输出

public classTreeSetTest {public static voidmain(String[] args) {

TreeSet ts = new TreeSet();//ts.add(null); 错误，不支持null

ts.add(1000);

ts.add(20);

ts.add(3);

ts.add(40000);

ts.add(5000000);

ts.add(3); //3 重复

System.out.println(ts.size()); //5

for(Integer i:ts) {

System.out.print(i+" ");

}

System.out.println();if(!ts.contains(6))

{

ts.add(6);

}

System.out.println(ts.size());//6

ts.remove(3);

System.out.println(ts.size());//5

ts.clear();

System.out.println(ts.size());//0

LinkedHashSet

继承HashSet，基于HashMap实现，可以容纳null元素。

不支持同步

通过一个双向链表维护插入顺序(插入顺序保留)

示例代码：

public classLinkedHashSetTest {public static voidmain(String[] args) {

LinkedHashSet lhs = new LinkedHashSet();

lhs.add(null);

lhs.add(1000);

lhs.add(20);

lhs.add(3);

lhs.add(40000);

lhs.add(5000000);

lhs.add(3); //3 重复

lhs.add(null); //null 重复

System.out.println(lhs.size()); //6

for(Integer i:lhs) {

System.out.print(i+" ");

}

System.out.println();if(!lhs.contains(6))

{

lhs.add(6);

}

System.out.println(lhs.size());//7

lhs.remove(3);

System.out.println(lhs.size());//6

可以很清楚的看出，LinkedHashSet可以容纳null元素，而且因为保留了顺序，其遍历顺序和插入顺序一致。

HashSet和LinkedHashSet判定元素重复原则

判定两个元素的hashcode返回值是否相同，若不同返回false

两者的hashcode相同，判定equals方法，若不同返回false，否则返回true

hashcode和equals方法所有类都有，因为Object类有

我们先写一个一个Cat类和Dog类，Cat 类没有hashcode方法，Dog类重写了hashcode方法，其返回具体的size。代码如下：

/*Cat类本身没有hashcode()，而是继承Objiect类的，

* 而Object类的hashcode()会返回对象信息和内存

* 地址经过运算后的一个int值，所以他们的hashcode返回值是不一样的*/

classCat

{private intsize;public Cat(intsize)

{this.size =size;

}

}

/** Dog类本身改写了hashcode()方法，其返回值是具体

* 的size。所以两个 不同的Dog(4)，他们的hashcode

* 返回值是相同的*/

classDog {private intsize;public Dog(ints) {

size=s;

}public intgetSize() {returnsize;

}public booleanequals(Object obj2) {

System.out.println("Dog equals()~~~~~~~~~~~");if(0==size -((Dog) obj2).getSize()) {return true;

}else{return false;

}

}public inthashCode() {

System.out.println("Dog hashCode()~~~~~~~~~~~");returnsize;

}publicString toString() {

System.out.print("Dog toString()~~~~~~~~~~~");return size + "";

}

}

public classObjectHashSetTest {public static voidmain(String[] args) {

System.out.println("==========Cat HashSet ==============");

HashSet hs = new HashSet();

hs.add(new Cat(2));

hs.add(new Cat(1));

hs.add(new Cat(3));

hs.add(new Cat(5));

hs.add(new Cat(4));

hs.add(new Cat(4));

System.out.println(hs.size());//6

System.out.println("========================");

LinkedHashSet lhs= new LinkedHashSet();

lhs.add(new Cat(2));

lhs.add(new Cat(1));

lhs.add(new Cat(3));

lhs.add(new Cat(5));

lhs.add(new Cat(4));

lhs.add(new Cat(4));

System.out.println(lhs.size());//6

System.out.println("==========Dog HashSet ==============");

HashSet hs2 = new HashSet();

hs2.add(new Dog(2));

hs2.add(new Dog(1));

hs2.add(new Dog(3));

hs2.add(new Dog(5));

hs2.add(new Dog(4));

hs2.add(new Dog(4));

System.out.println(hs2.size());//5

System.out.println("========================");

LinkedHashSet lhs2= new LinkedHashSet();

lhs2.add(new Dog(2));

lhs2.add(new Dog(1));

lhs2.add(new Dog(3));

lhs2.add(new Dog(5));

lhs2.add(new Dog(4));

lhs2.add(new Dog(4));

System.out.println(lhs2.size());//5

可以最后得出Dog类通过hashcode方法识别出来Dog(4)判定是相同的，所以第二个Dog(4)不会被放入容器中。

Map(映射)

两个集合之间元素对应关系

键值对应(K-V对)，{key,value}。

主要的三种类：

HashMap

TreeMap

LinkedHashMap

HashMap

K-V对，K和V都允许为null

不同步，多线程不安全

无序的

主要的方法：clear、containValue、containKey、get、put、remove、size

public static voidmain(String[] args) {

HashMap hm =new HashMap();

hm.put(1, null);

hm.put(null, "abc");

hm.put(1000, "aaa");

hm.put(2, "bbb");

hm.put(30000, "ccc");

System.out.println(hm.containsValue("aaa"));

System.out.println(hm.containsKey(30000));

System.out.println(hm.get(30000));

hm.put(30000, "ddd"); //更新覆盖ccc

System.out.println(hm.get(30000));

hm.remove(2);

System.out.println("size: " +hm.size());

hm.clear();

System.out.println("size: " + hm.size());

LinkedHashMap

基于双向链表维持插入顺序的HashMap。