Java/Reflection/Identifier

Материал из Java эксперт
Перейти к: навигация, поиск

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

   <source lang="java">
   

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 true if the given String is a valid Java
  *         identifier, false 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;
 }

}



 </source>
   
  
 
  



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

   <source lang="java">
 

/*

* 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;
 }

}


 </source>
   
  
 
  



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

   <source lang="java">
 

/*

* 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;
 }

}


 </source>
   
  
 
  



Escape Java Literal

   <source lang="java">
    

/*

* 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();
 }

}



 </source>
   
  
 
  



Is Java Identifier and get Java Identifier

   <source lang="java">
    

/*

   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();      
 }
 

}



 </source>
   
  
 
  



To Identifier String

   <source lang="java">
    

/*

* 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);
 }
 

}



 </source>