/**
 * --------------------------------------------------
 * 字段输入流
 * --------------------------------------------------
 * 从DataInputStream继承
 * 主要增加了从文本格式输入流中读入数据字段的能力
 * --------------------------------------------------
 * 
 * @author iwinyeah 李永超
 * @version 1.0.0
 * */

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;

public class FieldInputStream extends DataInputStream {
	public final static int BIN_MODE = 0;

	public final static int TXT_MODE = 1;

	int mode;

	public FieldInputStream(InputStream in, int mode) {
		super(in);
		this.mode = mode;
	}

	public boolean getBoolean() throws IOException {
		if (mode == 0) {
			return readBoolean();
		} else {
			if ("1".equals(next())) {
				return true;
			}
			return false;
		}
	}

	public byte getByte() throws IOException {
		if (mode == 0) {
			return readByte();
		} else {
			return (byte) Integer.parseInt(next());
		}
	}

	public short getShort() throws IOException {
		if (mode == 0) {
			return readShort();
		} else {
			return (short) Integer.parseInt(next());
		}
	}

	public int getInt() throws IOException {
		if (mode == 0) {
			return readInt();
		} else {
			return Integer.parseInt(next());
		}
	}

	public long getLong() throws IOException {
		if (mode == 0) {
			return readLong();
		} else {
			return Long.parseLong(next());
		}
	}

	public String getString() throws IOException {
		if (mode == 0) {
			if (read() == 0) {
				return null;
			} else {
				return readUTF();
			}
		} else {
			return next();
		}
	}

	// 取下一标识符
	private byte[] buffer = new byte[255];

	private int length = 0;

	private boolean eos = false;

	private final static int INITIAL = 0;

	private final static int ESCAPE = 1;

	private final static int COMMENT_START = 2;

	private final static int LINE_COMMENT = 3;

	private final static String WHITESPACE = "\n\r\t";

	public String next() throws IOException {
		length = 0;
		int c = in.read();
		int status = INITIAL;
		READWHILE: while (c != -1) { // 一直读到文件尾

			switch (status) {
			case INITIAL:
				if (c == '\n' || c == '\t') { // 如果是分隔符
					break READWHILE;
				} else if (c == '\\') {
					status = ESCAPE; // 设转义字符标志
				} else if (c == '/') {
					status = COMMENT_START; // 设注释标志
				} else {
					if (WHITESPACE.indexOf(c) < 0) {
						append(c);
					}
				}
				break;

			case ESCAPE: // 处理转义字符
				switch (c) {
				case 'n':
					append('\n');
					break;

				case 'r':
					append('\r');
					break;

				case 't':
					append('\t');
					break;

				case 'b':
					append('\b');
					break;

				case 'f':
					append('\f');
					break;

				default:
					append(c);
					break;
				}
				status = INITIAL; // 设正常情况标志
				break;

			case COMMENT_START: // 处理注释
				if (c == '/') {
					status = LINE_COMMENT; // 是行式注释
				} else {
					status = INITIAL;
					// 如果都不是则把注释起始符和刚读入的字符都加入到标识符中
					append('/');
					append(c);
				}
				break;

			case LINE_COMMENT:
				if (c == '\n') {
					status = INITIAL; // 如果当前为行注释状态则要一直读到行尾才恢复正常情况标志
					break READWHILE;
				}
				break;
			}
			c = in.read(); // 读入下一字符
		}

		if (c == -1) {
			eos = true;
		}

		// 如果读到文件尾时，标识符长度大于零，则返回标识符，否则返回NULL值
		if (length <= 0) {
			return null;
		} else {
			return new String(buffer, 0, length, "UTF-8");
		}
	}

	// 将读入的字符加入缓冲区
	private void append(int c) {
		// 缓冲区不足时自动扩展
		if (length >= buffer.length) {
			byte[] xBuffer = new byte[buffer.length + 16];
			System.arraycopy(buffer, 0, xBuffer, 0, buffer.length);
			buffer = null;
			buffer = xBuffer;
		}

		buffer[length++] = (byte) c;
	}

	public boolean eos() {
		return eos;
	}
}

• 中科院软件、计算机工程硕士;中港软件硕士、管理类硕士博士招生
• WebSphere 产品家族新特性系列经典推荐

package util;
/**
 * --------------------------------------------------
 * 字段输出流
 * --------------------------------------------------
 * 从DataOutputStream继承
 * 主要增加了向输出流写入文本格式的数据字段的能力
 * 文本格式流将由TAB分隔字段，回车换行符分隔记录
 * --------------------------------------------------
 * 
 * @author iwinyeah 李永超
 * @version 1.0.0
 * */

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class FieldOutputStream extends DataOutputStream {
	public final static int BIN_MODE = 0;

	public final static int TXT_MODE = 1;

	private final static byte[] fieldSplit = {'\t'};

	private final static byte[] recordSplit = {'\r','\n'};

	private int mode;
	
	private boolean nextEnd = false;

	public FieldOutputStream(OutputStream out, int mode) {
		super(out);
		this.mode = mode;
	}

	// 接着写入的是否最后一个字段
	// 写第一个字段前以参数false调用它
	// 写最后一个字段前以参数false调用它
	public void setNextEnd(boolean end){
		nextEnd = end;
	}
	
	public void putBoolean(boolean value) throws IOException {
		if (mode == 0) {
			writeBoolean(value);
		} else {
			out.write(value ? '1' : '0');
			out.write(nextEnd ? recordSplit : fieldSplit);
		}
	}

	public void putByte(byte value) throws IOException {
		if (mode == 0) {
			writeByte(value);
		} else {
			out.write(String.valueOf(value).getBytes("UTF-8"));
			out.write(nextEnd ? recordSplit : fieldSplit);
		}
	}

	public void putShort(short value) throws IOException {
		if (mode == 0) {
			writeShort(value);
		} else {
			out.write(String.valueOf(value).getBytes("UTF-8"));
			out.write(nextEnd ? recordSplit : fieldSplit);
		}
	}

	public void putInt(int value) throws IOException {
		if (mode == 0) {
			writeInt(value);
		} else {
			out.write(String.valueOf(value).getBytes("UTF-8"));
			out.write(nextEnd ? recordSplit : fieldSplit);
		}
	}

	public void putLong(long value) throws IOException {
		if (mode == 0) {
			writeLong(value);
		} else {
			out.write(String.valueOf(value).getBytes("UTF-8"));
			out.write(nextEnd ? recordSplit : fieldSplit);
		}
	}

	public void putString(String value) throws IOException {
		if (mode == 0) {
			if (value == null) {
				writeByte(0);
			} else {
				writeByte(1);
				writeUTF(value);
			}
		} else {
			if(value != null){
				byte[] b = value.getBytes("UTF-8");
				for(int i = 0; i < b.length; i++){
					if(b[i] == '\n'){
						out.write('\\');
						out.write('n');
					}
					else if(b[i] == '\r'){
						out.write('\\');
						out.write('r');
					}
					else if(b[i] == '\t'){
						out.write('\\');
						out.write('t');}
					else if(b[i] == '\b'){
						out.write('\\');
						out.write('b');}
					else if(b[i] == '\f'){
						out.write('\\');
						out.write('f');
					}else{
						out.write(b[i]);
					}
				}				
			}
			out.write(nextEnd ? recordSplit : fieldSplit);
		}
	}

}

• 中科院软件、计算机工程硕士;中港软件硕士、管理类硕士博士招生
• WebSphere 产品家族新特性系列经典推荐

package util;

/**
 * --------------------------------------------------
 * 日期转换对象
 * --------------------------------------------------
 * 主要提供日期与1970-01-01后的天数的转换和到字符串的转换
 * --------------------------------------------------
 * 
 * @author iwinyeah 李永超
 * @version 1.0.0
 * */

import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

public class DateUtil {
	private static Calendar _calendar = Calendar.getInstance(); // 用于日期计算

	private static long MSEC_EVERYDAY = 86400000L; // 一天的微秒数

	private static int rawOffset = TimeZone.getDefault().getRawOffset();

	/**
	 * 将日期转换为1970-01-01后的天数
	 * 
	 * @param Date
	 *            theDate 要计算天数的日期
	 * @return int 所传入日期与1970-01-01相差的天数
	 */
	public static int dateToDay(Date theDate) {
		return (int) ((theDate.getTime() + rawOffset) / MSEC_EVERYDAY);
	}

	/**
	 * 将1970-01-01后的天数转换为日期
	 * 
	 * @param int
	 *            要取的日期与1970-01-01相差的天数
	 * @return Date theDate 与1970-01-01相差相应天数的日期
	 */
	public static Date dayToDate(int day) {
		return new Date(day * MSEC_EVERYDAY);
	}

	/**
	 * 取今天与1970-01-01相差的天数
	 * 
	 * @return int 取今天与1970-01-01相差的天数
	 */
	public static int toDay() {
		return (int) ((System.currentTimeMillis() + rawOffset) / MSEC_EVERYDAY);
	}

	/**
	 * 将日期转换为年月日字符串
	 * 
	 * @param int
	 *            theDay 与1970-01-01相差的天数
	 * @return String 对应日期年月日形式的字符串
	 */
	public static String getYMD(int theDay) {
		_calendar.setTime(dayToDate(theDay));
		return _calendar.get(Calendar.YEAR) % 100 + "/"
				+ (_calendar.get(Calendar.MONTH) + 1 > 9 ? "" : "0")
				+ (_calendar.get(Calendar.MONTH) + 1) + "/"
				+ (_calendar.get(Calendar.DATE) > 9 ? "" : "0")
				+ _calendar.get(Calendar.DATE);
	}

	/**
	 * 将日期转换为年月字符串
	 * 
	 * @param int
	 *            theDay 与1970-01-01相差的天数
	 * @return String 对应日期年月形式的字符串
	 */
	public static String getYM(int theDay) {
		_calendar.setTime(dayToDate(theDay));
		return _calendar.get(Calendar.YEAR) + "/"
				+ (_calendar.get(Calendar.MONTH) + 1 > 9 ? "" : "0")
				+ (_calendar.get(Calendar.MONTH) + 1);
	}

	/**
	 * 将日期转换为月日字符串
	 * 
	 * @param int
	 *            theDay 与1970-01-01相差的天数
	 * @return String 对应日期月日形式的字符串
	 */
	public static String getMD(int theDay) {
		_calendar.setTime(dayToDate(theDay));
		return (_calendar.get(Calendar.MONTH) + 1 > 9 ? "" : "0")
				+ (_calendar.get(Calendar.MONTH) + 1) + "/"
				+ (_calendar.get(Calendar.DATE) > 9 ? "" : "0")
				+ _calendar.get(Calendar.DATE);
	}

	/**
	 * 将日期转换为当月一号
	 * 
	 * @param int
	 *            theDay 与1970-01-01相差的天数
	 * @return int 对应日期所在月份第一天与1970-01-01相差的天数
	 */
	public static int getMonthFirstDay(int theDay) {
		_calendar.setTime(dayToDate(theDay));
		_calendar.set(Calendar.DAY_OF_MONTH, 1);
		return (int) (dateToDay(_calendar.getTime()));
	}

	/**
	 * 取日期所在年份
	 * 
	 * @param int
	 *            theDay 与1970-01-01相差的天数
	 * @return int 对应日期所在年份
	 */
	public static int getYear(int theDay) {
		_calendar.setTime(dayToDate(theDay));
		return _calendar.get(Calendar.YEAR);
	}

	/**
	 * 取日期所在月份
	 * 
	 * @param int
	 *            theDay 与1970-01-01相差的天数
	 * @return int 对应日期所在月份
	 */
	public static int getMonth(int theDay) {
		_calendar.setTime(dayToDate(theDay));
		return _calendar.get(Calendar.MONTH);
	}

	/**
	 * 取日期所在周次
	 * 
	 * @param int
	 *            theDay 与1970-01-01相差的天数
	 * @return int 对应日期所在周次
	 */
	public static int getWeek(int theDay) {
		// 1971-01-03是星期日,从该日开始计算周次
		_calendar.setTime(dayToDate(theDay));
		return (int) ((_calendar.getTime().getTime() - 172800000L) / 604800000L);
	}

}

• 中科院软件、计算机工程硕士;中港软件硕士、管理类硕士博士招生
• WebSphere 产品家族新特性系列经典推荐

// 方法一
public class firstManager implements Runnable {
  public void runTask() {
   (new Thread(this)).start();
  }
  public void run() {
   System.out.println("\nfirst thread method!");
   // Do some thing ...
  }
}
// 方法二
public class secondManager {
  private BackTask backTask;
  private Timer timer;
  public secondManager() {
   backTask = new BackTask();
   timer = new Timer();
  }
  public void runTask() {
   timer.schedule(backTask, 0);
  }
  private class BackTask extends TimerTask {
   public void run() {
    System.out.println("\nsecond thread method!");
    // Do some thing ...
   }
  }
}
// 方法三
public class thirdManager {
  private BackTask backTask;
  private int cmd = 0;
  public thirdManager() {
   backTask = new BackTask();
   backTask.start();
  }
  public void runTask() {
   synchronized (backTask) {
    cmd = 1;
    backTask.notify();
   }
  }
  private class BackTask extends Thread {
   public void run() {
    while (true) {
     try {
      if (cmd == 0) {
       synchronized (this) {
        wait();
       }
       continue;
      }
      System.out.println("\nthird thread method!");
      // Do some thing ...
     } catch (Exception e) {
     }
     cmd = 0;
    }
   }
  }
}

// 用例
public void main(){
  firstManager man1 = new firstManager();
  secondManager man2 = new secondManager();
  thirdManager man3 = new thirdManager();
  man1.runTask();
  man2.runTask();
  man3.runTask();
}

• 中科院软件、计算机工程硕士;中港软件硕士、管理类硕士博士招生
• WebSphere 产品家族新特性系列经典推荐