JAVA实现栈并实现迭代器_java集合-Collections

学习阶段，以下不考虑泛型

附继承关系图：

简化版

完整版

1.集合接口：6个接口(短虚线表示)，表示不同集合类型，是集合框架的基础。

2.抽象类：5个抽象类(长虚线表示)，对集合接口的部分实现。可扩展为自定义集合类。

3.实现类：8个实现类(实线表示)，对接口的具体实现。

一、java集合框架的学习目的

学习集合每个容器的特点，包括对象的存储和取出

二、顶层接口Collection的方法

集合中顶层接口中所有的抽象方法，下面的子类或者接口都是具备的，接口中的方法都是抽象的，找实现类ArrayList，也就是接口指向实现类，运行的方法都是子类重写后的方法。

1.以ArrayList为例

add(Object o); //将元素添加到集合，存储到集合

addAll(collection c); //参数是一个集合，把一个集合存储到另一个集合

void clear(); //清楚集合中的所有对象，但是集合容器还在

int size(); //但会集合中存储元素的个数

boolean isEmpty(); //判断集合中元素个数是不是0，是返回True

boolean contains(Object o); //判断集合众是不是包含这个对象，如果包含返回True

boolean containsAll(Collection c); //一个集合是否完全包含另一个集合，是集合中存储的对象，如果完全包含，返回True

boolean remove(Object o);// 移除集合中的元素，移除成功返回True

//***********

//注意：如果集合中包含多个此元素，remove只移除第一个，也就是一次调用只能移除一个元素

boolean removeAll(Collection c);// 移除两个集合中的相同元素

boolean retainAll(Collection c);//保留两集合中相同的元素也就是取交集,只要原始集合没变，就返回False

toArry(); //集合专数组

2.方法运行Demo

import java.util.*;

public class CollectionDemo {

/*

* 练习collection中的方法

*/

public static void main(String[] args) {

method();

}

public static void method(){

Collection col = new ArrayList();

Collection col1 = new ArrayList();

col.add("a");

col.add("b");

col.add("c");

col.add("a");

col.add("a");

col1.add("a");

col1.add("b");

col1.add("e");

col.retainAll(col1);

System.out.println(col.containsAll(col1));

System.out.println(col.size());

System.out.println(col);

}

}

三、迭代器-Iterator

迭代器就是从集合中取出元素的方式

但是每种集合子类存储对象的方式不同，造成获取对象的方式也不同，因此规定了一个接口(iterator)，所有子类的迭代器必须满足接口规则

每一个集合的子类中，都有一个方法iterator()，返回的就是自己的内部类的对象，但是这个内部类实现了iterator接口

iterator iterator() //方法是获取迭代器对象的方法，返回值是一个接口，返回的就是这个接口的实现类

1.Iterator接口中的方法

boolean hasNext();//判断集合中有没有下一个被取出的元素，有返回true

Object next();//获取集合中的从下一个元素

void remove();//移除元素，就是迭代过程中移除

2.迭代器的实现源码演示

使用ArrayList为例演示

public class ArrayList extends XXX implements List{

//用方法iterator来返回内部类对象

public Iterator iterator(){

return new Itr();

}

//用内部类来实现迭代器的方法，并设置为私有，不向外暴露

private class Itr implements Iterator{

public boolean hasNext();

public Object next();

public void remove();

}

}

//外部调用的方式

Iterator it = new ArrayList对象.iterator();

3.迭代器取集合中元素的步骤

调用集合方法iterator()获取迭代器接口的实现类对象

调用接口Iterator方法hasNext()判断集合中有没有下一个元素

调用接口Iterator方法next()获取集合中的元素

public static void main(String[] args) {

//创建集合对象ArrayList

Collection con =new ArrayList();

con.add(1);

con.add(2);

con.add(3);

con.add(4);

//使用迭代器获取集合中的元素

Iterator it = con.iterator();

while(it.hasNext()){

System.out.println(it.next());

it.remove();

}

while(it.hasNext()){

System.out.println(it.next());

}

}

/*输出结果

1

2

3

4

*/

4.迭代器注意事项

如果hasNext()判断为false，还用next()获取，出现没有元素被取出异常

在迭代的过程中，不允许使用集合的方法改变集合长度，出现并发修改异常

迭代器创建好以后，只能迭代一次

一次迭代中，不允许出现多次next方法

四、list接口派系

Lsit接口继承Collection接口，自己成立一个派系。特点(有序，重复，下标)：

存储是有序的。顺序：存储和取出的顺序相同

允许存储重复

元素都有下标

1.List接口特有方法

void add(int index,Object o)//在列表的指定位置上插入元素

boolean addAll(int index,Collection c)//在列表的指定位置上插入另一个集合

Object get(int index)//返回指定索引上的元素！

Object remove(int index)//移除指定下标上的元素，返回移除前的对象

Object set(int index,Object o)//修改指定下标上的元素，返回修改前的元素

List subList(int start,int end)//获取集合中的一部分，包含头，不包含尾，返回新集合

demo:

import java.util.ArrayList;

import java.util.List;

/*

* List接口的特有方法

*/

public class ListDemo {

public static void main(String[] args) {

List list = new ArrayList();

list.add("a");

list.add("b");

list.add("c");

list.add("d");

/*

* void add(int index,Object o)

* 在列表的指定位置前插入元素

*/

list.add(2,"z");

System.out.println(list);

/*

* void addAll(int index,Collection o)

* 在列表的指定位置插入另一个集合

* 插入的集合为空时，返回false

*/

List list2 = new ArrayList();

list2.add("e");

list2.add("f");

list2.add("g");

list2.add("h");

list.addAll(5,list2);

System.out.println(list);

/*

* Object get(int index);

* 返回指定下标上的元素

*/

for(int i = 0;i

System.out.print((String)list.get(i)+',');

}

System.out.print('\n');

/*

* Object remove(int index)

* 移除指定下标上的元素

*/

list.remove(0);

System.out.println(list);

/*

* Object set(int index, Object o);

* 修改指定位置上的元素，并返回修改前的元素

*/

System.out.println(list2.set(0, "a"));

System.out.println(list2);

/*

* List subList(int start, int end)

* 获取集合一部分，有头无尾

*/

System.out.println(list.subList(1, 3));

}

}

2. List派系特有迭代器

迭代器只能应用于List集合，其他集合不能用。

List特有迭代器接口ListIterator，这个接口是Iterator的子接口。

List的派系的每一个子类，都有一个方法listIterator，返回ListIterator接口的实现类对象，这个实现类，就是集合的内部类。

2.1特点

迭代中，可以使用迭代器方法，进行添加，修改，删除集合中的元素，两个方向遍历

2.2方法

add(Object)//添加，迭代到哪个对象，添加到这个对象的后面

set(Object)//修改，迭代到哪个对象，修改的就是哪个对象

remove()//删除

hasPrevious() == hasNext() //逆向使用

previous() == next() //逆向使用

3.ArrayList类

容器的底层实现方式，可变长度数组(扩容，自动复制数组)，数组默认大小10个长度。

线程不安全集合，运行速度快。查询速度快，增删慢

每次增长50%。

ArrayList使用的频率最高，速度快，查询也快

可以存储NULL

4.Vector类

开始版本JDK1.0 ，升级到JDK1.2的时候，才出现了集合框架的概念。类Vector在JDK1.2版本后，改为实现List接口。Vector类底层实现，也是可变数组，增长率100%，线程安全，运行速度慢。 从JDK1.2版本开始，Vector被ArrayList取代

5.LinkedList类

特点和List接口，一致，重复，有序，下标

LinkedList底层实现原理：链表结构，查询慢，增删快，线程不安全，运行速度快

存储和取出，实现代码，和ArrayList完全一致

5.1LinkedList特有方法

addFirst(Object o);//头部添加元素

addLast(Object o);//尾部添加元素

Object getFirst();//获取头部

Object getLast();//获取尾部

Object removeFirst();//移除头部

Object removeLast();//移除尾部

//在LinkedList中，1.6版本开始，添加了几个新的方法，来操作集合

boolean offerFirst() boolean offerLast() //替换的了 addFirst() addLast(),返回永真

Object peekFirst() Object peekLast() //替换了 getFirst() getLast().如果集合中是空的，获取后返回null不会出现异常

Object pollFirst() Object pollLast()// 替换了 removeFirst() removeLast().如果集是空的返回null,不会出现异常

5.2LinkedList模拟队列和堆栈

堆栈：内存中的数据，先进去的，后出来

队列：内存中的数据，先进去的，先出来

特点：符合LinkedList类的特点，存储对象的时候，开头结尾，获取对象的时候，可以在开头和结尾获取。

package collectionDemo;

import java.util.*;

/*

* 通过LinkedList实现队列和栈

*/

public class LinkedListTest {

public static void main(String[] args) {

Heap h = new Heap();

h.put("a");

h.put("b");

h.put("c");

h.put("d");

h.put("e");

h.put("f");

System.out.println(h);

System.out.println(h.pop());

System.out.println(h.pop());

System.out.println(h.pop());

System.out.println(h.pop());

System.out.println(h.pop());

System.out.println(h.pop());

System.out.println(h.pop());

Queue q = new Queue();

q.put(1);

q.put(2);

q.put(3);

q.put(4);

q.put(5);

System.out.println(q);

System.out.println(q.pop());

System.out.println(q.pop());

System.out.println(q.pop());

System.out.println(q.pop());

System.out.println(q.pop());

System.out.println(q.pop());

}

}

//实现栈

class Heap{

private LinkedList h ;

Heap(){

this.h = new LinkedList();

}

public void put(E o){

this.h.addFirst(o);

}

public E pop(){

return this.h.pollFirst();

}

public String toString(){

return this.h.toString();

}

}

//实现队

class Queue{

private LinkedList q;

Queue(){

this.q = new LinkedList();

}

public void put(E o){

this.q.addFirst(o);

}

public E pop(){

return this.q.pollLast();

}

public String toString(){

return this.q.toString();

}

}