Question

我正在试图弄清楚如何解析一个长字符串，并根据一些索引和长度，将该值转换为特定数据类型的速度最快，因为我需要处理大约1000个字符串/秒。要清楚，我需要这样的东西

String initial = "4239898 mdj 8746bbbrts675420120214";

Someclass parser = new Someclass(initial);

Date date = parser.getDate(26,8);

因此使用位置26到26 + 8

的子字符串解析日期

所以基本上，我想知道是否已经有一个类可以帮助我完成这个，或者如果有人可以建议一些快速算法。

提前致谢

Answer 1

我刚刚为我的目的找到了一个非常酷的“框架”。它被称为fixedformat4j，它完全符合我的要求，并且具有非常快的性能，即使它有点旧。

以下是其网站（http://fixedformat4j.ancientprogramming.com/）上的基本示例：

@Record  
public class BasicRecord {  

  private String stringData;  
  private Integer integerData;  
  private Date dateData;  


  @Field(offset = 1, length = 10)  
  public String getStringData() {  
    return stringData;  
  }  

  public void setStringData(String stringData) {  
    this.stringData = stringData;  
  }  

  @Field(offset = 11, length = 5, align = Align.RIGHT, paddingChar = '0')  
  public Integer getIntegerData() {  
    return integerData;  
  }  

  public void setIntegerData(Integer integerData) {  
    this.integerData = integerData;  
  }  

  @Field(offset = 16, length = 10)  
  @FixedFormatPattern("yyyy-MM-dd")  
  public Date getDateData() {  
    return dateData;  
  }  

  public void setDateData(Date dateData) {  
    this.dateData = dateData;  
  }  
}

现在可以使用FixedFormatManager

加载和导出这个带注释的类

public class BasicUsage {  

  private static FixedFormatManager manager = new FixedFormatManagerImpl();  

  public static void main(String[] args) {  
    String string = "string    001232008-05-29";  
    BasicRecord record = manager.load(BasicRecord.class, string);  

    System.out.println("The parsed string: " + record.getStringData());  
    System.out.println("The parsed integer: " + record.getIntegerData());  
    System.out.println("The parsed date: " + record.getDateData());  

    record.setIntegerData(100);  
    System.out.println("Exported: " + manager.export(record));  
  }  
}

Answer 2

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;

public class SomeClass {
    public static void main(String []args)  {
        String initial = "4239898 mdj 8746bbbrts675420120214";

        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
        Date parsed = new Date();

        try {
            parsed = format.parse(initial.substring(26,34));
        }
        catch(ParseException pe) {
            pe.printStackTrace();
        }

        System.out.println(parsed);
    }
}

Answer 3

我所知道的并不是什么。我不知道怎么做比以下更快：

public Date getDate(int start)
{
    int year = Integer.parseInt( initial.substring(start, start + 4) );
    int month = Integer.parseInt( initial.substring(start + 4, start + 6) );
    int day = Integer.parseInt( initial.substring(start + 6, start + 8) );
    return new Date(year, month, day);
}

如果您的所有日期都采用YYYYMMDD格式，则可能比使用SimpleDateFormat类更快。（注意，在这种情况下你不需要传递长度（8））。

Answer 4

来自this字符串文章的有趣解释

StringBuilder类是在JDK 1.5中引入的。它是一样的   StringBuffer类，但StringBuilder未同步   多线程操作。但是，对于单线程程序，   没有同步开销的StringBuilder更多   高效。

经验法则：如果未修改字符串，则效率更高   （因为它们在字符串公共池中共享）。但是，如果你   必须经常修改字符串的内容（例如状态   消息），你应该使用StringBuffer类（或StringBuilder   如下所述）。

因此，您可以尝试使用这两个类或默认的String类。决定哪一种最适合您的情况。我有以下类，它在极重载系统下提供大约300毫秒。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;


public class StringEfficientParser
{

    //String initial = "4239898 mdj 8746bbbrts675420120214";
    public static void parseString(String input) throws ParseException
    {

        StringBuilder sb = new StringBuilder(input);
        String input_date = sb.substring(26, 34);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyymmdd");
        Date date = sdf.parse(input_date);

    }

    public static void main(String[] args) throws ParseException
    {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++)
        {
            parseString("4239898 mdj 8746bbbrts675420120214");          
        }
        long stop  = System.currentTimeMillis();

        System.out.println("elapsed time : " + (stop - start));
    }

}

Java中的字符串位置解析

4 个答案: