collection.txt

Java大部分的基础知识,EJB3,EJB2,WEBSERVICE,SOAP,JMS,MQ,还有些面试题

集合框架
	作用:集合有很多实现类，作用都是一样的，可以存放多个不同类型的对象，存储传输对象。
	     差别是不同的实现类存储对象的数据结构不一样， 针对不同的处理选择不同的集合实现类。		
	组成:
		接口:
			Collection
			List
			Set
			Map			
		算法:
			Collections
		实现:
			ArrayList
			HashSet
			TreeSet
			Vector
			HashMap
			Hashtable
	框架结构:
	集合的通用方法:
		add
		addAll(集合):加入一个集合
		remove
		removeAll(集合):删除两个集合重复的元素
		size:实际元素的个数
		capacity:集合的最大容量
		get:取一个元素
		indexOf:查找一个元素
		contains:是否包括一个元素
		containsAll:是否包括一个集合
		empty():是否为空
	List的三种遍历方式
		for
		iterator:迭代器
		enumeration:序列
	Set值不可以重复，只有两种遍历方式
		iterator:迭代器
		enumeration:序列
	map:键名+键值，键不可以重复,reques、session、application、page都属生map接口集
		keySet:键名
		values: 键值
		entrySet:键名+键值
	Collections:是一个算法，所有方法都是静态方法，是对集合对象的通用处理。
		
		
		
集合的作用?
	是数据的容器，可以存放不同类型的对象，集合有很多实现类,
	作用是一样的，只不过存储的数据结构不一样，在增、删、改
	查操作的效率上不一样。
集合的组成?
	接口
		Colection List Set Map
	实现类
		ArrayList Vector LinkedList 
		HashSet TreeSet HashMap Hashtable
	算法
		Collections
			1、sort:对一个集合排序
			2、reverse:返序一个集合
			3、max:取集合中最大值
			4、min:
集合的框架结构?
				Collection(可以直接加入一个对象，不用键名)
		List(值可以重复) 			Set(值不可重复)
ArrayList	Vector      LinkedList（链表）   	    HashSet		TreeSet(可以排序，所以类型必须相同)
				
				Map(键名+键值,键名不可以重复，键值可以重复)
			HashMap		Hashtable
集合的通用方法?
	iterator
	size
	add
	addAll:一个集合中加入另一个集合
	remove:删除一个元素
	removeAll:一个集合与另一个集合中的元素比较,若相同将当前集合删除
	empty():是否为空
	get(下标):取
	indexOf(对象):查
List遍历的三种方式:
	iterator
	enumeration
		Enumeration e=Collection.enumeration(集合);
		while(e.hasMoreElement())
		{
			e.nextElement();
		}
	for
Set只有两种遍历方式:
	iterator:迭代器
	enumeration:序列
Hashmap或Hasttabel的相关方法
	--得到所有键名
	Set keys=hm.keySet();
	--得到所有键值
	Collection col=hm.values();
	--得到所有键名+键值
	Set set=hm.entrySet();
一、线性表
	public class List
	{
		private int maxSize;
		private int size;
		private int index;
		private int a[];
		public List(int maxSize)
		{
			this.maxSize=maxSize;
			this.size=0;
			this.index=-1;
			a=new int[maxSize];
		}
		public void addLast(int data)
		{
			//如果满直接退出
			this.a[++index]=data;
			this.size++;
		}
		public void addFirst(int data)
		{
			//如果满直接退出
			for(int j=index;j>=0;j--)
			{
				a[j+1]=a[j];
			}
			a[0]=data;
			this.index++;
			this.size++;
		}
		public void addBefore(int oldData,int newData)
		{
			int pos=this.find(oldData);
			if(pos!=-1)
			{
				for(int j=index;j>=pos;j--)
				{
					a[j+1]=a[j];
				}
				a[pos]=newData;
				this.index++;
				this.size++;
			}
			
		}
		public int find(int data)
		{
			for(int i=0;i<size;i++)
			{
				if(data==a[i])
				{
					return i;
				}
			}
			return -1;
		}
		public int removeLast()
		{
			//如果为空退出
			int temp=a[index];
			index--;
			size--;
			return temp;
		}
		public int removeFirst()
		{
			for(int i=0;i<index;i++)
			{
				a[i]=a[i+1];
			}
			this.index--;
			this.size--;
		}
		public int remove(int deleteData)
		{
			int pos=this.find(deleteData);
			if(pos>=0)
			{
				for(int i=pos;i<index;i++)
				{
					a[i]=a[i+1];
				}
			}
			size--;
			index--;
		}
		/*
			折半查找
			1、是在已排好序的数组中处理
			2、有三个变量
				lower:初始是0
				upper:初始是数据最大的下标
				mid=(lower+upper)/2;
			3、退出条件
				lower>upper
			4、逻辑处理
				if(a[mid]==findData)
				{
					return mid;
				}
				else if(a[mid]>findData)
				{
					upper=mid-1;
				}
				else
				{
					lower=mid+1;
				}
		*/
		public void halfFind()
		{
			int lower=0;
			int upper=index;
			while(lower<=upper)
			{
				int mid=(lower+upper)/2;
				if(a[mid]==findData)
				{
					return mid;
				}
				else if(a[mid>findData])
				{
					upper=mid-1;
				}
				else
				{
					lower=mid+1;
				}
			}
		}
		public boolean isEmpty()
		{
			return this.size==0;
		}
		public boolean isFull()
		{
			return this.size==this.maxSize;
		}
	}
二、队列线性表的实现
	1、先进先出，通过尾部进，通过头部出
	public class ListQuery
	{
		private int maxSize;
		private int size;
		private int a[];
		private int vear=-1;
		private int front=0;
		public ListQuery(int maxSize)
		{
			this.maxSize=maxSize;
			a=new int[maxSize];
			this.size=0;
		}
		public void add(int i)
		{
			if(this.isFull)
			{
				System.out.println("队已满");
				return;
			}
			this.a[++vear]=i;
			if(vear==maxSize-1)
			{
				vear=-1;
			}
			this.size++;
		}
		public int remove()
		{
			if(this.isEmpty)
			{
				System.out.println("队已空");
				return;
			}
			int temp=a[front++];
			if(front==maxSize)
			{
				front=0;
			}
		}
		public boolean isEmpty()
		{
			return size==0;
		}
		public boolean isFull()
		{
			return this.size==maxSize;
		}
	}
三、队列链表的实现
	public class Node
	{
		public int data;
		public Node next;
		public Node(int data)
		{
			this.data=data;
		}
	}
	public class LinkQuery
	{
		private Node front=null;
		private Node vear=null;
		public void add(int i)
		{
			Node newNode=new Node(i);
			if(front==null && vear=null)
			{
				front=newNode;
				vear=newNode;
			}
			else
			{
				vear.next=newNode;
				vear=newNode;
			}
		}
		public void remove()
		{
			if(front==null)
			{
				System.out.println("栈已空");
				return;
			}
			Node temp=front;
			front=front.next();
			if(front==null)
			{
				vear=null;
			}
		}
		public boolean isEmpty()
		{
			return front==null;
		}
	}
四、栈,先进后出,只有一个出口，操作在头部进行
五、线性表
	1、排序(从小到大)straightSelectSort
		1、选择法:第一个数与其余的所有数比较，将最小的数放到第一位，
			  第一位不再参与比较。
			  第二个数与其余的所有数比较，将次小的数放到第二位，
			  第二位不再参与比较。
			  for(int i=0;i<a.length()-1;i++)
			  {
			  	int k=i;
			  	for(int j=i+1;j<a.length();j++)
			  	{
			  		if(a[k]>a[j])
			  		{
			  			k=j;
			  		}
			  	}
			  	if(k!=i)
			  	{
			  		int temp=a[k];
			  		a[k]=a[i];
			  		a[i]=temp
			  	}
			  }
		2、冒泡法排序:bubbleSort
			相邻的两个数进行比较，将最大的数放到最后面，最后的这个数不再参与比较
			相邻的两个数进行比较，将次大的数放到次后面，次后的这个数不再参与比较
			for(int i=0;i<a.length-1;i++)
			{
				for(int j=0;j<a.length-i-1;j++)
				{
					if(a[j]>a[j+1])
					{
						swap(j,j+1);
					}
				}
			}
		3、插入法排序:insertSort
			假设第一数已排好序，如果第二数比第一数小，第一个数右移,第一位放第二个数。
			int b[]={1000,-100,-99999,10,20,1,100,200,18};
			
			for(int i=1;i<a.length;i++)
			{
				int temp=a[i];
				int sort=i;
				while(i>0 && temp<a[sort-1])
				{
					a[sort]=a[sort-1];
					sort--;
				}
				a[sort]=temp;
			}
一、栈：先进后出，进与出都在头部操作
	1、线性表的实现
		public class ListStack
		{
			private int maxSize;
			private int size;
			private int top;
			private int a[];
			public ListStack(int maxSize)
			{
				this.maxSize=maxSize;
				this.size=0;
				top=-1;
				a=new int[maxSize];			
			}
			public void add(int i)
			{
				if(this.isFull)
				{
					System.out.println("栈已满");
					return;
				}
				a[++top]=i;
				size++;
			}
			public int remove()
			{
				if(this.isEmpty())
				{
					System.out.println("栈已空");
					return -1;
				}
				temp=a[top--];
				size--;
				return temp;
			}
			public boolean isFull()
			{
				return this.size==this.maxSize;
			}
			public boolean isEmpty()
			{
				return this.size==0;
			}
		}
	2、链表的实现
		public class Node
		{
			public int data;
			public Node next;
			public Node(int data)
			{
				this.data=data;
			}
		}
		public class LinkStack
		{
			private Node top;
			public void push(int i)
			{
				Node newNode=new Node(i);
				if(top==null)
				{
					top=newNode;
				}
				else
				{
					newNode.next=top;
					top=newNode;
				}
			}
			public int pop()
			{
				if(top==null)
				{
					System.out.println("栈已空");
					return -1;
				}
				int temp=top.data;
				top=top.nextNode;
				retutn temp;
			}
			public boolean isEmpty()
			{
				return top==null;
			}
		}
二、线性表
	public class List
	{
		int size;//实际元素的个数
		int maxSize;//最大容量
		int a[];//承载数据
		int index;//当前最大的下标值
		public List(int maxSize)
		{
			this.maxSize=maxSize;
			a=new int[this.maxSize];
			index=-1;
			size=0;
		}
		public void addLast(int data)
		{
			if(this.isFull)
			{
				System.out.println("线性表已满");
				return;
			}
			this.a[++index]=data;
			this.size++;
		}
		public void print()
		{
			for(int i=0;i<size;i++)
			{
				System.out.println(a[i]);
			}
		}
		/*
			选择法排序:
				第一个数与剩余的所有数比较，将最小的数放到第一位，第一位不再参与参与比较
				第二个数与剩余的所有数比较，将次小的数放到第二位，第二位不再参与参与比较
		*/
		public void selectSort()
		{
			for(int i=0;i<this.size-1;i++)
			{
				int k=i;
				for(int j=i+1;j<this.size;j++)
				{
					if(a[k]>a[j])
					{
						k=j;
					}
				}
				if(k!=i)
				{
					int temp=a[k];
					a[k]=a[i];
					a[i]=temp;
				}
			}
		}
		/*
		冒泡法:
			相邻数比较，将最大数放到最后，最后的这个数不再参与比较
			相邻数比较，将次大数放到最后，次后的这个数不再参与比较
		*/
		public void maopaoSort()
		{
			for(int i=0;i<this.size-1;i++)
			{
				boolean flag=false;
				for(int j=0;j<this.size-i-1;j++)
				{
					if(a[j]>a[j+1])
					{
						int temp=a[j];
						a[j]=a[j+1];
						a[j+1]=temp;
						flag=true;
					}
				}
				if(flag==flase)
				{
					break;
				}
			}
			
		}
		/*
		插入法:假设第一数已排好序,
			插入第二数时，第一数与第二个数比较，若第二个数小于第一数,第一数右移,
				第一个位置放第二个数
		*/
		public void insertSort()
		{
			for(int i=1;i<this.size;i++)
			{
				int temp=a[i];
				int sort=i;
				while(sort>0 && a[sort-1]>temp)
				{
					a[sort]=a[sort-1];
					sort--;
				}
				a[sort]=temp;
			}
		}
		public boolean isEmpty()
		{
			return this.size==0;
		}
		public boolean isFull()
		{
			return this.size=this.maxSize;
		}
	}