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

最新推荐文章于 2021-12-24 15:19:20 发布

weixin_39604557

最新推荐文章于 2021-12-24 15:19:20 发布

阅读量340

点赞数

文章标签： 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() 方法会在删除当前迭代对象的同时维护索引的一致性。