Java容器代码

目录

 

Array：

Collection：

Set和Iterator：

Map：

泛型：

---

Array：

package Container;
import java.util.Arrays;
import java.util.Comparator;
/*
 * Arrays类常用方法：
 * copyOF（）：将一个数组中的值复制到新的数组中
 * sort（）：将一个数组中的值进行排序，默认为升序排列
 * binarySearch（）：在已排好序的数组中查找特定值
 * equals（）：判断两个数组是否相等
 * asList（）：将数组重构为集合
 * 
 * 使用Arrays.sort()可以为数组排序，当数组元素是对象时，判断其大小排序
 * 可以使用java.util.Comparator里的Comparator接口，接口中只有一个compare()方法供其它类实现，（友元函数形式）
 * 也可以使用java.lang.Comparator里的Comparable接口，接口中只有一个compareTo()方法供其它类实现。（成员函数形式）
 * 推荐使用compare()，因为其不改变当前对象的数据。
 */
public class Arrays_ {
	public class employee implements Comparator
	{
		int age;		
		String name;
		float salary;	
		@Override
		public int compare(Object o1,Object o2) {	//大于，等于和小于分别返回正整数，0和负整数
			//职员根据年龄比较
			/*employee e1=(employee)o1,e2=(employee)o2;
			return e1.age-e2.age;*/
			//职员根据工资比较
			employee e1=(employee)o1,e2=(employee)o2;
			float judge=(int)(e1.salary-e2.salary);	//当e1.salary-e2.salary为0-1之间时，转为int会变为0
			if(judge>0)
			return 1;
			else if(judge==0)return 0;
			else return -1;
		}
	}
	public static void main(String agrs[])
	{
		//数组复制
		int a[]=new int[10];
		for(int i=0;i<10;i++)
		{
			a[i]=10-i;
		}
		int b[]=Arrays.copyOf(a, a.length);
		for(int i=0;i<10;i++)
		{
			System.out.print(b[i]+" ");
		} 
		
		//数组排序
		Arrays.sort(a);
		System.out.println("");
		for(int i=0;i<10;i++)
		{
			System.out.print(a[i]+" ");
		}
	}
}

Collection：

package Container;

import java.util.*;
/*
 * Collection（类集）接口:所有实现Collection接口以及Collection子接口的类都能使用迭代器
 * 方法:
 * add():添加一个元素
 * addAll():将其它容器所有元素添加至本容器
 * clear():清空本容器
 * contains():判断容器中是否存在本元素
 * containsAll():判断另一容器是否本容器子容器
 * equals():判断两容器是否相等
 * isEmpty():判断容器是否为空
 * remove():删除一个元素
 * size():返回元素数量（规模）
 * toArray():转化成数组并返回数组引用
 * iterator():迭代器
 * 
 * List:继承于Collection并新增了以下方法
 * add():指定位置添加元素
 * get(indexOf):获得索引处元素
 * set():重设指定元素值
 * indexOf():获取元素索引（位置）
 * lastIndexOf():返回元素最后一次出现位置
 * subList():截取列表的子列表，需给出起始位置和终止位置
 * listIterator():列表迭代器
 * 
 * ArrayList:动态数组，随机存取，会自动增大容量
 * 构造方法：
 * ArrayList():默认构造一个空表
 * ArrayList(int):构造一个已知大小的表
 * ArrayList(ArrayList):复制构造一个已有表
 *  
 * LinkedList:链表，插入删除快速，也可以自动增大容量
 * 实现方法
 * addFirst():首部添加元素
 * addLast():尾部添加元素
 * getFirst():获得表头元素
 * getLast():获得表尾元素
 * removeFirst():删除首部元素
 * removeLast():删除尾部元素
 */
public class Collection_and_List {
	//利用LinkedList构造一个栈结构以及队列结构
	static class Stack
	{
		private LinkedList l;
		Stack(){l=new LinkedList();}
		public void push(Object o)	//入栈
		{
			l.addFirst(o);	//头插法，头元素为最新插入元素
		}
		public void pop()			//出栈
		{
			l.removeFirst();
		}
		public Object top()			//返回栈顶元素
		{
			return l.getFirst();
		}
		public int size() {return l.size();}	//返回栈的规模
		public void clear() {l.clear();}		//清空栈
		
	}
	static class Queue
	{
		private LinkedList l;
		Queue(){l=new LinkedList();}
		public void enter(Object o)		//入队
		{
			l.addFirst(o);
		}
		public void leave()			//出队
		{
			l.removeLast();
		}
		public Object head() {return l.getLast();}//取队首元素
		public Object end() {return l.getFirst();}//取队尾元素
		public int size() {return l.size();}	//返回队列规模
		public void clear() {l.clear();}		//清空队列
	}
	public static void main(String[] args) {
	//测试ArrayList的功能	
		ArrayList a=new ArrayList();
		a.add("Animal");
		a.add("Dog");
		a.add("Cat");
		a.remove(0);
		for(int i=0;i<a.size();i++)System.out.println("动物:"+a.get(i));
	//测试创建的栈和队列
		Stack s=new Stack();
		for(int i=0;i<5;i++)//输入元素
		{
			s.push(i);
		}
		while(s.size()!=0)	//输出容器元素并清空
		{
			System.out.print(s.top()+" ");
			s.pop();
		}
		Queue q=new Queue();
		for(int i=0;i<5;i++)//输入元素
		{
			q.enter(i);
		}
		for(int i=0;i<5;i++)//输入容器元素
		{
			q.enter(i);
		}
		q.clear(); 			//清空容器
		if(s.size()==q.size())
		{
			System.out.println("栈和队列都已空");
		}
	}
}

Set和Iterator：

package Container;
import java.util.*;
/*
 * 迭代器:容器指针
 * 格式:Iterator<实例化类型>来定义指针
 * 容器（Collection）：
 * iterator():返回迭代器值(Iterator)
 * 迭代器（Iterator）：
 * next():第一次指向首个元素，依次指向下一元素。
 * hasNext():判断是否还有下个next值(即下个元素)
 * 
 * Set接口：实现类有HashSet、TreeSet、LinkedSet
 * 俩个特点：不能有重复元素，并且元素没有顺序之分
 * 
 * HashSet:哈希表，是一种顺序加链式结构,通过除以散列因子求余判断当前在数组中位置(hashCode())，定位具体链表后再通过比较判断
 * 元素是否与链表中的值 相等(equals())。
 * TreeSet:实现二叉排序树表(红黑树)后得到的Set，插入和删除比HashSet慢，但优势是元素根据排序规则保持有序
 * 二叉排序树(红黑树)特点：左小右大，中序遍历（左中右）后得到一个有序数组
 * LinkedHashSet:是HashSet的子类,插入元素用链表串起来，可以按元素插入顺序排序
 */
public class Set_and_Iterator {
	static class employee{
		int id;
		employee(int id){this.id=id;}
		public int hashCode() {		//原返回余数的函数，现通过id判断是否为同一对象,即散列码为id
			return this.id;
		}
		public boolean equals(Object o) {	//判断相等函数，原相同余数的函数在此函数判断链表是否有同一元素，现直接判断id
											//是否相等
			employee e=(employee) o;
			if(id==e.id)return true;	//相等，已存在相同id对象
			else return false;			//不相等，不存在相同id对象
		}
	}
	public static void main(String[] args) {
		Set<Integer> s=new HashSet<Integer>();
		//添加0-100里除以6的余数(即范围为0-6的数)
		for(int i=0;i<100;i++)
		{
			s.add(i%6);
		}
		for(Iterator<Integer> it=s.iterator();it.hasNext();)
		{
			System.out.print(it.next()+" ");
		}
		System.out.println();
		//当容器添加的不是常规对象（int,float,String等）类型时，需重写hashCode()函数和equals()函数
		s.clear();
		Set<employee> set=new HashSet<employee>();
		set.add(new employee(1));
		set.add(new employee(1));
		set.add(new employee(1));
		for(Iterator<employee> it=set.iterator();it.hasNext();)
		{
			System.out.print(it.next().id+" ");
		}
		System.out.println();
		HashSet<Integer> hashset=new HashSet<Integer>();
		TreeSet<Integer> treeset=new TreeSet<Integer>();
		LinkedHashSet<Integer> linkedhashset=new LinkedHashSet<Integer>();
		for(int i=0;i<5;i++)
		{
			int temp=(int)(Math.random()*100);
			Integer t=new Integer(temp);
			hashset.add(t);
			treeset.add(t);
			linkedhashset.add(t);
			System.out.println("第"+i+"次随机数为:"+t);
		}
		System.out.println("HashSet:"+hashset);
		System.out.println("TreeSet:"+treeset);
		System.out.println("LinkedHashSet:"+linkedhashset);
	}

}

Map：

package Container;
import java.util.*;
import java.util.Map.Entry;
/*
 * Map:一个键值（key）对应一个对象（value）的容器，并且没有排序
 * 提供以下接口：
 * put(K,V):增添一对键值，若已存在键，则替换值
 * putAll(Map):复制容器Map
 * clear():清空容器键值对
 * remove(Object):删除某个指定键值
 * get(Object):通过键，查找值，找不到返回null
 * size():返回键值对个数
 * isEmpty():判断容器是否为空
 * keySet():返回容器所有键的Set视图
 * values():返回容器所有值得Collection视图
 * entrySet():返回容器所有键值的Set视图
 * containsKey(Object):判断是否包含键
 * containsValue(Object):判断是否包含值
 */
public class Map_ {
	public static void main(String args[])
	{
		Map<Integer,String>m=new HashMap<Integer,String>();
		m.put(1,"yellow");
		m.put(2,"red");
		m.put(3,"color");
		m.put(3,"green");	//测试当已存在键时是否替代值
		System.out.println("Map:"+m);
		m.remove(2);		//删除指定键的键值对
		System.out.println("Map:"+m);
		m.put(2,"red");
		
		//遍历方式：由于Map没有提供iterator()函数，而是用keySet(),values()和entrySet()三个方法取代
		//方法一
		Collection<String> c=m.values();
		for(Iterator<String> it=c.iterator();it.hasNext();) {
			System.out.print(it.next()+" ");
		}
		System.out.println();
		//方法二
		Set<Integer> s=m.keySet();
		for(Iterator<Integer> it=s.iterator();it.hasNext();) {
			System.out.print(it.next()+" ");
		}
		System.out.println();
		//方法三
		/*
		 * Entry对象:把键值当成一个对象，用来转换Map与其它容器（Set）容器的参数不匹配问题
		 * 也提供了获取键，值，以及设置值的方法
		 * getKey():获取当前键值对里的键
		 * getValue():获取当前键值对里的值
		 * setValue(V):重新设置当前键值对里的值
		 */
		Set<Entry<Integer,String>> set=m.entrySet();
		for(Iterator<Entry<Integer,String>>it=set.iterator();it.hasNext();) {
			/*Entry<Integer,String> e=it.next();
			System.out.print(e.getKey()+"---->"+e.getValue()+"  ");*/
			System.out.println(it.next()+" ");
		}
		System.out.println();
	}
}

泛型：

package Container;
import java.util.*;
/*
 * 泛型：一般与容器搭配使用,使用泛型后容器会明确所装元素类型
 * 三种使用方法：
 * 容器实例化使用：所有容器名后+<实例化类型>
 * 定义方法：权限后+<T>,统一变量用T定义
 * 定义接口（纯抽象类）:类名后+<T>
 */
//利用LinkedList类+泛型知识构造一个对任何类型都能使用的栈结构

public class wide_type {
	static class Stack<T>			//已经泛型化的接口（类）所有方法不必再一次泛型
	{
		private LinkedList<T> l;
		Stack(){l=new LinkedList<T>();}
		public void push(T e)
		{
			l.addFirst(e);
		}
		public T top()
		{
			return l.getFirst();
		}
		public void pop()
		{
			l.removeFirst();
		}
		public int size() {return l.size();}
		public void clear() {l.clear();}
	}
	//利用LinkedList类+泛型知识构造一个对任何类型都能使用的队列结构
	static class Queue<T>{
		private LinkedList<T> l;		//因为所有容器都是泛型化的，所以只能把他们实例化为T类型
		Queue(){l=new LinkedList<T>();}
		public void enter(T e) {	//入队
			l.addFirst(e);
		}
		public void leave() {		//出队
			l.removeLast();
		}
		public T head() {			//返回队首元素
			return l.getLast();
		}
		public T end() {			//返回队尾元素
			return l.getFirst();
		}
		public int size() {			//返回队列规模
			return l.size();
		}
		public void clear() {l.clear();}	//清空队列
	}
	public static void main(String agrs[])
	{
		List a=new ArrayList();
		a.add("Dog");
		//String str=a.get(0);	//错误：Object转换成String必须使用(String)强制转换
		//使用泛型后容器会明确所装元素类型
		List<String> l=new ArrayList<String>();
		l.add("Dog");
		String str=l.get(0);
		
		//java容器装对象(String)等，数组装基础类型Array
		//错误示例：Stack<int> s=new Stack<int>();
		Stack<String> s=new Stack<String>();
		s.push("狗吠");
		s.push("猫叫");
		s.push("狼嚎");
		System.out.println("栈顶:"+s.top());
		s.clear();
		Queue<String> q=new Queue<String>();
		q.enter("狗吠");
		q.enter("猫叫");
		q.enter("狼嚎");
		System.out.println("队首:"+q.head()+"  队尾:"+q.end());
		q.clear();
		System.out.println("栈规模:"+s.size()+"队列规模:"+q.size());
	}
}