Data Type Java

/*
  Copyright (c) 2009 Olivier Chafik, All Rights Reserved
  
  This file is part of JNAerator (http://jnaerator.googlecode.com/).
  
  JNAerator is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
  
  JNAerator is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with JNAerator.  If not, see .
 */
//package org.ochafik.util.string;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class StringUtils {
  public static String htmlize(String text) {
    return text.startsWith("") ? text
        : ""
            + text.replace("&", "&").replace("<", "<")
                .replace(">", ">").replace("\n", "
")
            + "";
  }
  static Pattern spacePattern;
  public static List explode(String s) {
    if (spacePattern == null) {
      spacePattern = Pattern.compile("\\s+");
    }
    return explode(s, spacePattern);
  }
  public static List explode(String s, String sep) {
    StringTokenizer st = new StringTokenizer(s, sep);
    List v = new ArrayList();
    for (; st.hasMoreTokens();) {
      v.add(st.nextToken());
    }
    return v;
  }
  /*
   * public static final String implode(Object[] strings, String separator) {
   * return implode(Arrays.asList(strings), separator); }
   */
  public static String implode(double[] array, String separator) {
    StringBuffer out = new StringBuffer();
    boolean first = true;
    for (double v : array) {
      if (first)
        first = false;
      else
        out.append(separator);
      out.append(v);
    }
    return out.toString();
  }
  public static String implode(Object[] values) {
    return implode(values, ", ");
  }
  public static String implode(Object[] values, Object separator) {
    return implode(Arrays.asList(values), separator);
  }
  public static final  String implode(Iterable elements,
      Object separator) {
    String sepStr = separator.toString();
    StringBuilder out = new StringBuilder();
    boolean first = true;
    for (Object s : elements) {
      if (s == null)
        continue;
      if (first)
        first = false;
      else
        out.append(sepStr);
      out.append(s);
    }
    return out.toString();
  }
  public static final String implode(Iterable strings) {
    return implode(strings, ", ");
  }
  /*
   * public static final String implode(Collection strings, String
   * separator) { int size = 0, n = strings.size(); for (Object s : strings)
   * if (s != null) size += s.toString().length();
   * 
   * StringBuffer out = new StringBuffer(size + separator.length() * (n == 0 ?
   * 0 : n - 1)); boolean first = true; for (Object s : strings) { if (s ==
   * null) continue;
   * 
   * if (first) first = false; else out.append(separator); out.append(s); }
   * return out.toString(); }
   */
  public static final List explode(String string, Pattern separator) {
    int lastIndex = 0, len = string.length();
    Matcher matcher = separator.matcher(string);
    List ret = new LinkedList();
    while (matcher.find()) {
      String s = string.substring(lastIndex, matcher.start());
      if (s.length() > 0)
        ret.add(s);
      lastIndex = matcher.end();
    }
    String s = string.substring(lastIndex, len);
    if (s.length() > 0)
      ret.add(s);
    return ret;
  }
  public static String replace(String pattern, String replace, String s) {
    return concatWithSeparator(explode(s, pattern).toArray(new String[0]),
        replace);
  }
  public static final String concat(String[] a) {
    StringBuffer b = new StringBuffer();
    for (int i = 0; i < a.length; i++)
      b.append(a[i]);
    return b.toString();
  }
  public static final String concatln(String[] a) {
    StringBuffer b = new StringBuffer();
    int lenm = a.length - 1;
    for (int i = 0; i < lenm; i++) {
      b.append(a[i]);
      b.append("\n");
    }
    if (lenm != -1)
      b.append(a[lenm]);
    return b.toString();
  }
  public static final String concatSpace(String[] a) {
    StringBuffer b = new StringBuffer();
    int lenm = a.length - 1;
    for (int i = 0; i < lenm; i++) {
      b.append(a[i]);
      b.append(" ");
    }
    if (lenm != -1)
      b.append(a[lenm]);
    return b.toString();
  }
  public static final String concatWithSeparator(String[] a, String sep) {
    StringBuffer b = new StringBuffer();
    int lenm = a.length - 1;
    for (int i = 0; i < lenm; i++) {
      b.append(a[i]);
      b.append(sep);
    }
    if (lenm != -1)
      b.append(a[lenm]);
    return b.toString();
  }
  public static final String javaEscape(String s) {
    if (s == null)
      return null;
    char c;
    int len = s.length();
    StringBuffer b = new StringBuffer(len);
    for (int i = 0; i < len; i++) {
      c = s.charAt(i);
      switch (c) {
      case '\n':
        b.append("\\n");
        break;
      case '\t':
        b.append("\\t");
        break;
      case '\r':
        b.append("\\r");
        break;
      case '"':
        b.append("\"");
        break;
      case '\\':
        b.append("\\\\");
        break;
      default:
        if (c > 127 || Character.isISOControl(c)) {
          b.append("\\u");
          String nb = Integer.toString((int) c, 16);
          int nblen = nb.length();
          switch (nblen) {
          case 1:
            b.append(0);
          case 2:
            b.append(0);
          case 3:
            b.append(0);
          case 4:
            b.append(nb);
            break;
          default:
            throw new IllegalArgumentException(
                "Should not happen !");
          }
        } else
          b.append(c);
      }
    }
    return b.toString();
  }
  public static final String javaUnEscape(String s) {
    char c;
    int len = s.length();
    StringBuffer b = new StringBuffer(len);
    for (int i = 0; i < len; i++) {
      c = s.charAt(i);
      if (c == '\\') {
        c = s.charAt(++i);
        switch (c) {
        case 'n':
          b.append('\n');
          break;
        case 'r':
          b.append('\r');
          break;
        case 't':
          b.append('\t');
          break;
        case '\\':
          b.append('\\');
          break;
        case '"':
          b.append('"');
          break;
        case '\'':
          b.append('\'');
          break;
        case 'u':
          try {
            String nb = s.substring(i + 1, i + 5);
            int n = Integer.parseInt(nb, 16);
            b.append((char) n);
            i += 4;
          } catch (Exception ex) {
            throw new IllegalArgumentException(
                "Illegal unicode escaping in string \"" + s
                    + "\" at index " + i, ex);
          }
          break;
        default:
          throw new IllegalArgumentException(
              "Unknown character: \"\\" + String.valueOf(c)
                  + "...\"");
        }
      } else
        b.append(c);
    }
    return b.toString();
  }
  public static String capitalize(String string) {
    return string == null ? null : string.length() == 0 ? "" : Character
        .toUpperCase(string.charAt(0)) + string.substring(1);
  }
  public static String capitalize(List strings, String separator) {
    List cap = new ArrayList(strings.size());
    for (String s : strings)
      cap.add(capitalize(s));
    return implode(cap, separator);
  }
  public static String uncapitalize(String string) {
    return string.length() == 0 ? "" : Character.toLowerCase(string
        .charAt(0)) + string.substring(1);
  }
  public static final String LINE_SEPARATOR;
  static {
    LINE_SEPARATOR = System.getProperty("line.separator");
  }
}