java集合-Collections

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(); //集合专数组

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() //方法是获取迭代器对象的方法，返回值是一个接口，返回的就是这个接口的实现类

boolean hasNext();//判断集合中有没有下一个被取出的元素，有返回true
Object next();//获取集合中的从下一个元素
void remove();//移除元素，就是迭代过程中移除

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();

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
*/

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)//获取集合中的一部分，包含头，不包含尾，返回新集合

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<list.size();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));
	}
}

	 add(Object)//添加，迭代到哪个对象，添加到这个对象的后面
     set(Object)//修改，迭代到哪个对象，修改的就是哪个对象
     remove()//删除
     hasPrevious() == hasNext() //逆向使用
     previous() == next() //逆向使用

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,不会出现异常

package collectionDemo;

import java.util.*;

/*
 * 通过LinkedList实现队列和栈
*/

public class LinkedListTest {
	public static void main(String[] args) {
		Heap<String> h = new Heap<String>();
		
		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<Integer> q = new Queue<Integer>();
		
		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<E>{ 
	private LinkedList<E> h ;
	
	Heap(){
		this.h =  new LinkedList<E>();
	}
	
	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<E>{
	
	private LinkedList<E> q;
	
	Queue(){
		this.q = new LinkedList<E>();
	}
	
	public void put(E o){
		this.q.addFirst(o);
	}
	
	public E pop(){
		return this.q.pollLast();
	}
	
public String toString(){
		
		return this.q.toString();
	}

}