Lang (Nutz 1.r.57 API)

java.lang.Object
- org.nutz.lang.Lang

```
public abstract class Lang
extends Object
```
这些帮助函数让 Java 的某些常用功能变得更简单

作者:

zozoh(zozohtnt@gmail.com), wendal(wendal1985@gmail.com), bonyfish(mc02cxj@gmail.com)

字段概要

字段
限定符和类型字段和说明

static int HASH_BUFF_SIZE

static boolean isAndroid
当前运行的 Java 虚拟机是否是在安卓环境

字段
限定符和类型	字段和说明
`static int`	`HASH_BUFF_SIZE`
`static boolean`	`isAndroid` 当前运行的 Java 虚拟机是否是在安卓环境

构造器概要

构造器
构造器和说明

Lang()

构造器
构造器和说明
`Lang()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static <T> T[]`	`array(T... eles)` 较方便的创建一个数组，比如： String[] strs = Lang.array("A", "B", "A"); => ["A","B","A"]
`static Object`	`array2array(Object array, Class<?> eleType)` 将数组转换成另外一种类型的数组。
`static <T,E> List<E>`	`array2list(Object array, Class<E> eleType)` 将数组转换成一个列表。
`static <T> List<T>`	`array2list(T[] array)` 将数组转换成一个列表。
`static <T extends Map<Object,Object>> T`	`array2map(Class<T> mapClass, Object array, String keyFieldName)` 将一个数组变成 Map
`static <T> Object[]`	`array2ObjectArray(T[] args, Class<?>[] pts)` 将数组转换成Object[] 数组。
`static <T> T[]`	`arrayFirst(T e, T[] eles)` 将一个对象添加成为一个数组的第一个元素，从而生成一个新的数组
`static <T> T[]`	`arrayLast(T[] eles, T e)` 将一个对象添加成为一个数组的最后一个元素，从而生成一个新的数组
`static <T> T[]`	`arrayUniq(T... eles)` 较方便的创建一个没有重复的数组，比如： String[] strs = Lang.arrayUniq("A","B","A"); => ["A","B"] String[] strs = Lang.arrayUniq(); => null 返回的顺序会遵循输入的顺序
`static void`	`Break()` 打断 each 循环
`static <E> E[]`	`collection2array(Collection<?> col, Class<E> eleType)` 将集合变成指定类型的数组
`static <E> E[]`	`collection2array(Collection<E> coll)` 将集合变成数组，数组的类型为集合的第一个元素的类型。
`static <E> List<E>`	`collection2list(Collection<?> col, Class<E> eleType)` 将集合编程变成指定类型的列表
`static <E> List<E>`	`collection2list(Collection<E> col)` 将集合变成 ArrayList
`static <T extends Map<Object,Object>> T`	`collection2map(Class<T> mapClass, Collection<?> coll, String keyFieldName)` 将一个集合变成 Map。
`static ComboException`	`comboThrow(Throwable... es)`
`static <T> StringBuilder`	`concat(int offset, int len, Object c, T[] objs)` 将一个数组的部分元素转换成字符串每个元素之间，都会用一个给定的字符分隔
`static <T> StringBuilder`	`concat(int offset, int len, T[] array)` 将一个数组部分元素拼合成一个字符串
`static <T> StringBuilder`	`concat(Object c, Collection<T> coll)` 将一个集合转换成字符串每个元素之间，都会用一个给定的字符分隔
`static StringBuilder`	`concat(Object c, int[] vals)` 将一个整型数组转换成字符串每个元素之间，都会用一个给定的字符分隔
`static <T> StringBuilder`	`concat(Object c, Iterator<T> it)` 将一个迭代器转换成字符串每个元素之间，都会用一个给定的字符分隔
`static StringBuilder`	`concat(Object c, long[] vals)` 将一个长整型数组转换成字符串每个元素之间，都会用一个给定的字符分隔
`static <T> StringBuilder`	`concat(Object c, T[] objs)` 将一个数组转换成字符串每个元素之间，都会用一个给定的字符分隔
`static <T> StringBuilder`	`concat(T[] objs)` 将一个数组所有元素拼合成一个字符串
`static <T> StringBuilder`	`concatBy(String ptn, Object c, T[] objs)` 将一个数组转换成字符串所有的元素都被格式化字符串包裹。
`static <T> StringBuilder`	`concatBy(String fmt, T[] objs)` 将一个数组转换成字符串所有的元素都被格式化字符串包裹。
`static <T> boolean`	`contains(T[] array, T ele)` 判断一个数组内是否包括某一个对象。
`static Context`	`context()` 创建一个新的上下文对象
`static Context`	`context(Map<String,Object> map)` 根据一个 Map 包裹成一个上下文对象
`static Context`	`context(String str)` 根据一段 JSON 字符串，生产一个新的上下文对象
`static Context`	`contextf(String fmt, Object... args)` 根据一段 JSON 字符串，生产一个新的上下文对象
`static void`	`Continue()` 继续 each 循环，如果再递归，则停止递归
`static void`	`convertMapKey(Object obj, MapKeyConvertor mkc, boolean recur)` 将一个 Map 所有的键都按照回调进行修改本函数遇到数组或者集合，会自动处理每个元素
`static <T> T`	`copyProperties(Object origin, T target)`
`static <T> T`	`copyProperties(Object origin, T target, String active, String lock, boolean ignoreNull, boolean ignoreStatic)`
`static String`	`digest(String algorithm, byte[] bytes, byte[] salt, int iterations)` 从字节数组计算出数字签名
`static String`	`digest(String algorithm, CharSequence cs)` 从字符串计算出数字签名
`static String`	`digest(String algorithm, File f)` 从数据文件计算出数字签名
`static String`	`digest(String algorithm, InputStream ins)` 从流计算出数字签名，计算完毕流会被关闭
`static <T> void`	`each(Object obj, boolean loopMap, Each<T> callback)` 用回调的方式，遍历一个对象，可以支持遍历数组集合 Map 单一元素
`static <T> void`	`each(Object obj, Each<T> callback)` 用回调的方式，遍历一个对象，可以支持遍历数组集合 Map 单一元素
`static <T extends Collection<E>,E> T`	`enum2collection(Enumeration<E> enums, T cols)` 将枚举对象，变成集合
`static <T> Enumeration<T>`	`enumeration(Collection<T> col)` 返回一个集合对象的枚举对象。
`static boolean`	`equals(Object a0, Object a1)` 判断两个对象是否相等。
`static StringBuilder`	`execOutput(String[] cmd, Charset charset)`
`static StringBuilder`	`execOutput(String cmd, Charset charset)`
`static <C extends Collection<T>,T> C`	`fill(C coll, T[]... objss)` 将一个或者多个数组填入一个集合。
`static Map<String,Object>`	`filter(Map<String,Object> source, String prefix, String include, String exclude, Map<String,String> keyMap)` map对象浅过滤,返回值是一个新的map
`static <T> T`	`first(Collection<T> coll)` 获取集合中的第一个元素，如果集合为空，返回 null
`static <K,V> Map.Entry<K,V>`	`first(Map<K,V> map)` 获得表中的第一个名值对
`static Object`	`first(Object obj)` 如果是数组或集合取得第一个对象。
`static String`	`fixedHexString(byte[] hashBytes)`
`static <T> Class<T>`	`forName(String name, Class<T> type)` 强制从字符串转换成一个 Class，将 ClassNotFoundException 包裹成 RuntimeException
`static <T> T`	`get(T[] array, int index)` 安全的从一个数组获取一个元素，容忍 null 数组，以及支持负数的 index 如果该下标越界，则返回 null
`static Type`	`getFieldType(Mirror<?> me, Field field)` 当一个类使用来定义泛型时,本方法返回类的一个字段的具体类型。
`static Type`	`getFieldType(Mirror<?> me, String field)` 当一个类使用来定义泛型时,本方法返回类的一个字段的具体类型。
`static Type`	`getGenericsType(Mirror<?> me, Type type)` 当一个类使用来定义泛型时,本方法返回类的一个字段的具体类型。
`static Type[]`	`getGenericsTypes(Type type)` 返回一个 Type 的泛型数组, 如果没有, 则直接返回null
`static String`	`getIP(javax.servlet.http.HttpServletRequest request)` 获得访问者的IP地址, 反向代理过的也可以获得
`static Type[]`	`getMethodParamTypes(Mirror<?> me, Method method)` 当一个类使用来定义泛型时, 本方法返回类的一个方法所有参数的具体类型
`static Object`	`getPrimitiveDefaultValue(Class<?> pClass)` 获取基本类型的默认值
`static String`	`getStackTrace(Throwable e)` 将一个抛出对象的异常堆栈，显示成一个字符串
`static Class<?>`	`getTypeClass(Type type)` 获取一个 Type 类型实际对应的Class
`static RuntimeException`	`impossible()` 生成一个不可能的运行时异常
`static Reader`	`inr(CharSequence cs)` 根据一段文本模拟出一个文本输入流对象
`static InputStream`	`ins(CharSequence cs)` 根据一段文本模拟出一个输入流对象
`static boolean`	`isCauseBy(Throwable e, Class<? extends Throwable> causeType)`
`static boolean`	`isEmpty(Object obj)` 判断一个对象是否为空。
`static <T> boolean`	`isEmptyArray(T[] ary)` 判断一个数组是否是空数组
`static boolean`	`isJDK6()` 当前运行的 Java 虚拟机是 JDK6 的话，则返回 true
`static boolean`	`isWin()` 判断当前系统是否为Windows
`static int`	`length(Object obj)` 获得一个对象的长度。
`static <T> ArrayList<T>`	`list(T... eles)` 较方便的创建一个列表，比如： List<Pet> pets = Lang.list(pet1, pet2, pet3); 注，这里的 List，是 ArrayList 的实例
`static List<Object>`	`list4(String str)` 根据一段字符串，生成一个List 对象。
`static Class<?>`	`loadClass(String className)` 使用当前线程的ClassLoader加载给定的类
`static Class<?>`	`loadClassQuite(String className)`
`static <T extends Throwable> T`	`makeThrow(Class<T> classOfT, String format, Object... args)` 根据格式化字符串，生成一个指定的异常。
`static RuntimeException`	`makeThrow(String format, Object... args)` 根据格式化字符串，生成运行时异常
`static NutMap`	`map(String str)` 根据一段字符串，生成一个 Map 对象。
`static NutMap`	`map(String key, Object v)` 创建一个一个键的 Map 对象
`static <T> T`	`map2Object(Map<?,?> src, Class<T> toType)` 根据一个 Map，和给定的对象类型，创建一个新的 JAVA 对象
`static NutMap`	`mapf(String fmt, Object... args)` 根据一个格式化字符串，生成 Map 对象
`static String`	`md5(CharSequence cs)` 获取指定字符串的 MD5 值
`static String`	`md5(File f)` 获取指定文件的 MD5 值
`static String`	`md5(InputStream ins)` 获取指定输入流的 MD5 值
`static <T> T[]`	`merge(T[]... arys)` 将多个数组，合并成一个数组。
`static RuntimeException`	`noImplement()` 生成一个未实现的运行时异常
`static void`	`notifyAll(Object lock)` 通知对象的同步锁
`static Map<String,Object>`	`obj2map(Object obj)` 将对象转换成 Map
`static <T extends Map<String,Object>> T`	`obj2map(Object obj, Class<T> mapType)` 将对象转换成 Map
`static NutMap`	`obj2nutmap(Object obj)` 将对象转为 Nutz 的标准 Map 封装
`static StringOutputStream`	`ops(StringBuilder sb)` 根据一个 StringBuilder 模拟一个输出流对象
`static Writer`	`opw(StringBuilder sb)` 根据一个 StringBuilder 模拟一个文本输出流对象
`static boolean`	`parseBoolean(String s)` 将字符串解析成 boolean 值，支持更多的字符串 1 \| 0 yes \| no on \| off true \| false
`static void`	`quiteSleep(long millisecond)` 对Thread.sleep(long)的简单封装,不抛出任何异常
`static String`	`readAll(Reader reader)` 从一个文本输入流读取所有内容，并将该流关闭
`static <T> void`	`reverse(T[] arrays)` 将指定的数组的内容倒序排序。
`static void`	`runInAnThread(Runnable runnable)`
`static String`	`runRootPath()`
`static <T> Set<T>`	`set(T... eles)` 创建一个 Hash 集合
`static String`	`sha1(CharSequence cs)` 获取指定字符串的 SHA1 值
`static String`	`sha1(File f)` 获取指定文件的 SHA1 值
`static String`	`sha1(InputStream ins)` 获取指定输入流的 SHA1 值
`static String`	`simpleMetodDesc(Method method)`
`static void`	`sleep(long ms)` 一个便利的方法，将当前线程睡眠一段时间
`static Number`	`str2number(String s)` 将字符串，变成数字对象，现支持的格式为： null - 整数 0 23.78 - 浮点 Float 0x45 - 16进制整数 Integer 78L - 长整数 Long 69 - 普通整数 Integer
`static byte[]`	`toBytes(char[] cs)` 将字符数组强制转换成字节数组。
`static byte[]`	`toBytes(int[] is)` 将整数数组强制转换成字节数组。
`static Throwable`	`unwrapThrow(Throwable e)`
`static void`	`wait(Object lock, long ms)` 一个便利的等待方法同步一个对象
`static <T> T[]`	`without(T[] objs, T val)` 清除数组中的特定值
`static RuntimeException`	`wrapThrow(Throwable e)` 用运行时异常包裹抛出对象，如果抛出对象本身就是运行时异常，则直接返回。
`static <T extends Throwable> T`	`wrapThrow(Throwable e, Class<T> wrapper)` 用一个指定可抛出类型来包裹一个抛出对象。
`static RuntimeException`	`wrapThrow(Throwable e, String fmt, Object... args)` 将抛出对象包裹成运行时异常，并增加自己的描述
`static void`	`writeAll(Writer writer, String str)` 将一段字符串写入一个文本输出流，并将该流关闭
`static DocumentBuilder`	`xmls()` 帮你快速获得一个 DocumentBuilder，方便 XML 解析。

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - HASH_BUFF_SIZE
```
public static int HASH_BUFF_SIZE
```
  - isAndroid
```
public static final boolean isAndroid
```
    当前运行的 Java 虚拟机是否是在安卓环境
- 构造器详细资料
  - Lang
```
public Lang()
```
- 方法详细资料
  - comboThrow
```
public static ComboException comboThrow(Throwable... es)
```
  - noImplement
```
public static RuntimeException noImplement()
```
    生成一个未实现的运行时异常
    
    返回:
    
    一个未实现的运行时异常
  - impossible
```
public static RuntimeException impossible()
```
    生成一个不可能的运行时异常
    
    返回:
    
    一个不可能的运行时异常
  - makeThrow
```
public static RuntimeException makeThrow(String format,
                                         Object... args)
```
    根据格式化字符串，生成运行时异常
    
    参数:
    
    format - 格式
    
    args - 参数
    
    返回:
    
    运行时异常
  - makeThrow
```
public static <T extends Throwable> T makeThrow(Class<T> classOfT,
                                                String format,
                                                Object... args)
```
    根据格式化字符串，生成一个指定的异常。
    
    参数:
    
    classOfT - 异常类型，需要有一个字符串为参数的构造函数
    
    format - 格式
    
    args - 参数
    
    返回:
    
    异常对象
  - wrapThrow
```
public static RuntimeException wrapThrow(Throwable e,
                                         String fmt,
                                         Object... args)
```
    将抛出对象包裹成运行时异常，并增加自己的描述
    
    参数:
    
    e - 抛出对象
    
    fmt - 格式
    
    args - 参数
    
    返回:
    
    运行时异常
  - wrapThrow
```
public static RuntimeException wrapThrow(Throwable e)
```
    用运行时异常包裹抛出对象，如果抛出对象本身就是运行时异常，则直接返回。
    如果是 InvocationTargetException，那么将其剥离，只包裹其 TargetException
    
    参数:
    
    e - 抛出对象
    
    返回:
    
    运行时异常
  - wrapThrow
```
public static <T extends Throwable> T wrapThrow(Throwable e,
                                                Class<T> wrapper)
```
    用一个指定可抛出类型来包裹一个抛出对象。这个指定的可抛出类型需要有一个构造函数接受 Throwable 类型的对象
    
    参数:
    
    e - 抛出对象
    
    wrapper - 包裹类型
    
    返回:
    
    包裹后对象
  - unwrapThrow
```
public static Throwable unwrapThrow(Throwable e)
```
  - isCauseBy
```
public static boolean isCauseBy(Throwable e,
                                Class<? extends Throwable> causeType)
```
  - equals
```
public static boolean equals(Object a0,
                             Object a1)
```
    判断两个对象是否相等。这个函数用处是:
    - 可以容忍 null
    - 可以容忍不同类型的 Number
    - 对数组，集合， Map 会深层比较
    当然，如果你重写的 equals 方法会优先
    参数:
    
    a0 - 比较对象1
    
    a1 - 比较对象2
    
    返回:
    
    是否相等
  - contains
```
public static <T> boolean contains(T[] array,
                                   T ele)
```
    判断一个数组内是否包括某一个对象。它的比较将通过 equals(Object,Object) 方法
    
    参数:
    
    array - 数组
    
    ele - 对象
    
    返回:
    
    true 包含 false 不包含
  - readAll
```
public static String readAll(Reader reader)
```
    从一个文本输入流读取所有内容，并将该流关闭
    
    参数:
    
    reader - 文本输入流
    
    返回:
    
    输入流所有内容
  - writeAll
```
public static void writeAll(Writer writer,
                            String str)
```
    将一段字符串写入一个文本输出流，并将该流关闭
    
    参数:
    
    writer - 文本输出流
    
    str - 字符串
  - ins
```
public static InputStream ins(CharSequence cs)
```
    根据一段文本模拟出一个输入流对象
    
    参数:
    
    cs - 文本
    
    返回:
    
    输出流对象
  - inr
```
public static Reader inr(CharSequence cs)
```
    根据一段文本模拟出一个文本输入流对象
    
    参数:
    
    cs - 文本
    
    返回:
    
    文本输出流对象
  - opw
```
public static Writer opw(StringBuilder sb)
```
    根据一个 StringBuilder 模拟一个文本输出流对象
    
    参数:
    
    sb - StringBuilder 对象
    
    返回:
    
    文本输出流对象
  - ops
```
public static StringOutputStream ops(StringBuilder sb)
```
    根据一个 StringBuilder 模拟一个输出流对象
    
    参数:
    
    sb - StringBuilder 对象
    
    返回:
    
    输出流对象
  - array
```
public static <T> T[] array(T... eles)
```
    较方便的创建一个数组，比如：
```
 String[] strs = Lang.array("A", "B", "A"); => ["A","B","A"]
 
```
    参数:
    
    eles - 可变参数
    
    返回:
    
    数组对象
  - arrayUniq
```
public static <T> T[] arrayUniq(T... eles)
```
    较方便的创建一个没有重复的数组，比如：
```
 String[] strs = Lang.arrayUniq("A","B","A");  => ["A","B"]
 String[] strs = Lang.arrayUniq();  => null
 
```
    返回的顺序会遵循输入的顺序
    参数:
    
    eles - 可变参数
    
    返回:
    
    数组对象
  - isEmpty
```
public static boolean isEmpty(Object obj)
```
    判断一个对象是否为空。它支持如下对象类型：
    - null : 一定为空
    - 数组
    - 集合
    - Map
    - 其他对象 : 一定不为空
    参数:
    
    obj - 任意对象
    
    返回:
    
    是否为空
  - isEmptyArray
```
public static <T> boolean isEmptyArray(T[] ary)
```
    判断一个数组是否是空数组
    
    参数:
    
    ary - 数组
    
    返回:
    
    null 或者空数组都为 true 否则为 false
  - list
```
public static <T> ArrayList<T> list(T... eles)
```
    较方便的创建一个列表，比如：
```
 List<Pet> pets = Lang.list(pet1, pet2, pet3);
 
```
    注，这里的 List，是 ArrayList 的实例
    参数:
    
    eles - 可变参数
    
    返回:
    
    列表对象
  - set
```
public static <T> Set<T> set(T... eles)
```
    创建一个 Hash 集合
    
    参数:
    
    eles - 可变参数
    
    返回:
    
    集合对象
  - merge
```
public static <T> T[] merge(T[]... arys)
```
    将多个数组，合并成一个数组。如果这些数组为空，则返回 null
    
    参数:
    
    arys - 数组对象
    
    返回:
    
    合并后的数组对象
  - arrayFirst
```
public static <T> T[] arrayFirst(T e,
                                 T[] eles)
```
    将一个对象添加成为一个数组的第一个元素，从而生成一个新的数组
    
    参数:
    
    e - 对象
    
    eles - 数组
    
    返回:
    
    新数组
  - arrayLast
```
public static <T> T[] arrayLast(T[] eles,
                                T e)
```
    将一个对象添加成为一个数组的最后一个元素，从而生成一个新的数组
    
    参数:
    
    e - 对象
    
    eles - 数组
    
    返回:
    
    新数组
  - concatBy
```
public static <T> StringBuilder concatBy(String fmt,
                                         T[] objs)
```
    将一个数组转换成字符串
    所有的元素都被格式化字符串包裹。这个格式话字符串只能有一个占位符， %s, %d 等，均可，请视你的数组内容而定
    
    参数:
    
    fmt - 格式
    
    objs - 数组
    
    返回:
    
    拼合后的字符串
  - concatBy
```
public static <T> StringBuilder concatBy(String ptn,
                                         Object c,
                                         T[] objs)
```
    将一个数组转换成字符串
    所有的元素都被格式化字符串包裹。这个格式话字符串只能有一个占位符， %s, %d 等，均可，请视你的数组内容而定
    每个元素之间，都会用一个给定的字符分隔
    
    参数:
    
    ptn - 格式
    
    c - 分隔符
    
    objs - 数组
    
    返回:
    
    拼合后的字符串
  - concat
```
public static <T> StringBuilder concat(Object c,
                                       T[] objs)
```
    将一个数组转换成字符串
    每个元素之间，都会用一个给定的字符分隔
    
    参数:
    
    c - 分隔符
    
    objs - 数组
    
    返回:
    
    拼合后的字符串
  - without
```
public static <T> T[] without(T[] objs,
                              T val)
```
    清除数组中的特定值
    
    参数:
    
    objs - 数组
    
    val - 值，可以是 null，如果是对象，则会用 equals 来比较
    
    返回:
    
    新的数组实例
  - concat
```
public static StringBuilder concat(Object c,
                                   long[] vals)
```
    将一个长整型数组转换成字符串
    每个元素之间，都会用一个给定的字符分隔
    
    参数:
    
    c - 分隔符
    
    vals - 数组
    
    返回:
    
    拼合后的字符串
  - concat
```
public static StringBuilder concat(Object c,
                                   int[] vals)
```
    将一个整型数组转换成字符串
    每个元素之间，都会用一个给定的字符分隔
    
    参数:
    
    c - 分隔符
    
    vals - 数组
    
    返回:
    
    拼合后的字符串
  - concat
```
public static <T> StringBuilder concat(int offset,
                                       int len,
                                       Object c,
                                       T[] objs)
```
    将一个数组的部分元素转换成字符串
    每个元素之间，都会用一个给定的字符分隔
    
    参数:
    
    offset - 开始元素的下标
    
    len - 元素数量
    
    c - 分隔符
    
    objs - 数组
    
    返回:
    
    拼合后的字符串
  - concat
```
public static <T> StringBuilder concat(T[] objs)
```
    将一个数组所有元素拼合成一个字符串
    
    参数:
    
    objs - 数组
    
    返回:
    
    拼合后的字符串
  - concat
```
public static <T> StringBuilder concat(int offset,
                                       int len,
                                       T[] array)
```
    将一个数组部分元素拼合成一个字符串
    
    参数:
    
    offset - 开始元素的下标
    
    len - 元素数量
    
    array - 数组
    
    返回:
    
    拼合后的字符串
  - concat
```
public static <T> StringBuilder concat(Object c,
                                       Collection<T> coll)
```
    将一个集合转换成字符串
    每个元素之间，都会用一个给定的字符分隔
    
    参数:
    
    c - 分隔符
    
    coll - 集合
    
    返回:
    
    拼合后的字符串
  - concat
```
public static <T> StringBuilder concat(Object c,
                                       Iterator<T> it)
```
    将一个迭代器转换成字符串
    每个元素之间，都会用一个给定的字符分隔
    
    参数:
    
    c - 分隔符
    
    it - 集合
    
    返回:
    
    拼合后的字符串
  - fill
```
public static <C extends Collection<T>,T> C fill(C coll,
                                                 T[]... objss)
```
    将一个或者多个数组填入一个集合。
    
    类型参数:
    
    C - 集合类型
    
    T - 数组元素类型
    
    参数:
    
    coll - 集合
    
    objss - 数组（数目可变）
    
    返回:
    
    集合对象
  - collection2map
```
public static <T extends Map<Object,Object>> T collection2map(Class<T> mapClass,
                                                              Collection<?> coll,
                                                              String keyFieldName)
```
    将一个集合变成 Map。
    
    参数:
    
    mapClass - Map 的类型
    
    coll - 集合对象
    
    keyFieldName - 采用集合中元素的哪个一个字段为键。
    
    返回:
    
    Map 对象
  - collection2list
```
public static <E> List<E> collection2list(Collection<E> col)
```
    将集合变成 ArrayList
    
    参数:
    
    col - 集合对象
    
    返回:
    
    列表对象
  - collection2list
```
public static <E> List<E> collection2list(Collection<?> col,
                                          Class<E> eleType)
```
    将集合编程变成指定类型的列表
    
    参数:
    
    col - 集合对象
    
    eleType - 列表类型
    
    返回:
    
    列表对象
  - collection2array
```
public static <E> E[] collection2array(Collection<E> coll)
```
    将集合变成数组，数组的类型为集合的第一个元素的类型。如果集合为空，则返回 null
    
    参数:
    
    coll - 集合对象
    
    返回:
    
    数组
  - collection2array
```
public static <E> E[] collection2array(Collection<?> col,
                                       Class<E> eleType)
```
    将集合变成指定类型的数组
    
    参数:
    
    col - 集合对象
    
    eleType - 数组元素类型
    
    返回:
    
    数组
  - array2map
```
public static <T extends Map<Object,Object>> T array2map(Class<T> mapClass,
                                                         Object array,
                                                         String keyFieldName)
```
    将一个数组变成 Map
    
    参数:
    
    mapClass - Map 的类型
    
    array - 数组
    
    keyFieldName - 采用集合中元素的哪个一个字段为键。
    
    返回:
    
    Map 对象
  - array2list
```
public static <T> List<T> array2list(T[] array)
```
    将数组转换成一个列表。
    
    参数:
    
    array - 原始数组
    
    返回:
    
    新列表
    
    另请参阅:
    
    Castors
  - array2list
```
public static <T,E> List<E> array2list(Object array,
                                       Class<E> eleType)
```
    将数组转换成一个列表。将会采用 Castor 来深层转换数组元素
    
    参数:
    
    array - 原始数组
    
    eleType - 新列表的元素类型
    
    返回:
    
    新列表
    
    另请参阅:
    
    Castors
  - array2array
```
public static Object array2array(Object array,
                                 Class<?> eleType)
                          throws FailToCastObjectException
```
    将数组转换成另外一种类型的数组。将会采用 Castor 来深层转换数组元素
    
    参数:
    
    array - 原始数组
    
    eleType - 新数组的元素类型
    
    返回:
    
    新数组
    
    抛出:
    
    FailToCastObjectException
    
    另请参阅:
    
    Castors
  - array2ObjectArray
```
public static <T> Object[] array2ObjectArray(T[] args,
                                             Class<?>[] pts)
                                      throws FailToCastObjectException
```
    将数组转换成Object[] 数组。将会采用 Castor 来深层转换数组元素
    
    参数:
    
    args - 原始数组
    
    pts - 新数组的元素类型
    
    返回:
    
    新数组
    
    抛出:
    
    FailToCastObjectException
    
    另请参阅:
    
    Castors
  - map2Object
```
public static <T> T map2Object(Map<?,?> src,
                               Class<T> toType)
                        throws FailToCastObjectException
```
    根据一个 Map，和给定的对象类型，创建一个新的 JAVA 对象
    
    参数:
    
    src - Map 对象
    
    toType - JAVA 对象类型
    
    返回:
    
    JAVA 对象
    
    抛出:
    
    FailToCastObjectException
  - map
```
public static NutMap map(String str)
```
    根据一段字符串，生成一个 Map 对象。
    
    参数:
    
    str - 参照 JSON 标准的字符串，但是可以没有前后的大括号
    
    返回:
    
    Map 对象
  - convertMapKey
```
public static void convertMapKey(Object obj,
                                 MapKeyConvertor mkc,
                                 boolean recur)
```
    将一个 Map 所有的键都按照回调进行修改本函数遇到数组或者集合，会自动处理每个元素
    
    参数:
    
    obj - 要转换的 Map 或者集合或者数组
    
    mkc - 键值修改的回调
    
    recur - 遇到 Map 是否递归
    
    另请参阅:
    
    MapKeyConvertor
  - map
```
public static NutMap map(String key,
                         Object v)
```
    创建一个一个键的 Map 对象
    
    参数:
    
    key - 键
    
    v - 值
    
    返回:
    
    Map 对象
  - mapf
```
public static NutMap mapf(String fmt,
                          Object... args)
```
    根据一个格式化字符串，生成 Map 对象
    
    参数:
    
    fmt - 格式化字符串
    
    args - 字符串参数
    
    返回:
    
    Map 对象
  - context
```
public static Context context()
```
    创建一个新的上下文对象
    
    返回:
    
    一个新创建的上下文对象
  - context
```
public static Context context(Map<String,Object> map)
```
    根据一个 Map 包裹成一个上下文对象
    
    参数:
    
    map - Map 对象
    
    返回:
    
    一个新创建的上下文对象
  - contextf
```
public static Context contextf(String fmt,
                               Object... args)
```
    根据一段 JSON 字符串，生产一个新的上下文对象
    
    参数:
    
    fmt - JSON 字符串模板
    
    args - 模板参数
    
    返回:
    
    一个新创建的上下文对象
  - context
```
public static Context context(String str)
```
    根据一段 JSON 字符串，生产一个新的上下文对象
    
    返回:
    
    一个新创建的上下文对象
  - list4
```
public static List<Object> list4(String str)
```
    根据一段字符串，生成一个List 对象。
    
    参数:
    
    str - 参照 JSON 标准的字符串，但是可以没有前后的中括号
    
    返回:
    
    List 对象
  - length
```
public static int length(Object obj)
```
    获得一个对象的长度。它可以接受:
    - null : 0
    - 数组
    - 集合
    - Map
    - 一般 Java 对象。返回 1
    如果你想让你的 Java 对象返回不是 1 ，请在对象中声明 length() 函数
    参数:
    
    obj -
    
    返回:
    
    对象长度
  - first
```
public static Object first(Object obj)
```
    如果是数组或集合取得第一个对象。否则返回自身
    
    参数:
    
    obj - 任意对象
    
    返回:
    
    第一个代表对象
  - first
```
public static <T> T first(Collection<T> coll)
```
    获取集合中的第一个元素，如果集合为空，返回 null
    
    参数:
    
    coll - 集合
    
    返回:
    
    第一个元素
  - first
```
public static <K,V> Map.Entry<K,V> first(Map<K,V> map)
```
    获得表中的第一个名值对
    
    参数:
    
    map - 表
    
    返回:
    
    第一个名值对
  - Break
```
public static void Break()
                  throws ExitLoop
```
    打断 each 循环
    
    抛出:
    
    ExitLoop
  - Continue
```
public static void Continue()
                     throws ExitLoop
```
    继续 each 循环，如果再递归，则停止递归
    
    抛出:
    
    ExitLoop
  - each
```
public static <T> void each(Object obj,
                            Each<T> callback)
```
    用回调的方式，遍历一个对象，可以支持遍历
    - 数组
    - 集合
    - Map
    - 单一元素
    参数:
    
    obj - 对象
    
    callback - 回调
  - each
```
public static <T> void each(Object obj,
                            boolean loopMap,
                            Each<T> callback)
```
    用回调的方式，遍历一个对象，可以支持遍历
    - 数组
    - 集合
    - Map
    - 单一元素
    参数:
    
    obj - 对象
    
    loopMap - 是否循环 Map，如果循环 Map 则主要看 callback 的 T，如果是 Map.Entry 则循环 Entry 否循环 value。如果本值为 false，则将 Map 当作一个完整的对象来看待
    
    callback - 回调
  - get
```
public static <T> T get(T[] array,
                        int index)
```
    安全的从一个数组获取一个元素，容忍 null 数组，以及支持负数的 index
    如果该下标越界，则返回 null
    
    类型参数:
    
    T -
    
    参数:
    
    array - 数组，如果为 null 则直接返回 null
    
    index - 下标，-1 表示倒数第一个， -2 表示倒数第二个，以此类推
    
    返回:
    
    数组元素
  - getStackTrace
```
public static String getStackTrace(Throwable e)
```
    将一个抛出对象的异常堆栈，显示成一个字符串
    
    参数:
    
    e - 抛出对象
    
    返回:
    
    异常堆栈文本
  - parseBoolean
```
public static boolean parseBoolean(String s)
```
    将字符串解析成 boolean 值，支持更多的字符串
    - 1 | 0
    - yes | no
    - on | off
    - true | false
    参数:
    
    s - 字符串
    
    返回:
    
    布尔值
  - xmls
```
public static DocumentBuilder xmls()
                            throws ParserConfigurationException
```
    帮你快速获得一个 DocumentBuilder，方便 XML 解析。
    
    返回:
    
    一个 DocumentBuilder 对象
    
    抛出:
    
    ParserConfigurationException
  - quiteSleep
```
public static void quiteSleep(long millisecond)
```
    对Thread.sleep(long)的简单封装,不抛出任何异常
    
    参数:
    
    millisecond - 休眠时间
  - str2number
```
public static Number str2number(String s)
```
    将字符串，变成数字对象，现支持的格式为：
    - null - 整数 0
    - 23.78 - 浮点 Float
    - 0x45 - 16进制整数 Integer
    - 78L - 长整数 Long
    - 69 - 普通整数 Integer
    参数:
    
    s - 参数
    
    返回:
    
    数字对象
  - obj2map
```
public static Map<String,Object> obj2map(Object obj)
```
    将对象转换成 Map
    
    参数:
    
    obj - POJO 对象
    
    返回:
    
    Map 对象
  - obj2nutmap
```
public static NutMap obj2nutmap(Object obj)
```
    将对象转为 Nutz 的标准 Map 封装
    
    参数:
    
    obj - POJO du对象
    
    返回:
    
    NutMap 对象
  - obj2map
```
public static <T extends Map<String,Object>> T obj2map(Object obj,
                                                       Class<T> mapType)
```
    将对象转换成 Map
    
    类型参数:
    
    T -
    
    参数:
    
    obj - POJO 对象
    
    mapType - Map 的类型
    
    返回:
    
    Map 对象
  - enumeration
```
public static <T> Enumeration<T> enumeration(Collection<T> col)
```
    返回一个集合对象的枚举对象。实际上就是对 Iterator 接口的一个封装
    
    参数:
    
    col - 集合对象
    
    返回:
    
    枚举对象
  - enum2collection
```
public static <T extends Collection<E>,E> T enum2collection(Enumeration<E> enums,
                                                            T cols)
```
    将枚举对象，变成集合
    
    参数:
    
    enums - 枚举对象
    
    cols - 集合对象
    
    返回:
    
    集合对象
  - toBytes
```
public static byte[] toBytes(char[] cs)
```
    将字符数组强制转换成字节数组。如果字符为双字节编码，则会丢失信息
    
    参数:
    
    cs - 字符数组
    
    返回:
    
    字节数组
  - toBytes
```
public static byte[] toBytes(int[] is)
```
    将整数数组强制转换成字节数组。整数的高位将会被丢失
    
    参数:
    
    is - 整数数组
    
    返回:
    
    字节数组
  - isWin
```
public static boolean isWin()
```
    判断当前系统是否为Windows
    
    返回:
    
    true 如果当前系统为Windows系统
  - loadClass
```
public static Class<?> loadClass(String className)
                          throws ClassNotFoundException
```
    使用当前线程的ClassLoader加载给定的类
    
    参数:
    
    className - 类的全称
    
    返回:
    
    给定的类
    
    抛出:
    
    ClassNotFoundException - 如果无法用当前线程的ClassLoader加载
  - isJDK6
```
public static boolean isJDK6()
```
    当前运行的 Java 虚拟机是 JDK6 的话，则返回 true
    
    返回:
    
    true 如果当前运行的 Java 虚拟机是 JDK6
  - getPrimitiveDefaultValue
```
public static Object getPrimitiveDefaultValue(Class<?> pClass)
```
    获取基本类型的默认值
    
    参数:
    
    pClass - 基本类型
    
    返回:
    
    0/false,如果传入的pClass不是基本类型的类,则返回null
  - getFieldType
```
public static Type getFieldType(Mirror<?> me,
                                String field)
                         throws NoSuchFieldException
```
    当一个类使用来定义泛型时,本方法返回类的一个字段的具体类型。
    
    参数:
    
    me -
    
    field -
    
    抛出:
    
    NoSuchFieldException
  - getMethodParamTypes
```
public static Type[] getMethodParamTypes(Mirror<?> me,
                                         Method method)
```
    当一个类使用来定义泛型时, 本方法返回类的一个方法所有参数的具体类型
    
    参数:
    
    me -
    
    method -
  - getFieldType
```
public static Type getFieldType(Mirror<?> me,
                                Field field)
```
    当一个类使用来定义泛型时,本方法返回类的一个字段的具体类型。
    
    参数:
    
    me -
    
    field -
  - getGenericsType
```
public static Type getGenericsType(Mirror<?> me,
                                   Type type)
```
    当一个类使用来定义泛型时,本方法返回类的一个字段的具体类型。
    
    参数:
    
    me -
    
    type -
  - getTypeClass
```
public static Class<?> getTypeClass(Type type)
```
    获取一个 Type 类型实际对应的Class
    
    参数:
    
    type - 类型
    
    返回:
    
    与Type类型实际对应的Class
  - getGenericsTypes
```
public static Type[] getGenericsTypes(Type type)
```
    返回一个 Type 的泛型数组, 如果没有, 则直接返回null
    
    参数:
    
    type - 类型
    
    返回:
    
    一个 Type 的泛型数组, 如果没有, 则直接返回null
  - forName
```
public static <T> Class<T> forName(String name,
                                   Class<T> type)
```
    强制从字符串转换成一个 Class，将 ClassNotFoundException 包裹成 RuntimeException
    
    类型参数:
    
    T -
    
    参数:
    
    name - 类名
    
    type - 这个类型的边界
    
    返回:
    
    类对象
  - md5
```
public static String md5(File f)
```
    获取指定文件的 MD5 值
    
    参数:
    
    f - 文件
    
    返回:
    
    指定文件的 MD5 值
    
    另请参阅:
    
    digest(String, File)
  - md5
```
public static String md5(InputStream ins)
```
    获取指定输入流的 MD5 值
    
    参数:
    
    ins - 输入流
    
    返回:
    
    指定输入流的 MD5 值
    
    另请参阅:
    
    digest(String, InputStream)
  - md5
```
public static String md5(CharSequence cs)
```
    获取指定字符串的 MD5 值
    
    参数:
    
    cs - 字符串
    
    返回:
    
    指定字符串的 MD5 值
    
    另请参阅:
    
    digest(String, CharSequence)
  - sha1
```
public static String sha1(File f)
```
    获取指定文件的 SHA1 值
    
    参数:
    
    f - 文件
    
    返回:
    
    指定文件的 SHA1 值
    
    另请参阅:
    
    digest(String, File)
  - sha1
```
public static String sha1(InputStream ins)
```
    获取指定输入流的 SHA1 值
    
    参数:
    
    ins - 输入流
    
    返回:
    
    指定输入流的 SHA1 值
    
    另请参阅:
    
    digest(String, InputStream)
  - sha1
```
public static String sha1(CharSequence cs)
```
    获取指定字符串的 SHA1 值
    
    参数:
    
    cs - 字符串
    
    返回:
    
    指定字符串的 SHA1 值
    
    另请参阅:
    
    digest(String, CharSequence)
  - digest
```
public static String digest(String algorithm,
                            File f)
```
    从数据文件计算出数字签名
    
    参数:
    
    algorithm - 算法，比如 "SHA1" 或者 "MD5" 等
    
    f - 文件
    
    返回:
    
    数字签名
  - digest
```
public static String digest(String algorithm,
                            InputStream ins)
```
    从流计算出数字签名，计算完毕流会被关闭
    
    参数:
    
    algorithm - 算法，比如 "SHA1" 或者 "MD5" 等
    
    ins - 输入流
    
    返回:
    
    数字签名
  - digest
```
public static String digest(String algorithm,
                            CharSequence cs)
```
    从字符串计算出数字签名
    
    参数:
    
    algorithm - 算法，比如 "SHA1" 或者 "MD5" 等
    
    cs - 字符串
    
    返回:
    
    数字签名
  - digest
```
public static String digest(String algorithm,
                            byte[] bytes,
                            byte[] salt,
                            int iterations)
```
    从字节数组计算出数字签名
    
    参数:
    
    algorithm - 算法，比如 "SHA1" 或者 "MD5" 等
    
    bytes - 字节数组
    
    salt - 随机字节数组
    
    iterations - 迭代次数
    
    返回:
    
    数字签名
  - reverse
```
public static <T> void reverse(T[] arrays)
```
    将指定的数组的内容倒序排序。注意，这会破坏原数组的内容
    
    参数:
    
    arrays - 指定的数组
  - simpleMetodDesc
```
public static String simpleMetodDesc(Method method)
```
  - fixedHexString
```
public static String fixedHexString(byte[] hashBytes)
```
  - sleep
```
public static void sleep(long ms)
```
    一个便利的方法，将当前线程睡眠一段时间
    
    参数:
    
    ms - 要睡眠的时间 ms
  - wait
```
public static void wait(Object lock,
                        long ms)
```
    一个便利的等待方法同步一个对象
    
    参数:
    
    lock - 锁对象
    
    ms - 要等待的时间 ms
  - notifyAll
```
public static void notifyAll(Object lock)
```
    通知对象的同步锁
    
    参数:
    
    lock - 锁对象
  - runInAnThread
```
public static void runInAnThread(Runnable runnable)
```
  - filter
```
public static Map<String,Object> filter(Map<String,Object> source,
                                        String prefix,
                                        String include,
                                        String exclude,
                                        Map<String,String> keyMap)
```
    map对象浅过滤,返回值是一个新的map
    
    参数:
    
    source - 原始的map对象
    
    prefix - 包含什么前缀,并移除前缀
    
    include - 正则表达式仅包含哪些key(如果有前缀要求,则已经移除了前缀)
    
    exclude - 正则表达式排除哪些key(如果有前缀要求,则已经移除了前缀)
    
    keyMap - 映射map, 原始key--目标key (如果有前缀要求,则已经移除了前缀)
    
    返回:
    
    经过过滤的map,与原始map不是同一个对象
  - getIP
```
public static String getIP(javax.servlet.http.HttpServletRequest request)
```
    获得访问者的IP地址, 反向代理过的也可以获得
    
    参数:
    
    request - 请求的req对象
    
    返回:
    
    来源ip
  - runRootPath
```
public static String runRootPath()
```
    返回:
    
    返回当前程序运行的根目录
  - copyProperties
```
public static <T> T copyProperties(Object origin,
                                   T target)
```
  - copyProperties
```
public static <T> T copyProperties(Object origin,
                                   T target,
                                   String active,
                                   String lock,
                                   boolean ignoreNull,
                                   boolean ignoreStatic)
```
  - execOutput
```
public static StringBuilder execOutput(String cmd,
                                       Charset charset)
                                throws IOException
```
    抛出:
    
    IOException
  - execOutput
```
public static StringBuilder execOutput(String[] cmd,
                                       Charset charset)
                                throws IOException
```
    抛出:
    
    IOException
  - loadClassQuite
```
public static Class<?> loadClassQuite(String className)
                               throws ClassNotFoundException
```
    抛出:
    
    ClassNotFoundException

类 Lang

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

HASH_BUFF_SIZE

isAndroid

构造器详细资料

Lang

方法详细资料

comboThrow

noImplement

impossible

makeThrow

makeThrow

wrapThrow

wrapThrow

wrapThrow

unwrapThrow

isCauseBy

equals

contains

readAll

writeAll

ins

inr

opw

ops

array

arrayUniq

isEmpty

isEmptyArray

list

set

merge

arrayFirst

arrayLast

concatBy

concatBy

concat

without

concat

concat

concat

concat

concat

concat

concat

fill

collection2map

collection2list

collection2list

collection2array

collection2array

array2map

array2list

array2list

array2array

array2ObjectArray

map2Object

map

convertMapKey

map

mapf

context

context

contextf

context

list4

length

first

first

first

Break

Continue

each

each

get

getStackTrace