/*
* StringTool.java
*
* Created on 2006年5月8日, 下午7:16
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/
import java.util.Calendar;
import java.util.Enumeration;
import java.util.NoSuchElementException;
/**
* The string tokenizer class allows an application to break a
* string into tokens. The tokenization method is much simpler than
* the one used by the <code>StreamTokenizer</code> class. The
* <code>StringTool</code> methods do not distinguish among
* identifiers, numbers, and quoted strings, nor do they recognize
* and skip comments.
* <player>
* The set of delimiters (the characters that separate tokens) may
* be specified either at creation time or on a per-token basis.
* <player>
* An instance of <code>StringTool</code> behaves in one of two
* ways, depending on whether it was created with the
* <code>returnDelims</code> flag having the value <code>true</code>
* or <code>false</code>:
* <ul>
* <li>If the flag is <code>false</code>, delimiter characters serve to
* separate tokens. A token is a maximal sequence of consecutive
* characters that are not delimiters.
* <li>If the flag is <code>true</code>, delimiter characters are themselves
* considered to be tokens. A token is thus either one delimiter
* character, or a maximal sequence of consecutive characters that are
* not delimiters.
* </ul><player>
* A <tt>StringTool</tt> object internally maintains a current
* position within the string to be tokenized. Some operations advance this
* current position past the characters processed.<player>
* A token is returned by taking a substring of the string that was used to
* create the <tt>StringTool</tt> object.
* <player>
* The following is one example of the use of the tokenizer. The code:
* <blockquote><pre>
* StringTool st = new StringTool("this is a test");
* while (st.hasMoreTokens()) {
* System.out.println(st.nextToken());
* }
* </pre></blockquote>
* <player>
* prints the following output:
* <blockquote><pre>
* this
* is
* a
* test
* </pre></blockquote>
*
* <player>
* <tt>StringTool</tt> is a legacy class that is retained for
* compatibility reasons although its use is discouraged in new code. It is
* recommended that anyone seeking this functionality use the <tt>split</tt>
* method of <tt>String</tt> or the java.util.regex package instead.
* <player>
* The following example illustrates how the <tt>String.split</tt>
* method can be used to break up a string into its basic tokens:
* <blockquote><pre>
* String[] result = "this is a test".split("\\s");
* for (int x=0; x<result.length; x++)
* System.out.println(result[x]);
* </pre></blockquote>
* <player>
* prints the following output:
* <blockquote><pre>
* this
* is
* a
* test
* </pre></blockquote>
*
* @author unascribed
* @version 1.29, 01/23/03
* @see java.io.StreamTokenizer
* @since JDK1.0
*/
public class StringTool implements Enumeration {
private int currentPosition;
private int newPosition;
private int maxPosition;
private String str;
private String delimiters;
private boolean retDelims;
private boolean delimsChanged;
public static final String[] ms = new String[]{"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dev"};
/**
* maxDelimChar stores the value of the delimiter character with the
* highest value. It is used to optimize the detection of delimiter
* characters.
*/
private char maxDelimChar;
/**
* Set maxDelimChar to the highest char in the delimiter set.
*/
private void setMaxDelimChar() {
if (delimiters == null) {
maxDelimChar = 0;
return;
}
char m = 0;
for (int i = 0; i < delimiters.length(); i++) {
char c = delimiters.charAt(i);
if (m < c)
m = c;
}
maxDelimChar = m;
}
/**
* Constructs a string tokenizer for the specified string. All
* characters in the <code>delim</code> argument are the delimiters
* for separating tokens.
* <player>
* If the <code>returnDelims</code> flag is <code>true</code>, then
* the delimiter characters are also returned as tokens. Each
* delimiter is returned as a string of length one. If the flag is
* <code>false</code>, the delimiter characters are skipped and only
* serve as separators between tokens.
* <player>
* Note that if <tt>delim</tt> is <tt>null</tt>, this constructor does
* not throw an exception. However, trying to invoke other methods on the
* resulting <tt>StringTool</tt> may result in a
* <tt>NullPointerException</tt>.
*
* @param str a string to be parsed.
* @param delim the delimiters.
* @param returnDelims flag indicating whether to return the delimiters
* as tokens.
*/
public StringTool(String str, String delim, boolean returnDelims) {
currentPosition = 0;
newPosition = -1;
delimsChanged = false;
this.str = str;
maxPosition = str.length();
delimiters = delim;
retDelims = returnDelims;
setMaxDelimChar();
}
/**
* Constructs a string tokenizer for the specified string. The
* characters in the <code>delim</code> argument are the delimiters
* for separating tokens. Delimiter characters themselves will not
* be treated as tokens.
*
* @param str a string to be parsed.
* @param delim the delimiters.
*/
public StringTool(String str, String delim) {
this(str, delim, false);
}
/**
* Constructs a string tokenizer for the specified string. The
* tokenizer uses the default delimiter set, which is
* <code>" \t\n\r\f"</code>: the space character,
* the tab character, the newline character, the carriage-return character,
* and the form-feed character. Delimiter characters themselves will
* not be treated as tokens.
*
* @param str a string to be parsed.
*/
public StringTool(String str) {
this(str, " \t\n\r\f", false);
}
/**
* Skips delimiters starting from the specified position. If retDelims
* is false, returns the index of the first non-delimiter character at or
* after startPos. If retDelims is true, startPos is returned.
*/
private int skipDelimiters(int startPos) {
if (delimiters == null)
throw new NullPointerException();
int position = startPos;
while (!retDelims && position < maxPosition) {
char c = str.charAt(position);
if ((c > maxDelimChar) || (delimiters.indexOf(c) < 0))
break;
position++;
}
return position;
}
/**
* Skips ahead from startPos and returns the index of the next delimiter
* character encountered, or maxPosition if no such delimiter is found.
*/
private int scanToken(int startPos) {
int position = startPos;
while (position < maxPosition) {
char c = str.charAt(position);
if ((c <= maxDelimChar) && (delimiters.indexOf(c) >= 0))
break;
position++;
}
if (retDelims && (startPos == position)) {
char c = str.charAt(position);
if ((c <= maxDelimChar) && (delimiters.indexOf(c) >= 0))
position++;
}
return position;
}
/**
* Tests if there are more tokens available from this tokenizer's string.
* If this method returns <tt>true</tt>, then a subsequent call to
* <tt>nextToken</tt> with no argument will successfully return a token.
*
* @return <code>true</code> if and only if there is at least one token
* in the string after the current position; <code>false</code>
* otherwise.
*/
public boolean hasMoreTokens() {
/*
* Temporary store this position and use it in the following
* nextToken() method only if the delimiters have'nt been changed in
* that nextToken() invocation.
*/
newPosition = skipDelimiters(currentPosition);
return (newPosition < maxPosition);
}
/**
* Returns the next token from this string tokenizer.
*
* @return the next token from this string tokenizer.
* @exception NoSuchElementException if there are no more tokens in this
* tokenizer's string.
*/
public String nextToken() {
/*
* If next position already computed in hasMoreElements() and
* delimiters have changed between the computation and this invocation,
* then use the computed value.
*/
currentPosition = (newPosition >= 0 && !delimsChanged) ?
newPosition : skipDelimiters(currentPosition);
/* Reset these anyway */
delimsChanged = false;
newPosition = -1;
if (currentPosition >= maxPosition)
throw new NoSuchElementException();
int start = currentPosition;
currentPosition = scanToken(currentPosition);
return str.substring(start, currentPosition);
}
/**
* Returns the next token in this string tokenizer's string. First,
* the set of characters considered to be delimiters by this
* <tt>StringTool</tt> object is changed to be the characters in
* the string <tt>delim</tt>. Then the next token in the string
* after the current position is returned. The current position is
* advanced beyond the recognized token. The new delimiter set
* remains the default after this call.
*
* @param delim the new delimiters.
* @return the next token, after switching to the new delimiter set.
* @exception NoSuchElementException if there are no more tokens in this
* tokenizer's string.
*/
public String nextToken(String delim) {
delimiters = delim;
/* delimiter string specified, so set the appropriate flag. */
delimsChanged = true;
setMaxDelimChar();
return nextToken();
}
/**
* Returns the same value as the <code>hasMoreTokens</code>
* method. It exists so that this class can implement the
* <code>Enumeration</code> interface.
*
* @return <code>true</code> if there are more tokens;
* <code>false</code> otherwise.
* @see java.util.Enumeration
* @see java.util.StringTool#hasMoreTokens()
*/
public boolean hasMoreElements() {
return hasMoreTokens();
}
/**
* Returns the same value as the <code>nextToken</code> method,
* except that its declared return value is <code>Object</code> rather than
* <code>String</code>. It exists so that this class can implement the
* <code>Enumeration</code> interface.
*
* @return the next token in the string.
* @exception NoSuchElementException if there are no more tokens in this
* tokenizer's string.
* @see java.util.Enumeration
* @see java.util.StringTool#nextToken()
*/
public Object nextElement() {
return nextToken();
}
/**
* Calculates the number of times that this tokenizer's
* <code>nextToken</code> method can be called before it generates an
* exception. The current position is not advanced.
*
* @return the number of tokens remaining in the string using the current
* delimiter set.
* @see java.util.StringTool#nextToken()
*/
public int countTokens() {
int count = 0;
int currpos = currentPosition;
while (currpos < maxPosition) {
currpos = skipDelimiters(currpos);
if (currpos >= maxPosition)
break;
currpos = scanToken(currpos);
count++;
}
return count;
}
public static long getData(String s){
Calendar calendar = Calendar.getInstance();
StringTool su = new StringTool(s," ");
su.nextToken();
String date = su.nextToken();
String time = su.nextToken();
StringTool sd = new StringTool(date,"-");
int i = 0;
while(sd.hasMoreTokens()){
String temp = sd.nextToken();
if(i == 0)
//day
calendar.set(Calendar.DAY_OF_MONTH,Integer.parseInt(temp));
else if( i == 1){
// month
int j;
for(j = 0;j<ms.length;j++){
if(temp.equals(ms[j])){
calendar.set(Calendar.MONTH,j);
break;
}
}
}else{
calendar.set(Calendar.YEAR,Integer.parseInt(temp));
}
i++;
}
i=0;
StringTool st = new StringTool(time,":");
while(st.hasMoreTokens()){
String temp = st.nextToken();
if(i == 0)
//hour
calendar.set(Calendar.HOUR_OF_DAY,Integer.parseInt(temp));
else if( i == 1){
//minute
calendar.set(Calendar.MINUTE,Integer.parseInt(temp));
}else{
//second
calendar.set(Calendar.SECOND,Integer.parseInt(temp));
}
i++;
}
return calendar.getTime().getTime();
}
}
发表评论
-
网络图片资源处理
2009-09-29 13:22 802编程中往往不仅需要处理本地的图片资源,还要处理网络中获取 ... -
J2ME Effects Library
2009-09-28 15:42 945J2ME ARMY KNIFE is, as far as I ... -
j2me中的MIDlet类说明
2009-09-28 13:14 1427在J2ME编程过程中,MIDlet ... -
J2ME入门体会
2009-09-28 13:13 775学习J2ME已经有几天的时间了,今天我以一个初学者的角度来谈谈 ... -
j2me进度条Gauge模板
2009-09-28 13:11 1393这是很好的进度条的模板,里面涉及丰富的Java知识,值得很好研 ... -
使用调色板修改png图片
2009-09-28 13:07 1442这个算法是参考一位高人的文章,直接读取并修改png格式图片的调 ... -
SimpleCache
2009-09-28 12:39 750public class SimpleCache { ... -
StringTokenizer
2009-09-28 12:36 824public class StringTokenizer { ... -
编码技巧
2009-09-22 11:56 6951. 用StringBuffer ... -
混淆器
2009-09-22 10:49 939ProGuard - ... -
j2me游戏中使用记录管理系统
2009-09-22 10:32 550纪录管理系统(Record Ma ...
相关推荐
一个老外写的HtmlEditor,很不错!!
老外写的一个flash时间类,还比较准确了哟。。。
老外写的焊接机器人程序.zip西门子PLC编程实例程序源码下载老外写的焊接机器人程序.zip西门子PLC编程实例程序源码下载老外写的焊接机器人程序.zip西门子PLC编程实例程序源码下载老外写的焊接机器人程序.zip西门子PLC...
老外写的ADO封装类,超全面,使用简单。经过长期测试,使用中相当稳定。
中国工程师写英文时最常犯的错误 The Most Common Habits from more than 200 English Papers written by Graduate Chinese Engineering Students 17页
老外写的翻页效果 leaves老外写的翻页效果 leaves
老外写的程序软件,老外写的程序软件,老外写的程序软件老外写的程序软件
老外写的3DES不错老外写的3DES不错老外写的3DES不错
几个老外写的ado,dao,odbc数据库操作类的vc代码
老外写的42个QT例子老外写的42个QT例子
老外写的类似Msn酷控件原码. 老外写的类似Msn酷控件原码
老外写的图表类,可以生成饼图、柱图等图表,非常漂亮。
老外写的文件粉碎源码
老外写的一个ListView控件,感觉很不错,用的时候请找Ntest的DLL
超清晰android界面开发电子书(老外写的) 入门级别的,如果想学习andr开发的同学可以参考写写不错语言简单
老外写的,值得参考android 学习参考
老外写的Socket hook代码,有了这个你可以写出自己的socket调试工具。
老外写的一个p2p程序,有点复杂.vc6开发的
俄罗斯方块 老外写的俄罗斯方块 开发的功能比较全面,代码思路清晰,只分了个三个类.很有用
老外写的测试书,非常全面、详细,是测试人员应该读的