zstring.java

Java实现的遗传算法工具集：GA Playground

import java.lang.*;
import java.util.*;

/*
 ZString 2.5   96/12/6   Andre Pinheiro ([e-mail])
 Copyright (c) 1996, JavaZine - Online magazine about Java and netprogramming
 (http://camoes.rnl.ist.utl.pt/~adlp/JavaZine/index.html)
 All Rights Reserved.

 Permission to use, copy, modify, and distribute this software
 and its documentation for NON-COMMERCIAL or COMMERCIAL purposes
 and without fee is hereby granted provided that credit in
 this copyright notice appears in all copies.
 We will not be held responsible for any unwanted effects
 due to the usage of this software or any derivative.
 No warrantees for usability for any specific application
 are given or implied.

 ZString has all String's methods, plus:

* ZString()
  ZString toZString()
  static ZString valueOf(String s)
  char firstChar()
  char lastChar()
  ZString nChars(int n, int pos)
  ZString firstNChars(int n)
  ZString lastNChars(int n)
  ZString firstHalf()
  ZString secondHalf()
  boolean isCharAt(char c, int pos)
  boolean isSpaceAt(int pos)
  boolean isNewlineAt(int pos)
  boolean isQuoteAt(int pos)
  void clear();
  void set(String s)
  void set(ZString s)
  void set(char c)
  void add(String s)
  void add(ZString s)
  void add(char c)
  void addChar(char c)
  void addNChars(int n, char c)
  void plus(String s)
  void plus(ZString s)
  void plus(char c)
  void plusChar(char c)
  void plusNChars(int n, char c)
  void append(String s)
  void append(ZString s)
  void append(char c)
  void appendChar(char c)
  void appendNChars(int n, char c)
  void subtract(String s)
  void subtract(ZString s)
  void subtract(char c)
  void subtractChar(char c)
  void minus(String s)
  void minus(ZString s)
  void minus(char c)
  void minusChar(char c)
  void insert(String s, int pos)
  void insert(String s)
  void insert(ZString s, int pos)
  void insert(ZString s)
  void insert(char c, int pos)
  void insert(char c)
  void insertChar(char c, int pos)
  void insertChar(char c)
  void insertNChars(int n, char c, int pos)
  void insertNChars(int n, char c)
  void insertNewlineChar(int pos)
  void insertNewlineChar()
  void insertQuotes()
  boolean hasQuotes()
  boolean deleteQuotes()
  void insertParenthesis()
  boolean hasParenthesis()
  boolean deleteParenthesis()
  void deleteNChars(int n, int pos)
  void deleteNChars(int n)
  void deleteFirstNChars(int n)
  void deleteFirstChar()
  void deleteFirstCharIf(char c)
  void deleteChar(int pos)
  void deleteChar()
  void deleteCharIf(int pos, char c)
  void deleteLastNChars(int n)
  void deleteLastChar()
  void deleteLastCharIf(char c)
  void deleteLastCharIfNewline()
  void deleteTailUntil(char c)
  void deleteTailUntilNot(char c)
  void deleteHeadUntil(char c)
  void deleteHeadUntilNot(char c)
  void deleteAll(String s)
  void deleteAll(ZString s)
  void deleteAll(char c)
  void deleteAllSpaces()
  void deleteAllNewlines()
  void deleteAllQuotes()
  void deleteAllBut(String s)
  void deleteAllBut(ZString s)
  void toUpperCaseAll(String s)
  void toUpperCaseAll(ZString s)
  void toUpperCaseAll(char c)
  void toLowerCaseAll(String s)
  void toLowerCaseAll(ZString s)
  void toLowerCaseAll(char c)
  void toUpperCaseAllBut(String s)
  void toUpperCaseAllBut(ZString s)
  void toUpperCaseAllBut(char c)
  void toLowerCaseAllBut(String s)
  void toLowerCaseAllBut(ZString s)
  void toLowerCaseAllBut(char c)
  void shiftLeft()
  void shiftLeft(char c)
  void shiftRight()
  void shiftRight(char c)
  void rotateLeft()
  void rotateRight()
  void reverse()
  void fillWithNChars(int n, char c)
  void fillWithChars(char c)
  void shorten(int pos)
  void compact(int pos)
  void arrange()
* int validate(ZString invalidValues, ZString defaultValue, char separatorChar, boolean ignoreCase)
* int validate(ZString invalidValues, ZString defaultValue, char separatorChar)
* int validate(ZString invalidValues, ZString defaultValue)
* int validate(ZString invalidValues);
* int check(ZString invalidValues, char separatorChar, boolean ignoreCase)
* int check(ZString invalidValues, char separatorChar)
* int check(ZString invalidValues)
  int findADigit()
  int findButADigit()
  int countOccurences(char c)
  int countOccurences(String s)
  int countOccurences(ZString s)
  int findNearestCharAtLeft(char c, int pos)
  int findNearestCharAtRight(char c, int pos)
  int findNearestCharAtBeginning(char c)
  int findNearestCharAtEnd(char c)
  int findNearestCharAt(char c, int pos)
  int findNearestDifferentCharAtLeft(char c, int pos)
  int findNearestDifferentCharAtRight(char c, int pos)
  int findNearestDifferentCharAtBeginning(char c)
  int findNearestDifferentCharAtEnd(char c)
  int findNearestDifferentCharAt(char c, int pos)

  * - methods introduced in this version
*/


public class ZString
{
  private String myStr;
  static final String digits = "0123456789";


    public ZString(ZString value)
    {
      myStr = value.toString();
    }


    public ZString(String value)
    {
      myStr = value;
    }


    public ZString(char value[])
    {
      myStr = new String(value);
    }


    public ZString(char value[], int offset, int count)
    {
      myStr = new String(value, offset, count);
    }


    public ZString(byte ascii[], int hibyte, int offset, int count)
    {
      myStr = new String(ascii, hibyte, offset, count);
    }


    public ZString(byte ascii[], int hibyte)
    {
      myStr = new String(ascii, hibyte);
     
    }

     
    public ZString (StringBuffer buffer)
    { 
      myStr = new String(buffer);
    }
    

    public int length()
    {
      return myStr.length();
    }


    public char charAt(int index)
    {
      return myStr.charAt(index);
    }


    public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin)
    {
      myStr.getChars(srcBegin, srcEnd, dst, dstBegin);
    }


    public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin)
    {
      myStr.getBytes(srcBegin, srcEnd, dst, dstBegin);
    }


    public boolean equals(Object anObject)
    {
      return myStr.equals(anObject);
    }


    public boolean equalsIgnoreCase(ZString anotherString)
    {
      return myStr.equalsIgnoreCase(anotherString.toString());
    }


    public int compareTo(ZString anotherString)
    {
      return myStr.compareTo(anotherString.toString());
    }


    public boolean regionMatches(int toffset, ZString other, int ooffset, int len)
    {
      return myStr.regionMatches(toffset, other.toString(), ooffset, len);
    }


    public boolean regionMatches(boolean ignoreCase,
      int toffset, ZString other, int ooffset, int len)
    {
      return myStr.regionMatches(ignoreCase, toffset, other.toString(), ooffset, len);
    }


    public boolean startsWith(ZString prefix, int toffset)
    {
      return myStr.startsWith(prefix.toString(), toffset);
    }


    public boolean startsWith(ZString prefix)
    {
      return myStr.startsWith(prefix.toString());
    }


    public boolean endsWith(ZString suffix)
    {
      return myStr.endsWith(suffix.toString());
    }


    public int hashCode()
    {
      return myStr.hashCode();
    }


    public int indexOf(int ch)
    {
      return myStr.indexOf(ch);
    }


    public int indexOf(int ch, int fromIndex)
    {
      return myStr.indexOf(ch, fromIndex);
    }


    public int lastIndexOf(int ch)
    {
      return myStr.lastIndexOf(ch);
    }


    public int lastIndexOf(int ch, int fromIndex)
    {
      return myStr.lastIndexOf(ch, fromIndex);
    }


    public int indexOf(String str)
    {
      return myStr.indexOf(str);
    }


    public int indexOf(String str, int fromIndex)
    {
      return myStr.indexOf(str, fromIndex);
    }


    public int lastIndexOf(String str)
    {
      return myStr.lastIndexOf(str);
    }


    public int lastIndexOf(String str, int fromIndex)
    {
      return myStr.lastIndexOf(str, fromIndex);
    }


    public ZString substring(int beginIndex)
    {
      return valueOf(myStr.substring(beginIndex));
    }


    public ZString substring(int beginIndex, int endIndex)
    {
      return valueOf(myStr.substring(beginIndex, endIndex));
    }


    public ZString concat(String str)
    {
      return valueOf(myStr.concat(str));
    }


    public ZString replace(char oldChar, char newChar)
    {
      return valueOf(myStr.replace(oldChar, newChar));
    }


    public ZString toLowerCase()
    {
      return valueOf(myStr.toLowerCase());
    }


    public ZString toUpperCase()
    {
      return valueOf(myStr.toUpperCase());
    }


    public ZString trim()
    {
      return valueOf(myStr.trim());
    }


    public String toString()
    {
      return myStr;
    }


    public char[] toCharArray()
    {
      return myStr.toCharArray();
    }


    public static ZString valueOf(Object obj)
    {
      return (obj == null) ? new ZString("null") : new ZString(obj.toString());
    }


    public static ZString valueOf(char data[])
    {
      return new ZString(data);
    }


    public static ZString valueOf(char data[], int offset, int count)
    {
      return new ZString(data, offset, count);
    }

    
    public static ZString copyValueOf(char data[], int offset, int count)
    {
      char str[] = new char[count];
      System.arraycopy(data, offset, str, 0, count);
      
      return new ZString(str);
    }


    public static ZString copyValueOf(char data[])
    {
      return copyValueOf(data, 0, data.length);
    }


    public static ZString valueOf(boolean b)
    {
      return b ? new ZString("true") : new ZString("false");
    }


    public static ZString valueOf(char c)
    {
      char data[] = {c};

      return new ZString(data);
    }


    public static ZString valueOf(int i)
    {
      return new ZString(Integer.toString(i, 10));
    }


    public static ZString valueOf(long l)
    {
      return new ZString(Long.toString(l, 10));
    }


    public static ZString valueOf(float f)
    {
      return new ZString(Float.toString(f));
    }


    public static ZString valueOf(double d)
    {
      return new ZString(Double.toString(d));
    }


    public ZString intern()
    {
      return valueOf(myStr.intern());
    }


  // --- methods unique to ZString ---


  public ZString()
  {
    myStr = "";
  }


  public ZString toZString()
  {
    return this;
  }


  public static ZString valueOf(String s)
  {
    return new ZString(s);
  }


  //returns first character
  public char firstChar()
  {
    if (myStr.length() > 0)
      return myStr.charAt(0);
    else
      return '\0';
  }


  //returns last character
  public char lastChar()
  {
    if (myStr.length() > 0)
      return myStr.charAt(myStr.length() - 1);
    else
      return '\0';
  }


  //returns n characters starting at position pos
  public ZString nChars(int n, int pos)
  {
    return new ZString(myStr.substring(pos, pos + n));
  }


  //returns first n characters
  public ZString firstNChars(int n)
  {
    return new ZString(myStr.substring(0, n));
  }


  //returns last n characters
  public ZString lastNChars(int n)
  {
    return new ZString(myStr.substring(myStr.length() - n, myStr.length()));
  }


  //returns first half of the string
  public ZString firstHalf()
  {
    return new ZString(myStr.substring(0, myStr.length() / 2));
  }


  //returns second half of the string
  public ZString secondHalf()
  {
    return new ZString(myStr.substring(myStr.length() / 2, myStr.length()));
  }


  //returns true if there is a c character at position pos
  public boolean isCharAt(char c, int pos)
  {
    return (myStr.charAt(pos) == c);
  }


  //returns true if there is a space at position pos
  public boolean isSpaceAt(int pos)
  {
    return isCharAt(' ', pos);
  }


  //returns true if there is a newline character at position pos
  public boolean isNewlineAt(int pos)
  {
    return isCharAt('\n', pos);
  }


  //returns true if there is a quote at position pos
  public boolean isQuoteAt(int pos)
  {
    return isCharAt('\"', pos);
  }


  // clears the string
  public void clear()
  {
    myStr = "";