Java/Reflection/Identifier

Check whether the given String is a valid identifier according to the Java Language specifications.

    
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Map;

/*
  * JBoss, Home of Professional Open Source
  * Copyright 2005, JBoss Inc., and individual contributors as indicated
  * by the @authors tag. See the copyright.txt in the distribution for a
  * full listing of individual contributors.
  *
  * This is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */

public class Main{
  /**
   * Check whether the given String is a valid identifier according
   * to the Java Language specifications.
   *
   * See The Java Language Specification Second Edition, Section 3.8
   * for the definition of what is a valid identifier.
   *
   * @param s String to check
   *
   * @return <code>true</code> if the given String is a valid Java
   *         identifier, <code>false</code> otherwise.
   */
  public final static boolean isValidJavaIdentifier(String s)
  {
     // an empty or null string cannot be a valid identifier
     if (s == null || s.length() == 0)
     {
        return false;
     }
     char[] c = s.toCharArray();
     if (!Character.isJavaIdentifierStart(c[0]))
     {
        return false;
     }
     for (int i = 1; i < c.length; i++)
     {
        if (!Character.isJavaIdentifierPart(c[i]))
        {
           return false;
        }
     }
     return true;
  }

}

Determines if the specified string is permissible as a Java identifier.

  
/*
 * Copyright 2005 Joe Walker
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * @author Joe Walker [joe at getahead dot ltd dot uk]
 */
public class Main {
  /**
   * Determines if the specified string is permissible as a Java identifier.
   * Returns true if the string is non-null, non-zero length with a Java
   * identifier start as the first character and Java identifier parts in all
   * remaining characters.
   * @param test the string to be tested.
   * @return true if the string is a Java identifier, false otherwise.
   * @see java.lang.Character#isJavaIdentifierPart(char)
   * @see java.lang.Character#isJavaIdentifierStart(char)
   */
  public static boolean isJavaIdentifier(String test)
  {
      if (test == null || test.length() == 0)
      {
          return false;
      }
      if (!Character.isJavaIdentifierStart(test.charAt(0)) && test.charAt(0) != "_")
      {
          return false;
      }
      for (int i = 1; i < test.length(); i++)
      {
          if (!Character.isJavaIdentifierPart(test.charAt(i)) && test.charAt(i) != "_")
          {
              return false;
          }
      }
      return true;
  }
}

Determine whether the supplied string represents a well-formed fully-qualified Java classname.

  
/*
 * JBoss DNA (http://www.jboss.org/dna)
 * See the COPYRIGHT.txt file distributed with this work for information
 * regarding copyright ownership.  Some portions may be licensed
 * to Red Hat, Inc. under one or more contributor license agreements.
 * See the AUTHORS.txt file in the distribution for a full listing of 
 * individual contributors. 
 *
 * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
 * is licensed to you under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * JBoss DNA 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;

public class Utils {
  /**
   * Determine whether the supplied string represents a well-formed fully-qualified Java classname. This utility method enforces
   * no conventions (e.g., packages are all lowercase) nor checks whether the class is available on the classpath.
   * 
   * @param classname
   * @return true if the string is a fully-qualified class name
   */
  public static boolean isFullyQualifiedClassname( String classname ) {
      if (classname == null) return false;
      String[] parts = classname.split("[\\.]");
      if (parts.length == 0) return false;
      for (String part : parts) {
          CharacterIterator iter = new StringCharacterIterator(part);
          // Check first character (there should at least be one character for each part) ...
          char c = iter.first();
          if (c == CharacterIterator.DONE) return false;
          if (!Character.isJavaIdentifierStart(c) && !Character.isIdentifierIgnorable(c)) return false;
          c = iter.next();
          // Check the remaining characters, if there are any ...
          while (c != CharacterIterator.DONE) {
              if (!Character.isJavaIdentifierPart(c) && !Character.isIdentifierIgnorable(c)) return false;
              c = iter.next();
          }
      }
      return true;
  }
}

Escape Java Literal

     
/*
 * Static String formatting and query routines.
 * Copyright (C) 2001-2005 Stephen Ostermiller
 * http://ostermiller.org/contact.pl?regarding=Java+Utilities
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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.
 *
 * See COPYING.TXT for details.
 */

import java.util.HashMap;
import java.util.regex.Pattern;
/**
 * Utilities for String formatting, manipulation, and queries.
 * More information about this class is available from .
 *
 * @author Stephen Ostermiller http://ostermiller.org/contact.pl?regarding=Java+Utilities
 * @since ostermillerutils 1.00.00
 */
public class StringHelper {
  /**
   * Replaces characters that are not allowed in a Java style
   * string literal with their escape characters.  Specifically
   * quote ("), single quote ("), new line (\n), carriage return (\r),
   * and backslash (\), and tab (\t) are escaped.
   *
   * @param s String to be escaped
   * @return escaped String
   * @throws NullPointerException if s is null.
   *
   * @since ostermillerutils 1.00.00
   */
  public static String escapeJavaLiteral(String s){
    int length = s.length();
    int newLength = length;
    // first check for characters that might
    // be dangerous and calculate a length
    // of the string that has escapes.
    for (int i=0; i<length; i++){
      char c = s.charAt(i);
      switch(c){
        case "\"":
        case "\"":
        case "\n":
        case "\r":
        case "\t":
        case "\\":{
          newLength += 1;
        } break;
      }
    }
    if (length == newLength){
      // nothing to escape in the string
      return s;
    }
    StringBuffer sb = new StringBuffer(newLength);
    for (int i=0; i<length; i++){
      char c = s.charAt(i);
      switch(c){
        case "\"":{
          sb.append("\\\"");
        } break;
        case "\"":{
          sb.append("\\\"");
        } break;
        case "\n":{
          sb.append("\\n");
        } break;
        case "\r":{
          sb.append("\\r");
        } break;
        case "\t":{
          sb.append("\\t");
        } break;
        case "\\":{
          sb.append("\\\\");
        } break;
        default: {
          sb.append(c);
        }
      }
    }
    return sb.toString();
  }
}

Is Java Identifier and get Java Identifier

     
/*
    GNU LESSER GENERAL PUBLIC LICENSE
    Copyright (C) 2006 The Lobo Project
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
    This library 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
    Lesser General Public License for more details.
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    Contact info: lobochief@users.sourceforge.net
*/
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
public class Strings
{
  private static final MessageDigest MESSAGE_DIGEST;
  public static final String[] EMPTY_ARRAY = new String[0];
  static {
      MessageDigest md;
      try {
          md = MessageDigest.getInstance("MD5");
      } catch(NoSuchAlgorithmException err) {
        throw new IllegalStateException();
      }
      MESSAGE_DIGEST = md;
  }
  public static boolean isBlank(String text) {
      return text == null || "".equals(text);
  }
  
  public static int countLines(String text) 
  {
    int startIdx = 0;
    int lineCount = 1;
    for(;;) 
    {
      int lbIdx = text.indexOf("\n", startIdx);
      if(lbIdx == -1) 
      {
        break;
      }
      lineCount++;
      startIdx = lbIdx + 1;
    }
    return lineCount;
  }
  public static boolean isJavaIdentifier(String id) 
  {
    if(id == null) 
    {
      return false;
    }
    int len = id.length();
    if(len == 0) 
    {
      return false;
    }
    if(!Character.isJavaIdentifierStart(id.charAt(0))) 
    {
      return false;
    }
    for(int i = 1; i < len; i++) 
    {
      if(!Character.isJavaIdentifierPart(id.charAt(i))) 
      {
        return false;
      }
    }
    return true;
  }
  
  public static String getJavaStringLiteral(String text) {
      StringBuffer buf = new StringBuffer();
      buf.append(""");
      int len = text.length();
      for(int i = 0; i < len; i++) {
          char ch = text.charAt(i);
          switch(ch) {
          case "\\":
              buf.append("\\\\");
              break;
          case "\n":
              buf.append("\\n");
              break;
          case "\r":
              buf.append("\\r");
              break;
          case "\t":
              buf.append("\\t");
              break;
          case """:
              buf.append("\\\"");
              break;
          default:
              buf.append(ch);
            break;
          }
      }
      buf.append(""");
      return buf.toString();
  }
  
  public static String getJavaIdentifier(String candidateID) {
    int len = candidateID.length();
    StringBuffer buf = new StringBuffer();
    for(int i = 0; i < len; i++) 
    {
        char ch = candidateID.charAt(i);
      boolean good = i == 0 ? Character.isJavaIdentifierStart(ch) : Character.isJavaIdentifierPart(ch);
      if(good) 
      {
          buf.append(ch);
      }
      else {
          buf.append("_");
      }
    }
    return buf.toString();      
  }
  
}

To Identifier String

     
/*
 * Copyright 2000,2005 wingS development team.
 *
 * This file is part of wingS (http://wingsframework.org).
 *
 * wingS is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 *
 * Please see COPYING for the complete licence.
 */
import java.util.StringTokenizer;
/**
 * Some string manipulation utilities.
 *
 * @author 
 */
public class StringUtil {
  private final static char[] ALPHAS = {
      "a", "b",
      "c", "d", "e", "f", "g", "h",
      "i", "j", "k", "l", "m", "n",
      "o", "p", "q", "r", "s", "t",
      "u", "v", "w", "x", "y", "z",
  };
  /**
   * All possible digits for representing a number as a String
   * This is conservative and does not include "special"
   * characters since some browsers don"t handle them right.
   * The IE for instance seems to be case insensitive in class
   * names for CSSs. Grrr.
   */
  private final static char[] DIGITS = {
      "0", "1", "2", "3", "4", "5",
      "6", "7", "8", "9", "a", "b",
      "c", "d", "e", "f", "g", "h",
      "i", "j", "k", "l", "m", "n",
      "o", "p", "q", "r", "s", "t",
      "u", "v", "w", "x", "y", "z",
      /* This %@&!-IE is case insensitive for certain
       * URLs and IDs
       * "A" , "B" ,
       * "C" , "D" , "E" , "F" , "G" , "H" ,
       * "I" , "J" , "K" , "L" , "M" , "N" ,
       * "O" , "P" , "Q" , "R" , "S" , "T" ,
       * "U" , "V" , "W" , "X" , "Y" , "Z"
       */
  };
  public static final int MAX_RADIX = DIGITS.length;
  /**
   * creates a shortest possible string representation of the given
   * long number that qualifies as an identifier in common programming
   * languages (and HTML-id"s :-)
   * That is, it must start with a letter.
   *
   * @param val the long value to be encoded
   * @return a string represantation of the given value that qualifies
   *         as an identifier.
   */
  public static String toIdentifierString(long val) {
      char buf[] = new char[14];
      int i = 0;
      if (val < 0) {
          buf[i++] = "_";
          val = -(val + 1);
      }
      buf[i++] = ALPHAS[(int) (val % ALPHAS.length)];
      val /= ALPHAS.length;
      while (val != 0 && i < buf.length) {
          buf[i++] = DIGITS[(int) (val % DIGITS.length)];
          val /= DIGITS.length;
      }
      return new String(buf, 0, i);
  }
  
}