/*
* 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 824编程中往往不仅需要处理本地的图片资源,还要处理网络中获取 ... -
J2ME Effects Library
2009-09-28 15:42 972J2ME ARMY KNIFE is, as far as I ... -
j2me中的MIDlet类说明
2009-09-28 13:14 1454在J2ME编程过程中,MIDlet ... -
J2ME入门体会
2009-09-28 13:13 794学习J2ME已经有几天的时间了,今天我以一个初学者的角度来谈谈 ... -
j2me进度条Gauge模板
2009-09-28 13:11 1431这是很好的进度条的模板,里面涉及丰富的Java知识,值得很好研 ... -
使用调色板修改png图片
2009-09-28 13:07 1478这个算法是参考一位高人的文章,直接读取并修改png格式图片的调 ... -
SimpleCache
2009-09-28 12:39 790public class SimpleCache { ... -
StringTokenizer
2009-09-28 12:36 846public class StringTokenizer { ... -
编码技巧
2009-09-22 11:56 7291. 用StringBuffer ... -
混淆器
2009-09-22 10:49 990ProGuard - ... -
j2me游戏中使用记录管理系统
2009-09-22 10:32 571纪录管理系统(Record Ma ...
相关推荐
老外写的焊接机器人程序.zip西门子PLC编程实例程序源码下载老外写的焊接机器人程序.zip西门子PLC编程实例程序源码下载老外写的焊接机器人程序.zip西门子PLC编程实例程序源码下载老外写的焊接机器人程序.zip西门子PLC...
老外写的ADO封装类,超全面,使用简单。经过长期测试,使用中相当稳定。
【标题】"一个老外写的HtmlEditor"是一个国外开发者创建的HTML编辑器,它提供了丰富的功能,便于用户创建和编辑HTML文档。这个编辑器可能是开源的或者免费供个人使用,旨在简化网页设计过程,提高开发效率。 【描述...
此外,“O(nlogn)”在英文中应写为“O(n log n)”,以符合国际标准格式。 5. **过度使用被动语态**: - **例子**:“It was observed that the method performs well under certain conditions.” - **改进后**:...
老外写的翻页效果 leaves老外写的翻页效果 leaves
这个"老外写的一个flash时间类"旨在提供一个更精确的时间控制工具,以改善标准的ActionScript 3(AS3)Timer类可能存在的精度问题。下面我们将深入探讨这个时间类的相关知识点。 1. **ActionScript 3 Timer类**: ...
老外写的程序软件,老外写的程序软件,老外写的程序软件老外写的程序软件
老外写的文件粉碎源码
标题 "ifix5.0老外写的例子" 指向的是一个使用IFix 5.0版本开发的应用程序示例,特别关注于水处理领域的工业自动化控制。IFix(Industrial Interactive Fix)是GE Digital推出的一款先进的组态软件,用于构建、监控...
【标题】:“老外写的ListView” 在Android开发中,ListView是一个非常重要的视图组件,它允许开发者在屏幕上显示大量的数据,通常以列表的形式呈现。这个标题提到的是一个由非中国开发者(老外)编写的ListView...
老外写的分割算法好 还不错 有需要的下来看看
西门子PLC例程源码老外写的焊接机器人程序本资源系百度网盘分享地址
老外写的ST语言教程_很详细
老外写的PHP的SMTP邮件类 外带Debug模式,很好很强大
【标题】"老外写的图表类"是一款专用于生成各种数据可视化图表的库,它能够帮助程序员轻松地创建出美观的饼图、柱状图等多种图表类型。这个库的亮点在于其精美的设计和易用性,使得数据分析结果能够以直观、吸引人的...
老外写的ST语言教程-很详细 PPT
老外写的很强悍的IC卡测试小工具 支持EDEP ,ECC ,SIM ...
《老外写的嵌入式测试书》是一本深入探讨嵌入式系统测试的专业书籍,它由国外资深专家撰写,以其全面性和深度深受测试人员推崇。这本书不仅覆盖了基础的测试理论,还深入到了嵌入式系统的独特测试挑战,旨在帮助读者...
标题中的“老外写的3DES不错”表明这是一个关于3DES加密算法的外国作者编写的代码或教程。3DES,即三重数据加密标准(Triple DES),是基于原始数据加密标准(DES)的一种加强版本,旨在提供更强的安全性。在描述中...
标题中的“ado,dao,odbc数据库操作类的vc代码”揭示了这些代码库主要涉及在Visual C++(VC)环境中使用不同的数据库访问技术,包括ActiveX Data Objects (ADO), Data Access Objects (DAO),以及Open Database ...