java 常用工具类？

1：设计一个方法要求检查一个指定字符是否允许作为 Java 标识符中的首字符,并测试？
2：设计一个方法，接收一个字符和字符串，然后返回这个字符在这个字符串出现的次数，并测试？
3：设计一个类并提供一个方法，将整型值转换为二进制、十六进制和八进制值？
4：设计一个方法，接收一个byte然后将其转换字母并要求是大写的，再设计一个方法判断其是元音还是辅音。最后在main方法中声明一个数组，要求随机产生10个符合字母范围的数据放在数组内，并使用一个方法转成大写，另个方法判断其是元音还是辅音，并打印出来。

5：设计一个方法，接收三个参数分别是年，月，日,然后返加一个Calender类型的对象，再设计一个方法接收Calender类型对象，在方法内分别打印此日期是一个月的第几天，一年的第几天，一周的第几天，此天是周几，这个月的第一天是周几，是一周的第几天。

这些方法很多都已经有了

[code="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. */ package org.directwebremoting.util;

import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.xml.transform.TransformerFactoryConfigurationError;

/**

一些通用的方法
Various utilities, mostly to make up for JDK 1.4 functionallity that is not
in JDK 1.3
@author Joe Walker [joe at getahead dot ltd dot uk]
/
public final class LocalUtil
{
/*
- splitInbound() returns the type info in this parameter */ public static final int INBOUND_INDEX_TYPE = 0;
/**
- splitInbound() returns the value info in this parameter */ public static final int INBOUND_INDEX_VALUE = 1;
/**
- Prevent instansiation */ private LocalUtil() { }
/**
- Replacement for String#replaceAll(String, String) in JDK 1.4+
- @param text source text
- @param repl the stuff to get rid of
- @param with the stuff to replace it with
- @return replaced text or null if any args are null
  */
  public static String replace(String text, String repl, String with)
  {
  if (text == null || repl == null || with == null || repl.length() == 0)
  {
  return text;
  }
  StringBuffer buf = new StringBuffer(text.length());
  int searchFrom = 0;
  while (true)
  {
  int foundAt = text.indexOf(repl, searchFrom);
  if (foundAt == -1)
  {
  break;
  }
```
buf.append(text.substring(searchFrom, foundAt)).append(with);
searchFrom = foundAt + repl.length();
```
  }
  buf.append(text.substring(searchFrom));
  return buf.toString();
  }
/**
- 判断给定的字符串是否符合 Java 标识符的规范
- 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;
  }
/**
- Determines if the specified string contains only Unicode letters or
- digits as defined by {@link Character#isLetterOrDigit(char)}
- @param test The string to test
- @return true if the string is non-null, non-empty and contains only
- characters that are unicode letters or digits
- @see Character#isLetterOrDigit(char)
  */
  public static boolean isLetterOrDigitOrUnderline(String test)
  {
  if (test == null || test.length() == 0)
  {
  return false;
  }
  for (int i = 0; i < test.length(); i++)
  {
  if (!Character.isLetterOrDigit(test.charAt(i)) && test.charAt(i) != '_')
  {
  return false;
  }
  }
  return true;
  }
/**
- True if c1 is java.lang.Boolean and c2 is boolean, etc.
- @param c1 the first class to test
- @param c2 the second class to test
- @return true if the classes are equivalent
  */
  public static boolean isEquivalent(Class c1, Class c2)
  {
  if (c1 == Boolean.class || c1 == Boolean.TYPE)
  {
  return c2 == Boolean.class || c2 == Boolean.TYPE;
  }
  else if (c1 == Byte.class || c1 == Byte.TYPE)
  {
  return c2 == Byte.class || c2 == Byte.TYPE;
  }
  else if (c1 == Character.class || c1 == Character.TYPE)
  {
  return c2 == Character.class || c2 == Character.TYPE;
  }
  else if (c1 == Short.class || c1 == Short.TYPE)
  {
  return c2 == Short.class || c2 == Short.TYPE;
  }
  else if (c1 == Integer.class || c1 == Integer.TYPE)
  {
  return c2 == Integer.class || c2 == Integer.TYPE;
  }
  else if (c1 == Long.class || c1 == Long.TYPE)
  {
  return c2 == Long.class || c2 == Long.TYPE;
  }
  else if (c1 == Float.class || c1 == Float.TYPE)
  {
  return c2 == Float.class || c2 == Float.TYPE;
  }
  else if (c1 == Double.class || c1 == Double.TYPE)
  {
  return c2 == Double.class || c2 == Double.TYPE;
  }
  else if (c1 == Void.class || c1 == Void.TYPE)
  {
  return c2 == Void.class || c2 == Void.TYPE;
  }
  return false;
  }
/**
- @param type The class to de-primitivize
- @return The non-privitive version of the class
  */
  public static Class getNonPrimitiveType(Class type)
  {
  if (!type.isPrimitive())
  {
  return type;
  }
  else if (type == Boolean.TYPE)
  {
  return Boolean.class;
  }
  else if (type == Byte.TYPE)
  {
  return Byte.class;
  }
  else if (type == Character.TYPE)
  {
  return Character.class;
  }
  else if (type == Short.TYPE)
  {
  return Short.class;
  }
  else if (type == Integer.TYPE)
  {
  return Integer.class;
  }
  else if (type == Long.TYPE)
  {
  return Long.class;
  }
  else if (type == Float.TYPE)
  {
  return Float.class;
  }
  else if (type == Double.TYPE)
  {
  return Double.class;
  }
  else if (type == Void.TYPE)
  {
  return Void.class;
  }
  return null;
  }
/**
- Add headers to prevent browers and proxies from caching this reply.
- @param resp The response to add headers to
  */
  public static void addNoCacheHeaders(HttpServletResponse resp)
  {
  // Set standard HTTP/1.1 no-cache headers.
  resp.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
  // Set IE extended HTTP/1.1 no-cache headers (use addHeader).
  resp.addHeader("Cache-Control", "post-check=0, pre-check=0");
  // Set standard HTTP/1.0 no-cache header.
  resp.setHeader("Pragma", "no-cache");
  // Set to expire far in the past. Prevents caching at the proxy server
  resp.setHeader("Expires", "Sat, 6 May 1995 12:00:00 GMT");
  }
/**
- Is this class one that we auto fill, so the user can ignore?
- @param paramType The type to test
- @return true if the type is a Servlet type */ public static boolean isServletClass(Class paramType) { return paramType == HttpServletRequest.class || paramType == HttpServletResponse.class || paramType == ServletConfig.class || paramType == ServletContext.class || paramType == HttpSession.class; }
/**
- URL decode a value. This method gets around the lack of a
- decode(String, String) method in JDK 1.3.
- @param value The string to decode
- @return The decoded string
  */
  public static String decode(String value)
  {
  if (!testedDecoder)
  {
  try
  {
  decode14 = URLDecoder.class.getMethod("decode", new Class[] { String.class, String.class });
  }
  catch (Exception ex)
  {
  if (!warn13)
  {
  log.warn("URLDecoder.decode(String, String) is not available. Falling back to 1.3 variant.");
  warn13 = true;
  }
  }
```
testedDecoder = true;
```
  }
  if (decode14 != null)
  {
  try
  {
  return (String) decode14.invoke(null, new Object[] { value, "UTF-8" });
  }
  catch (Exception ex)
  {
  log.warn("Failed to use JDK 1.4 decoder", ex);
  }
  }
  return URLDecoder.decode(value);
  }
/**
- 用反射给对象设置属性集
- Set use reflection to set the setters on the object called by the keys
- in the params map with the corresponding values
- @param object The object to setup
- @param params The settings to use
- @param ignore List of keys to not warn about if they are not properties
- ```
          Note only the warning is skipped, we still try the setter
```
  */
  public static void setParams(Object object, Map params, List ignore)
  {
  for (Iterator it = params.entrySet().iterator(); it.hasNext();)
  {
  Map.Entry entry = (Map.Entry) it.next();
  String key = (String) entry.getKey();
  Object value = entry.getValue();
```
try
{
    setProperty(object, key, value);
}
catch (NoSuchMethodException ex)
{
    if (ignore != null && !ignore.contains(key))
    {
        log.warn("No property '" + key + "' on " + object.getClass().getName());
    }
}
catch (InvocationTargetException ex)
{
    log.warn("Error setting " + key + "=" + value + " on " + object.getClass().getName(), ex.getTargetException());
}
catch (Exception ex)
{
    log.warn("Error setting " + key + "=" + value + " on " + object.getClass().getName(), ex);
}
```
  }
  }
/**
- 用反射给对象设置属性，通过给定的属性名。
- Set a property on an object using reflection
- @param object The object to call the setter on
- @param key The name of the property to set.
- @param value The new value to use for the property
- @throws NoSuchMethodException Passed on from reflection code
- @throws SecurityException Passed on from reflection code
- @throws IllegalAccessException Passed on from reflection code
- @throws IllegalArgumentException Passed on from reflection code
- @throws InvocationTargetException Passed on from reflection code
  */
  public static void setProperty(Object object, String key, Object value) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
  {
  Class real = object.getClass();
  String setterName = "set" + key.substring(0, 1).toUpperCase(Locale.ENGLISH) + key.substring(1);
  try
  {
  // Can we work with whatever type we were given?
  Method method = real.getMethod(setterName, new Class[] { value.getClass() });
  method.invoke(object, new Object[] { value });
  return;
  }
  catch (NoSuchMethodException ex)
  {
  // If it is a string then next we try to coerce it to the right type
  // otherwise we give up.
  if (!(value instanceof String))
  {
  throw ex;
  }
  }
  Method[] methods = real.getMethods();
  for (int i = 0; i < methods.length; i++)
  {
  Method setter = methods[i];
```
if (setter.getName().equals(setterName) && setter.getParameterTypes().length == 1)
{
    Class propertyType = setter.getParameterTypes()[0];
    try
    {
        Object param = LocalUtil.simpleConvert((String) value, propertyType);
        setter.invoke(object, new Object[] { param });
        return;
    }
    catch (IllegalArgumentException ex)
    {
        // The conversion failed - it was speculative anyway so we
        // don't worry now
    }
}
```
  }
  throw new NoSuchMethodException("Failed to find a property called: " + key + " on " + object.getClass().getName());
  }
/**
- Can the type be used in a call to {@link #simpleConvert(String, Class)}?
- @param paramType The type to test
- @return true if the type is acceptable to simpleConvert() */ public static boolean isTypeSimplyConvertable(Class paramType) { return paramType == String.class || paramType == Integer.class || paramType == Integer.TYPE || paramType == Short.class || paramType == Short.TYPE || paramType == Byte.class || paramType == Byte.TYPE || paramType == Long.class || paramType == Long.TYPE || paramType == Float.class || paramType == Float.TYPE || paramType == Double.class || paramType == Double.TYPE || paramType == Character.class || paramType == Character.TYPE || paramType == Boolean.class || paramType == Boolean.TYPE; }
/**
- A very simple conversion function for all the IoC style setup and
- reflection that we are doing.
- @param value The value to convert
- @param paramType The type to convert to. Currently ony primitive types and
- String are supported.
- @return The converted object.
  */
  public static Object simpleConvert(String value, Class paramType)
  {
  if (paramType == String.class)
  {
  return value;
  }
  if (paramType == Character.class || paramType == Character.TYPE)
  {
  if (value.length() == 1)
  {
  return new Character(value.charAt(0));
  }
  else
  {
  throw new IllegalArgumentException("Can't more than one character in string - can't convert to char: '" + value + "'");
  }
  }
  String trimValue = value.trim();
  if (paramType == Boolean.class)
  {
  if (trimValue.length() == 0)
  {
  return null;
  }
```
return Boolean.valueOf(trimValue);
```
  }
  if (paramType == Boolean.TYPE)
  {
  return Boolean.valueOf(trimValue);
  }
  if (paramType == Integer.class)
  {
  if (trimValue.length() == 0)
  {
  return null;
  }
```
return Integer.valueOf(trimValue);
```
  }
  if (paramType == Integer.TYPE)
  {
  if (trimValue.length() == 0)
  {
  return new Integer(0);
  }
```
return Integer.valueOf(trimValue);
```
  }
  if (paramType == Short.class)
  {
  if (trimValue.length() == 0)
  {
  return null;
  }
```
return Short.valueOf(trimValue);
```
  }
  if (paramType == Short.TYPE)
  {
  if (trimValue.length() == 0)
  {
  return new Short((short) 0);
  }
```
return Short.valueOf(trimValue);
```
  }
  if (paramType == Byte.class)
  {
  if (trimValue.length() == 0)
  {
  return null;
  }
```
return Byte.valueOf(trimValue);
```
  }
  if (paramType == Byte.TYPE)
  {
  if (trimValue.length() == 0)
  {
  return new Byte((byte) 0);
  }
```
return Byte.valueOf(trimValue);
```
  }
  if (paramType == Long.class)
  {
  if (trimValue.length() == 0)
  {
  return null;
  }
```
return Long.valueOf(trimValue);
```
  }
  if (paramType == Long.TYPE)
  {
  if (trimValue.length() == 0)
  {
  return new Long(0);
  }
```
return Long.valueOf(trimValue);
```
  }
  if (paramType == Float.class)
  {
  if (trimValue.length() == 0)
  {
  return null;
  }
```
return Float.valueOf(trimValue);
```
  }
  if (paramType == Float.TYPE)
  {
  if (trimValue.length() == 0)
  {
  return new Float(0);
  }
```
return Float.valueOf(trimValue);
```
  }
  if (paramType == Double.class)
  {
  if (trimValue.length() == 0)
  {
  return null;
  }
```
return Double.valueOf(trimValue);
```
  }
  if (paramType == Double.TYPE)
  {
  if (trimValue.length() == 0)
  {
  return new Double(0);
  }
```
return Double.valueOf(trimValue);
```
  }
  throw new IllegalArgumentException("Unsupported conversion type: " + paramType.getName());
  }
/**
- 得到除去包名的类名。
- Get the short class name (i.e. without the package part)
- @param clazz the class to get the short name of
- @return the class name of the class without the package name
  */
  public static String getShortClassName(Class clazz)
  {
  String className = clazz.getName();
  char[] chars = className.toCharArray();
  int lastDot = 0;
  for (int i = 0; i < chars.length; i++)
  {
  if (chars[i] == '.')
  {
  lastDot = i + 1;
  }
  else if (chars[i] == '$')
  {
  chars[i] = '.';
  }
  }
  // This might come up in scans for locale/charset issues. It's not an
  // issue since we are talking about chars.
  return new String(chars, lastDot, chars.length - lastDot);
  }
/**
- Is this object property one that we can use in a JSON style or do we need
- to get fancy. i.e does it contain only letters and numbers with an
- initial letter.
- @param name The name to test for JSON compatibility
- @return true if the name is simple
  */
  public static boolean isSimpleName(String name)
  {
  if (name.length() == 0)
  {
  return false;
  }
  if (JavascriptUtil.isReservedWord(name))
  {
  return false;
  }
  boolean isSimple = Character.isLetter(name.charAt(0));
  for (int i = 1; isSimple && i < name.length(); i++)
  {
  if (!Character.isLetterOrDigit(name.charAt(i)))
  {
  isSimple = false;
  }
  }
  return isSimple;
  }
/**
- Utility to essentially do Class forName and allow configurable
- Classloaders.
- The initial implementation makes use of the context classloader for
- the current thread.
- @param className The class to create
- @return The class if it is safe or null otherwise.
- @throws ClassNotFoundException If className is not valid */ public static Class classForName(String className) throws ClassNotFoundException { // Class.forName(className); return Thread.currentThread().getContextClassLoader().loadClass(className); }
/**
- Calling methods using reflection is useful for graceful fallback - this
- is a helper method to make this easy
- @param object The object to use as 'this'
- @param method The method to call, can be null in which case null is returned
- @param params The parameters to pass to the reflection call
- @return The results of calling method.invoke() or null
- @throws IllegalStateException If anything goes wrong
  */
  public static Object invoke(Object object, Method method, Object[] params) throws IllegalStateException
  {
  Object reply = null;
  if (method != null)
  {
  try
  {
  reply = method.invoke(object, params);
  }
  catch (InvocationTargetException ex)
  {
  throw new IllegalStateException("InvocationTargetException calling " + method.getName() + ": " + ex.getTargetException().toString());
  }
  catch (Exception ex)
  {
  throw new IllegalStateException("Reflection error calling " + method.getName() + ": " + ex.toString());
  }
  }
  return reply;
  }
/**
- Utility to essentially do Class forName with the assumption that the
- environment expects failures for missing jar files and can carry on if
- this process fails.
- @param name The name for debugging purposes
- @param className The class to create
- @param impl The implementation class - what should className do?
- @return The class if it is safe or null otherwise.
  */
  public static Class classForName(String name, String className, Class impl)
  {
  Class clazz;
  try
  {
  clazz = classForName(className);
  }
  catch (ClassNotFoundException ex)
  {
  // We expect this sometimes, hence debug
  log.debug("Skipping '" + name + "' due to ClassNotFoundException on " + className + ". Cause: " + ex.getMessage());
  return null;
  }
  catch (NoClassDefFoundError ex)
  {
  // We expect this sometimes, hence debug
  log.debug("Skipping '" + name + "' due to NoClassDefFoundError on " + className + ". Cause: " + ex.getMessage());
  return null;
  }
  catch (TransformerFactoryConfigurationError ex)
  {
  // We expect this sometimes, hence debug
  log.debug("Skipping '" + name + "' due to TransformerFactoryConfigurationError on " + className + ". Cause: " + ex.getMessage());
  log.debug("Maybe you need to add xalan.jar to your webserver?");
  return null;
  }
  // Check it is of the right type
  if (!impl.isAssignableFrom(clazz))
  {
  log.error("Class '" + clazz.getName() + "' does not implement '" + impl.getName() + "'.");
  return null;
  }
  // Check we can create it
  try
  {
  clazz.newInstance();
  }
  catch (InstantiationException ex)
  {
  log.error("InstantiationException for '" + name + "' failed:", ex);
  return null;
  }
  catch (IllegalAccessException ex)
  {
  log.error("IllegalAccessException for '" + name + "' failed:", ex);
  return null;
  }
  catch (NoClassDefFoundError ex)
  {
  // We expect this sometimes, hence debug
  log.debug("Skipping '" + name + "' due to NoClassDefFoundError on " + className + ". Cause: " + ex.getMessage());
  return null;
  }
  catch (TransformerFactoryConfigurationError ex)
  {
  // We expect this sometimes, hence debug
  log.debug("Skipping '" + name + "' due to TransformerFactoryConfigurationError on " + className + ". Cause: " + ex.getMessage());
  log.debug("Maybe you need to add xalan.jar to your webserver?");
  return null;
  }
  catch (Exception ex)
  {
  // For some reason we can't catch this?
  if (ex instanceof ClassNotFoundException)
  {
  // We expect this sometimes, hence debug
  log.debug("Skipping '" + name + "' due to ClassNotFoundException on " + className + ". Cause: " + ex.getMessage());
  return null;
  }
  else
  {
  log.error("Failed to load '" + name + "' (" + className + ")", ex);
  return null;
  }
  }
  return clazz;
  }
/**
- Utility to essentially do Class forName and newInstance with the
- assumption that the environment expects failures for missing jar files
- and can carry on if this process fails.
- @param name The name for debugging purposes
- @param className The class to create
- @param impl The implementation class - what should className do?
- @return The new instance if it is safe or null otherwise.
  */
  public static Object classNewInstance(String name, String className, Class impl)
  {
  Class clazz;
  try
  {
  clazz = LocalUtil.classForName(className);
  }
  catch (ClassNotFoundException ex)
  {
  // We expect this sometimes, hence debug
  log.debug("Skipping '" + name + "' due to ClassNotFoundException on " + className + ". Cause: " + ex.getMessage());
  return null;
  }
  catch (NoClassDefFoundError ex)
  {
  // We expect this sometimes, hence debug
  log.debug("Skipping '" + name + "' due to NoClassDefFoundError on " + className + ". Cause: " + ex.getMessage());
  return null;
  }
  catch (TransformerFactoryConfigurationError ex)
  {
  // We expect this sometimes, hence debug
  log.debug("Skipping '" + name + "' due to TransformerFactoryConfigurationError on " + className + ". Cause: " + ex.getMessage());
  return null;
  }
  // Check it is of the right type
  if (!impl.isAssignableFrom(clazz))
  {
  log.error("Class '" + clazz.getName() + "' does not implement '" + impl.getName() + "'.");
  return null;
  }
  // Check we can create it
  try
  {
  return clazz.newInstance();
  }
  catch (InstantiationException ex)
  {
  log.error("InstantiationException for '" + name + "' failed:", ex);
  return null;
  }
  catch (IllegalAccessException ex)
  {
  log.error("IllegalAccessException for '" + name + "' failed:", ex);
  return null;
  }
  catch (TransformerFactoryConfigurationError ex)
  {
  log.error("TransformerFactoryConfigurationError for '" + name + "' failed:", ex);
  return null;
  }
  catch (Exception ex)
  {
  log.error("Failed to load creator '" + name + "', classname=" + className + ": ", ex);
  return null;
  }
  }
/**
- InputStream closer that can cope if the input stream is null.
- If anything goes wrong, the errors are logged and ignored.
- @param in The resource to close
  */
  public static void close(InputStream in)
  {
  if (in == null)
  {
  return;
  }
  try
  {
  in.close();
  }
  catch (IOException ex)
  {
  log.warn(ex.getMessage(), ex);
  }
  }
/**
- InputStream closer that can cope if the input stream is null.
- If anything goes wrong, the errors are logged and ignored.
- @param in The resource to close
  */
  public static void close(Reader in)
  {
  if (in == null)
  {
  return;
  }
  try
  {
  in.close();
  }
  catch (IOException ex)
  {
  log.warn(ex.getMessage(), ex);
  }
  }
/**
- InputStream closer that can cope if the input stream is null.
- If anything goes wrong, the errors are logged and ignored.
- @param in The resource to close
  */
  public static void close(RandomAccessFile in)
  {
  if (in == null)
  {
  return;
  }
  try
  {
  in.close();
  }
  catch (IOException ex)
  {
  log.warn(ex.getMessage(), ex);
  }
  }
/**
- Return a List of superclasses for the given class.
- @param clazz the class to look up
- @return the List of superclasses in order going up from this one
  */
  public static List getAllSuperclasses(Class clazz)
  {
  List classes = new ArrayList();
  Class superclass = clazz.getSuperclass();
  while (superclass != null)
  {
  classes.add(superclass);
  superclass = superclass.getSuperclass();
  }
  return classes;
  }
/**
- Return a list of all fields (whatever access status, and on whatever
- superclass they were defined) that can be found on this class.
- This is like a union of {@link Class#getDeclaredFields()} which
- ignores and superclasses, and {@link Class#getFields()} which ignored
- non-pubic fields
- @param clazz The class to introspect
- @return The complete list of fields */ public static Field[] getAllFields(Class clazz) { List classes = getAllSuperclasses(clazz); classes.add(clazz); return getAllFields(classes); }
/**
- As {@link #getAllFields(Class)} but acts on a list of {@link Class}s and
- uses only {@link Class#getDeclaredFields()}.
- @param classes The list of classes to reflect on
- @return The complete list of fields
  */
  private static Field[] getAllFields(List classes)
  {
  Set fields = new HashSet();
  for (Iterator it = classes.iterator(); it.hasNext();)
  {
  Class clazz = (Class) it.next();
  fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
  }
  return (Field[]) fields.toArray(new Field[fields.size()]);
  }
/**
- The log stream */ private static final Logger log = Logger.getLogger(LocalUtil.class);
/**
- Have we given a warning about URLDecoder.decode() in jdk 1.3 */ private static boolean warn13 = false;
/**
- Have we tested for the correct URLDecoder.decode() */ private static boolean testedDecoder = false;
/**
- Are we using the jdk 1.4 version of URLDecoder.decode() */ private static Method decode14 = null; }

[/code]

自己写吧LZ

让人写程序，一个程序给1分。 :D

还是自己写的好。

太吝啬了吧！！！ :o :o :o