java数据聚合框架,java聚合框架

java集合框架

1、java集合架构支持3种类型的集合：规则集(Set)，线性表(List)，和图(Map)，分别定义在Set，List，Map中。Set实例存储一组互不相同的元素(集合)，List实例存储一组顺序排列的元素(表)，Map存储一组 对象---关键值的映射

总的架构如下，非常重要，包含继承关系，实现的分类，一目了然：

Collection接口：

Set接口：

HashSet具体类

LinkedHashSet具体类

TreeSet具体类

List接口：

ArrayList具体类

LinkedList具体类

向量类Vector具体类

Stack具体类

Map接口：

HashMap类

LinkedHashMap类

TreeMap类

2、集合Collection接口

--Collection 是任何对象组，元素各自独立，通常拥有相同的套用规则。Set List由它派生。

Collection 和 Collections的区别。

Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。

Collection是个java.util下的接口，它是各种集合结构的父接口

基本操作  增加元素add(Object obj); addAll(Collection c);

删除元素 remove(Object obj); removeAll(Collection c);

求交集 retainAll(Collection c);

删除元素 remove(Object obj); removeAll(Collection c);

求交集 retainAll(Collection c);

访问/遍历集合元素的好办法是使用Iterator接口(迭代器用于取代Enumeration)

3、Set接口

Set：不允许重复，无序，允许1个null值。

实现类：HashSet-基于散列表的集，加进散列表的元素要实现hashCode()方法

LinkedHashSet-对集迭代时，按增加顺序返回元素

TreeSet-基于(平衡)树的数据结构

注：LinkedHashSet只是按照添加的的先后顺序在存储时保持顺序，要给集合元素添加顺序属性，需要使用TreeSet(集合元素有排序关系)。

TreeSet实现排序的2种方式：

》1.通过TreeSet(Comparator super E> comparator) 构造方法指定TreeSet的比较

(1).构造装入TreeSet的java bean

例如：

package src;

public class Foo {

private int num;

public int getNum() {

return num;

}

public void setNum(int num) {

this.num = num;

}

public String toString()

{

return "foo:" + this.getNum() + ",";

}

}

(2).自己实现比较器

例如：

package src;

import java.util.Comparator;

public class MyComparator implements Comparator {

public int compare(Foo f1,Foo f2) {

if (f1.getNum() > f2.getNum())

{

return 1;

}

else if (f1.getNum() == f2.getNum())

{

return 0;

}

else

{

return -1;

}

}

}

(3)new TreeSet时指定比较器

TreeSet set = new TreeSet(new MyComparator());

》2.使用TreeSet()构造方法，并对需要添加到set集合中的元素实现Comparable接口进行排序；

(1).构造bean，需要实现Comparable接口，并重写compareTo()方法，compareTo方法中定义排序的方式

package src;

public class Foo implements Comparable{

private int num;

public int getNum() {

return num;

}

public void setNum(int num) {

this.num = num;

}

public String toString()

{

return "foo:" + this.getNum() + ",";

}

public int compareTo(Object obj) {

if (obj instanceof Foo)

{

Foo foo = (Foo)obj;

if (this.num > foo.getNum())

{

return 1;

}

else if (this.num == foo.getNum())

{

return 0;

}

else

{

return -1;

}

}

return 0;

}

}

(2).创建TreeSet时直接使用构造TreeSet()方法

TreeSet set = new TreeSet();

4、List接口

ArrayList(不同步)：使用数组实现的动态扩展容量的list

LinkedList：是链式实现的list。

Vector(同步)类：它除了包含访问和修改向量的同步方法之外，跟ArrayList一样。

Stack类：它继承自Vector类，，但一般只作为栈的功能来使用，不要去使用Vector里面的功能

注：

一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的

二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

import java.util.Enumeration;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.Stack;

import java.util.Vector;

public class OldCollection {

static void vector(){

//实现可变长度的对象数组

//组件可以使用整型下标访问

//线程安全

Vector vector = new Vector();

vector.add("a");

vector.add("b");

vector.add("c");

vector.add("d");

vector.add("e");

System.out.println(vector);

//老的迭代器 里面没有删除的方法

Enumeration enumeration = vector.elements();

while(enumeration.hasMoreElements()){

System.out.println(enumeration.nextElement());

}

for (Iterator iter = vector.iterator(); iter.hasNext();) {

Object element = (Object) iter.next();

if(element.equals("c")){

iter.remove();

}

}

System.out.println(vector);

}

static void stack(){

Stack stack = new Stack();

//先进后出

stack.push(1);//压入栈顶

stack.push(2);//压入栈顶

stack.push(3);//压入栈顶

stack.push(4);//压入栈顶

stack.push(5);//压入栈顶

int count = stack.size();

for (int i = 0; i < count; i++) {

System.out.println("查看栈顶:"+stack.peek());

//System.out.println(stack.pop());//移除并返回值

}

}

static void linkedList() {

LinkedList linkedList = new LinkedList();

linkedList.add("center");

linkedList.addFirst("first");

linkedList.addLast("last");

System.out.println(linkedList);

linkedList.removeFirst();

System.out.println(linkedList);

linkedList.removeLast();

System.out.println(linkedList);

}

/**

* @param args

*/

public static void main(String[] args) {

//vector();

//stack();

linkedList();

}

}

5、Map接口

(1)实现类

HashMap：效率高

LikedHashMap：按照添加顺序存储，可以按添加顺序取出

TreeHashMap：排序性

(2)处理Map的三种集合

关键字集KeySet()

数值集value()

项目集enrySet()

(3)Map.Entry接口

getKey()

getValue()

setValue()

import java.util.Collection;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import java.util.Map.Entry;

public class TestMap {

/**

* 关键字唯一 将键映射至值的对象 每个键最多都只能映射至一个值 无序排列 键值对

* 键不可以重复，值可以重复

*/

static void mapFunction() {

HashMap map = new HashMap();

map.put("a", "aaaa");

map.put("key1", "value1");

map.put("key2", "value2");

map.put("key3", "value3");

map.put("key4", "value4");

map.put("yy", "vyyy");

map.put("yy", "same");// 覆盖前面的键值对

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

int size = map.size();//集合的键值对个数

Object get = map.get("key2");//通过键获得值

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

boolean containsKey = map.containsKey(new String("yy"));// true 是否包含键

boolean containsValue = map.containsValue("same");//是否包含值

map.remove("key1");// 移除键值对s

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

//map.clear();

System.out.println("isEmpty="+map.isEmpty());//判断map是否包含键值对

Map map2 = new HashMap();

map2.put("1", "11");

map2.put("2", "22");

map.putAll(map2);

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

//for (int i = 0; i < 100; i++) {

//map.put(i, i*i);

//}

//

//int i = 8;

//System.out.println(map.get(i));

}

static void mapIterator() {

//三种迭代

// 1 键set keySet

// 2 值集合 collection values

//3 键值对实体 entrySet set里面存放的是entry对象

Map map = new Hashtable();

map.put("keya", "valuea");

map.put("keyb", "valueb");

map.put("keyc", "valuec");

System.out.println("迭代一 键set集合");

Set keySet = map.keySet();

for (Iterator iter = keySet.iterator(); iter.hasNext();) {

Object key = (Object) iter.next();

Object value = map.get(key);

System.out.println(key+":"+value);

}

System.out.println("迭代二 value集合 collection");

Collection values = map.values();

for (Iterator iter = values.iterator(); iter.hasNext();) {

Object value = (Object) iter.next();

System.out.println(value);

}

System.out.println("迭代三 键值对的实体set视图");

Set entrySet = map.entrySet();

for (Iterator iter = entrySet.iterator(); iter.hasNext();) {

Entry entry = (Entry) iter.next();

System.out.println(entry.getKey()+":"+entry.getValue());

if(entry.getKey().equals("keya")){

entry.setValue("修改后的值");

}

}

System.out.println(map);

}

/**

* @param args

*/

public static void main(String[] args) {

mapIterator();

}

}

6、迭代器Iterator快速失败机制

Iterator是获取集合中元素的过程，实际上帮助获取集合中的元素。

快速失败：报出的异常为 java.util.ConcurrentModificationException 异常

当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。

当使用 fail-fast iterator 对 Collection 或 Map 进行迭代操作过程中尝试直接修改 Collection / Map 的内容时，即使是在单线程下运行， java.util.ConcurrentModificationException 异常也将被抛出。

Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。

所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。