sharefunc.java

B/S结构邮件系统的源码

package Shared;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Vector;

public class ShareFunc extends Thread
{
	public static Vector StrToDateStr(String pStartDate, String pEndDate)
	{
		String strToday ="";
		String strTomorrow = "";
		Vector data =  new Vector();
		if(pStartDate == null || pStartDate.equals(""))
		{
			SimpleDateFormat SimFormat = new SimpleDateFormat("yyyy-MM-dd"); 
	    	Date Today = new Date();
	        Date Tomorrow = new Date();
	        long myTime = (Today.getTime()/1000)+60*60*24;
	        Tomorrow.setTime(myTime*1000);
	        strToday = SimFormat.format(Today);
	        strTomorrow = SimFormat.format(Tomorrow);
		}
		else
		{
			strToday = pStartDate;
			strTomorrow = pEndDate;
		}
		data.insertElementAt(strToday,0);
		data.insertElementAt(strTomorrow,1);		
		return data;
	}
	
	//字符串转换成GB2312编码
	public static String StrToGB2312(String str)
	{
		if (str == null)
			str ="";
		try{
			str = new String(str.getBytes("ISO-8859-1"),"GB2312");
		}
		catch(Exception ex){
			return "";
		}
		return str;
	}	
	//字符串转成整型
	public static int StrToInt(String pStr)
	{
		int Rslt = 0;
		int IStr = 0;
		if(pStr != null && !pStr.equals(""))
		{
			IStr = Integer.parseInt(pStr);
			Rslt = IStr;
		}
		return Rslt;
	}
//将整型数据转换成高低字节转换的四字节
	public static int TurnDWord(int i)
	{
		int j = 0;
		 j |=(i<<24)&0xFF000000;
		 j |=(i<<8)&0x00FF0000;
		 j |=(i>>8)&0x0000FF00;
		 j |=(i>>24)&0x000000FF;
		 return j;
	}
	//将长整型数转换成高低字节转换的八字节
	public static long TurnLong(long i)
	{
		long j=0;
		j |=(i<<56)&0xFF00000000000000L;
		j |=(j<<40)&0x00FF000000000000L;
		j |=(j<<24)&0x0000FF0000000000L;
		j |=(j<<8) &0x000000FF00000000L;
		j |=(j>>8) &0x00000000FF000000L;
		j |=(j>>24)&0x0000000000FF0000L;
		j |=(j>>40)&0x000000000000FF00L;
		j |=(j>>56)&0x00000000000000FFL;
		return j;
	}
	//将整型数据转换成四字节流
	public static int IntToBytes(byte[] Dst, int index, int Src)
	{
		try
		{
			ByteArrayOutputStream boutStream = new ByteArrayOutputStream();
			DataOutputStream doutStream = new DataOutputStream(boutStream);
			doutStream.writeInt(ShareFunc.TurnDWord(Src));
	
			byte byteMsg[] = boutStream.toByteArray();
			for (int i = 0; i< 4; i++)
			{
				Dst[index++] = byteMsg[i];
			}
			doutStream.close();
			boutStream.close();
		}
		catch(Exception ex)
		{			
			ex.printStackTrace();
		}
		return 4;
	}
	//将字符串转换成字节流
	public static int StrToBytes(byte[] Dst, int index, String Src)
	{
		char[] Temp = Src.toCharArray();
		try
		{
			for(int i = 0; i<Temp.length; i++)
			{
				Dst[index + i] = (byte)Temp[i];
			}
		}
		catch(Exception ex)
		{			
			ex.printStackTrace();
		}
		return Temp.length;
	}
	//将字节数组转换成字符串
	public static String ByteArrayToStr(byte[] src,int start,int len)
	{
		byte[] tempdst = new byte[255];
		byte temp = 0;
		int ch1 = 0;
		int ch2 = 0;
		int i = 0;
		for(i=0; i< (len);i++)
		{
			temp = src[start + i];
			ch1 = (temp & 0x00000000000000F0)>>4;
			ch2 = (temp & 0x000000000000000F);
			if(ch1 >=0 && ch1 <=9)
				ch1 = ch1 + 0x30;
			else
				ch1 =  ch1 + 0x41 -10;
			
			if(ch2 >=0 && ch2 <=9)
				ch2 =  ch2 + 0x30;
			else
				ch2 =  ch2 + 0x41 -10;
			tempdst[i*2] = (byte)ch1;
			tempdst[i*2 + 1] = (byte)ch2;
		}
		return (new String(tempdst, 0, len*2)).trim();
	}
	//将字符串转换成字节数组
	public static byte[] StrToByteArray(String src,int start,int len)
	{
		byte [] Buff = new byte[(len)/2];
		int ch = 0;
		int ch1 = 0;
		int ch2 = 0;
		for(int i=0; i< (len/2);i++)
		{
			ch = (int)(src.charAt(start + i*2));
			if(ch>= 0x30 && ch <= 0x39)
				ch = ch - 0x30;
			else
				ch = ch - 0x41 + 10;
			ch = (ch << 4) & 0x0000000f0;
			ch1 = (int)(src.charAt(start + i*2+1));
			if(ch1>= 0x30 && ch1 <= 0x39)
				ch1 = ch1 - 0x30;
			else
				ch1 = ch1 - 0x41 + 10 ;
			ch1 = ch1&0x00000000f;

			Buff[i] =(byte) (((int)((ch | ch1)&0x0000000ff)));
		}
		return Buff;
	}
	//将字节数组清零
	public static void ByteArrayClean(byte []bs)
	{
		for(int i=0; i<bs.length; i++)
			bs[i] = 0;
		return;
	}
	//字节数组拷贝
	public static boolean ByteCopy(byte []dst, byte []src, int dstpos, int srcpos, int len)
	{
		for(int i=0; i<len; i++)
			dst[dstpos + i] = src[srcpos + i];
		return true;
	}
	//字节数组比较
	public static boolean ByteCmp(byte []dst, byte []src, int dstpos, int srcpos, int len)
	{
		for(int i=0; i<len; i++)
			if(dst[dstpos + i] != src[srcpos + i])
				return false;
		return true;
	}
	//UCS编码转换成字符串convertUcs2Bytes
	public static String Ucs2ToStr(byte []bs)
	{
		int new_len = bs.length + 2;
		if ((new_len % 2) == 1)
			new_len--;
		if (new_len <= 2)
			return "";

		byte []new_bs = new byte[new_len];
		new_bs[0] = (byte)0xff;
		new_bs[1] = (byte)0xfe;
		for (int i = 2; i < new_len; i += 2)
		{
			new_bs[i] = bs[i-1];
			new_bs[i+1] = bs[i-2];
		}
		String r = "";
		try
		{
			r = new String(new_bs, "Unicode");
		} 
		catch(Exception e)
		{
		}
		return r;
	}
	//将字节数组以十六进制方式输出
	public static void printMsg(byte[] ba, int loopcount)
	{
		int temp;
		printer.println();
		for(int i=0; i<loopcount; i++)
		{
			temp=(int)ba[i];
			temp&=0x000000ff;
			if(temp<0x10)
				printer.print("0");
			printer.print(Integer.toHexString(temp));
			if((i+1)%LineByteCnt == 0)
			{
				printer.println();
				continue;
			}
			else if(((i+1) % WordCnt) == 0)
			{
				printer.print("  ");
			} 
//			for(int j=0; j<BlankBtByte; j++)
				printer.print(" ");
		}
		printer.println();
		printer.println();
		printer.flush();
	}
	
	public void finalize(){printer.close();}
	
	private static PrintWriter printer=new PrintWriter(new OutputStreamWriter(System.out));
	private static int LineByteCnt = 20;
	private static int WordCnt = 4;
//	private static int BlankBtByte = 1;
//	private static int BlankBtWord = 2;

	public static void setPrinter(String filepath)throws IOException{
		Writer w=new FileWriter(filepath,true);
		printer=new PrintWriter(w);
	}
	//将时间整型数据转换成字节数组
	public static byte[] TimeToBytes(int time)
	{
		byte c1 = (byte)((time)&0x000000FF);
		byte c2 = (byte)((time>>8)&0x000000FF);
		byte c3 = (byte)((time>>16)&0x000000FF);
		byte c4 = (byte)((time>>24)&0x000000FF);
		byte c[] = new byte[4];
		c[0]=c4;
		c[1]=c3;
		c[2]=c2;
		c[3]=c1;
		return c;
	}
	//CRC校验
	public static byte CalCRC(byte[] msg, int len)
	{
		int CRC = 0;
		for(int k = 0; k < len; k++)
		{
			if((int)msg[k] >= 0)
			{
				CRC = CRC + (int)msg[k];
			}
			else
			{
				CRC = CRC + (256 +(int)msg[k]);
			}
			if(CRC > 255)
				CRC -= 255;
		}
		return (byte)(0xFF - CRC);
	}
	//文件拷贝
	public static void FileCpy(String src,String dst)
	{
		try
		{
			FileInputStream fis  = new FileInputStream(src);
			FileOutputStream fos = new FileOutputStream(dst);
			byte[] buf = new byte[1024];
			int i = 0;
			while((i = fis.read(buf)) != -1) 
			{
				fos.write(buf, 0, i);
			}
			fis.close();
			fos.close();
					}
					catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
}