• 有序的properties的工具类


    public class OrderProperties extends Properties {
    /** 序列化ID */
    private static final long serialVersionUID = -762117852594617585L;
    private static final String keyValueSeparators = "=: f";
    private static final String strictKeyValueSeparators = "=:";
    private static final String specialSaveChars = "=: f#!";
    private static final String whiteSpaceChars = " f";
    /** A table of hex digits */
    private static final char[] hexDigit = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    private PropertiesContext context = new PropertiesContext();

    private static void writeln(BufferedWriter bw, String s) throws IOException {
    bw.write(s);
    bw.newLine();
    }

    /**
    * Convert a nibble to a hex character
    *
    * @param nibble the nibble to convert.
    */
    private static char toHex(int nibble) {
    return hexDigit[(nibble & 0xF)];
    }

    public PropertiesContext getContext() {
    return context;
    }

    public synchronized void load(InputStream inStream) throws IOException {

    BufferedReader in;

    in = new BufferedReader(new InputStreamReader(inStream, "8859_1"));
    while (true) {
    // Get next line
    String line = in.readLine();
    // intract property/comment string
    String intactLine = line;
    if (line == null)
    return;

    if (line.length() > 0) {

    // Find start of key
    int len = line.length();
    int keyStart;
    for (keyStart = 0; keyStart < len; keyStart++)
    if (whiteSpaceChars.indexOf(line.charAt(keyStart)) == -1)
    break;

    // Blank lines are ignored
    if (keyStart == len)
    continue;

    // Continue lines that end in slashes if they are not comments
    char firstChar = line.charAt(keyStart);

    if ((firstChar != '#') && (firstChar != '!')) {
    while (continueLine(line)) {
    String nextLine = in.readLine();
    intactLine = intactLine + " " + nextLine;
    if (nextLine == null)
    nextLine = "";
    String loppedLine = line.substring(0, len - 1);
    // Advance beyond whitespace on new line
    int startIndex;
    for (startIndex = 0; startIndex < nextLine.length(); startIndex++)
    if (whiteSpaceChars.indexOf(nextLine.charAt(startIndex)) == -1)
    break;
    nextLine = nextLine.substring(startIndex, nextLine.length());
    line = loppedLine + nextLine;
    len = line.length();
    }

    // Find separation between key and value
    int separatorIndex;
    for (separatorIndex = keyStart; separatorIndex < len; separatorIndex++) {
    char currentChar = line.charAt(separatorIndex);
    if (currentChar == '\')
    separatorIndex++;
    else if (keyValueSeparators.indexOf(currentChar) != -1)
    break;
    }

    // Skip over whitespace after key if any
    int valueIndex;
    for (valueIndex = separatorIndex; valueIndex < len; valueIndex++)
    if (whiteSpaceChars.indexOf(line.charAt(valueIndex)) == -1)
    break;

    // Skip over one non whitespace key value separators if any
    if (valueIndex < len)
    if (strictKeyValueSeparators.indexOf(line.charAt(valueIndex)) != -1)
    valueIndex++;

    // Skip over white space after other separators if any
    while (valueIndex < len) {
    if (whiteSpaceChars.indexOf(line.charAt(valueIndex)) == -1)
    break;
    valueIndex++;
    }
    String key = line.substring(keyStart, separatorIndex);
    String value = (separatorIndex < len) ? line.substring(valueIndex, len) : "";

    // Convert then store key and value
    key = loadConvert(key);
    value = loadConvert(value);
    //memorize the property also with the whold string
    put(key, value, intactLine);
    } else {
    //memorize the comment string
    context.addCommentLine(intactLine);
    }
    } else {
    //memorize the string even the string is empty
    context.addCommentLine(intactLine);
    }
    }
    }

    /*
    * Converts encoded &#92;uxxxx to unicode chars and changes special saved
    * chars to their original forms
    */
    private String loadConvert(String theString) {
    char aChar;
    int len = theString.length();
    StringBuilder outBuffer = new StringBuilder(len);

    for (int x = 0; x < len; ) {
    aChar = theString.charAt(x++);
    if (aChar == '\') {
    aChar = theString.charAt(x++);
    if (aChar == 'u') {
    // Read the xxxx
    int value = 0;
    for (int i = 0; i < 4; i++) {
    aChar = theString.charAt(x++);
    switch (aChar) {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    value = (value << 4) + aChar - '0';
    break;
    case 'a':
    case 'b':
    case 'c':
    case 'd':
    case 'e':
    case 'f':
    value = (value << 4) + 10 + aChar - 'a';
    break;
    case 'A':
    case 'B':
    case 'C':
    case 'D':
    case 'E':
    case 'F':
    value = (value << 4) + 10 + aChar - 'A';
    break;
    default:
    throw new IllegalArgumentException("Malformed \uxxxx encoding.");
    }
    }
    outBuffer.append((char) value);
    } else {
    if (aChar == 't')
    outBuffer.append(' '); /* ibm@7211 */

    else if (aChar == 'r')
    outBuffer.append(' '); /* ibm@7211 */
    else if (aChar == 'n') {
    /*
    * ibm@8897 do not convert a to a line.separator
    * because on some platforms line.separator is a String
    * of " ". When a Properties class is saved as a file
    * (store()) and then restored (load()) the restored
    * input MUST be the same as the output (so that
    * Properties.equals() works).
    *
    */
    outBuffer.append(' '); /* ibm@8897 ibm@7211 */
    } else if (aChar == 'f')
    outBuffer.append('f'); /* ibm@7211 */
    else
    /* ibm@7211 */
    outBuffer.append(aChar); /* ibm@7211 */
    }
    } else
    outBuffer.append(aChar);
    }
    return outBuffer.toString();
    }

    public synchronized void store(OutputStream out, String header) throws IOException {
    BufferedWriter awriter;
    awriter = new BufferedWriter(new OutputStreamWriter(out, "8859_1"));
    if (header != null)
    writeln(awriter, "#" + header);
    @SuppressWarnings("rawtypes")
    List entrys = context.getCommentOrEntrys();
    for (Object obj : entrys) {
    if (obj.toString() != null) {
    writeln(awriter, obj.toString());
    }
    }
    awriter.flush();
    }

    private boolean continueLine(String line) {
    int slashCount = 0;
    int index = line.length() - 1;
    while ((index >= 0) && (line.charAt(index--) == '\'))
    slashCount++;
    return (slashCount % 2 == 1);
    }

    /*
    * Converts unicodes to encoded &#92;uxxxx and writes out any of the
    * characters in specialSaveChars with a preceding slash
    */
    private String saveConvert(String theString, boolean escapeSpace) {
    int len = theString.length();
    StringBuilder outBuffer = new StringBuilder(len * 2);

    for (int x = 0; x < len; x++) {
    char aChar = theString.charAt(x);
    switch (aChar) {
    case ' ':
    if (x == 0 || escapeSpace)
    outBuffer.append('\');

    outBuffer.append(' ');
    break;
    case '\':
    outBuffer.append('\');
    outBuffer.append('\');
    break;
    case ' ':
    outBuffer.append('\');
    outBuffer.append('t');
    break;
    case ' ':
    outBuffer.append('\');
    outBuffer.append('n');
    break;
    case ' ':
    outBuffer.append('\');
    outBuffer.append('r');
    break;
    case 'f':
    outBuffer.append('\');
    outBuffer.append('f');
    break;
    default:
    if ((aChar < 0x0020) || (aChar > 0x007e)) {
    outBuffer.append('\');
    outBuffer.append('u');
    outBuffer.append(toHex((aChar >> 12) & 0xF));
    outBuffer.append(toHex((aChar >> 8) & 0xF));
    outBuffer.append(toHex((aChar >> 4) & 0xF));
    outBuffer.append(toHex(aChar & 0xF)); }
    else {
    if (specialSaveChars.indexOf(aChar) != -1)
    outBuffer.append('\');
    outBuffer.append(aChar); } } }



    return outBuffer.toString(); }


    public synchronized Object put(Object key, Object value) {
    context.putOrUpdate(key.toString(), value.toString());
    return super.put(key, value); }


    public synchronized Object put(Object key, Object value, String line) {
    context.putOrUpdate(key.toString(), value.toString(), line);
    return super.put(key, value); }


    public synchronized Object remove(Object key) {
    context.remove(key.toString());
    return super.remove(key); }


    /** @param comment */
    public void addComment(String comment) {
    if (comment != null) {
    context.addCommentLine("#" + comment); } }



    class PropertiesContext {
    /** 描述信息 */
    private List<Object> commentOrEntrys = Lists.newArrayList();

    @SuppressWarnings("rawtypes")
    public List getCommentOrEntrys() {
    return commentOrEntrys; }


    public void addCommentLine(String line) {
    commentOrEntrys.add(line); }


    public void putOrUpdate(PropertyEntry pe) { remove(pe.getKey());

    commentOrEntrys.add(pe); }


    public void putOrUpdate(String key, String value, String line) {
    PropertyEntry pe = new PropertyEntry(key, value, line); remove(key);

    commentOrEntrys.add(pe); }


    public void putOrUpdate(String key, String value) {
    PropertyEntry pe = new PropertyEntry(key, value);
    int index = remove(key);
    commentOrEntrys.add(index, pe); }


    public int remove(String key) {
    for (int index = 0; index < commentOrEntrys.size(); index++) {
    Object obj = commentOrEntrys.get(index);
    if (obj instanceof PropertyEntry) {
    if (!Objects.equal(obj, null)) {
    if (key.equals(((PropertyEntry) obj).getKey())) {
    commentOrEntrys.remove(obj);
    return index; } } } }




    return commentOrEntrys.size(); }


    /** 属性描述 */
    class PropertyEntry {
    /** 属性KEY */
    private String key;
    /** 属性值 */
    private String value;
    /** 属性行 */
    private String line;

    public PropertyEntry(String key, String value) {
    this.key = key;
    this.value = value; }


    /**
    * 构建属性描述
    *
    * @param key key
    * @param value value
    * @param line line
    */
    public PropertyEntry(String key, String value, String line) {
    this(key, value);
    this.line = line; }


    public String getLine() {
    return line; }


    public void setLine(String line) {
    this.line = line; }


    public String getKey() {
    return key; }


    public void setKey(String key) {
    this.key = key; }


    public String getValue() {
    return value; }


    public void setValue(String value) {
    this.value = value; }


    public String toString() {
    if (line != null) {
    return line; }

    if (key != null && value != null) {
    String k = saveConvert(key, true);
    String v = saveConvert(value, false);
    return k + "=" + v; }

    return null; } } }}



  • 相关阅读:
    rh
    re模块
    粘包现象
    子类调用父类方法
    北大医院条码
    戴德金-连续性和无理数-第1页
    数学名词
    核心英语笔记,含记忆术mnemonics
    python笔记
    收集的句子
  • 原文地址:https://www.cnblogs.com/luyuefei/p/13386592.html
Copyright © 2020-2023  润新知