Assert (bus-core 6.0.2 API)

java.lang.Object
- org.aoju.bus.core.lang.Assert

```
public class Assert
extends Object
```
断言断言某些对象或值是否符合规定,否则抛出异常经常用于做变量检查

Since:

JDK 1.8+

Version:

6.0.2

Author:

Kimi Liu

Constructor Summary

Constructors
Constructor and Description

Assert()

Constructors
Constructor and Description
`Assert()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`checkBetween(double value, double min, double max)` 检查值是否在指定范围内
`static int`	`checkBetween(int value, int min, int max)` 检查值是否在指定范围内
`static long`	`checkBetween(long value, long min, long max)` 检查值是否在指定范围内
`static Number`	`checkBetween(Number value, Number min, Number max)` 检查值是否在指定范围内
`static int`	`checkIndex(int index, int size)` 检查下标(数组、集合、字符串)是否符合要求，下标必须满足：
`static int`	`checkIndex(int index, int size, String errorMsgTemplate, Object... params)` 检查下标(数组、集合、字符串)是否符合要求，下标必须满足：
`static void`	`hasText(String text, String message)` 断言给定的字符串包含有效的文本内容.
`static void`	`isAssignable(Class<?> superType, Class<?> subType)` `superType.isAssignableFrom(subType)` 是否为 `true`.
`static void`	`isAssignable(Class<?> superType, Class<?> subType, String errorMsgTemplate, Object... params)` `superType.isAssignableFrom(subType)` 是否为 `true`.
`static void`	`isFalse(boolean expression)` 断言是否为假,如果为 `true` 抛出 `IllegalArgumentException` 异常 Assert.isFalse(i < 0);
`static void`	`isFalse(boolean expression, String errorMsgTemplate, Object... params)` 断言是否为假,如果为 `true` 抛出 `IllegalArgumentException` 异常 Assert.isFalse(i < 0, "The value must be greater than zero");
`static <T> T`	`isInstanceOf(Class<?> type, T obj)` 断言给定对象是否是给定类的实例 Assert.instanceOf(Foo.class, foo);
`static <T> T`	`isInstanceOf(Class<?> type, T obj, String errorMsgTemplate, Object... params)` 断言给定对象是否是给定类的实例 Assert.instanceOf(Foo.class, foo);
`static void`	`isNull(Object object)` 断言对象是否为`null` ,如果不为`null` 抛出`IllegalArgumentException` 异常 Assert.isNull(value);
`static void`	`isNull(Object object, String errorMsgTemplate, Object... params)` 断言对象是否为`null` ,如果不为`null` 抛出`IllegalArgumentException` 异常 Assert.isNull(value, "The value must be null");
`static void`	`isTrue(boolean expression)` 断言是否为真,如果为 `false` 抛出 `IllegalArgumentException` 异常 Assert.isTrue(i > 0, "The value must be greater than zero");
`static void`	`isTrue(boolean expression, String errorMsgTemplate, Object... params)` 断言是否为真,如果为 `false` 抛出 `IllegalArgumentException` 异常 Assert.isTrue(i > 0, "The value must be greater than zero");
`static <T> T[]`	`noNullElements(T[] array)` 断言给定数组是否不包含`null`元素,如果数组为空或 `null`将被认为不包含 Assert.noNullElements(array);
`static <T> T[]`	`noNullElements(T[] array, String errorMsgTemplate, Object... params)` 断言给定数组是否不包含`null`元素,如果数组为空或 `null`将被认为不包含 Assert.noNullElements(array, "The array must have non-null elements");
`static <T extends CharSequence> T`	`notBlank(T text)` 检查给定字符串是否为空白(null、空串或只包含空白符),为空抛出 `IllegalArgumentException` Assert.notBlank(name, "Name must not be blank");
`static <T extends CharSequence> T`	`notBlank(T text, String errorMsgTemplate, Object... params)` 检查给定字符串是否为空白(null、空串或只包含空白符),为空抛出 `IllegalArgumentException` Assert.notBlank(name, "Name must not be blank");
`static String`	`notContain(String textToSearch, String substring)` 断言给定字符串是否不被另一个字符串包含(既是否为子串) Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");
`static String`	`notContain(String textToSearch, String substring, String errorMsgTemplate, Object... params)` 断言给定字符串是否不被另一个字符串包含(既是否为子串) Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");
`static <T> Collection<T>`	`notEmpty(Collection<T> collection)` 断言给定集合非空 Assert.notEmpty(collection);
`static <T> Collection<T>`	`notEmpty(Collection<T> collection, String errorMsgTemplate, Object... params)` 断言给定集合非空 Assert.notEmpty(collection, "Collection must have elements");
`static <K,V> Map<K,V>`	`notEmpty(Map<K,V> map)` 断言给定Map非空 Assert.notEmpty(map, "Map must have entries");
`static <K,V> Map<K,V>`	`notEmpty(Map<K,V> map, String errorMsgTemplate, Object... params)` 断言给定Map非空 Assert.notEmpty(map, "Map must have entries");
`static Object[]`	`notEmpty(Object[] array)` 断言给定数组是否包含元素,数组必须不为 `null` 且至少包含一个元素 Assert.notEmpty(array, "The array must have elements");
`static Object[]`	`notEmpty(Object[] array, String errorMsgTemplate, Object... params)` 断言给定数组是否包含元素,数组必须不为 `null` 且至少包含一个元素 Assert.notEmpty(array, "The array must have elements");
`static <T extends CharSequence> T`	`notEmpty(T text)` 检查给定字符串是否为空,为空抛出 `IllegalArgumentException` Assert.notEmpty(name);
`static <T extends CharSequence> T`	`notEmpty(T text, String errorMsgTemplate, Object... params)` 检查给定字符串是否为空,为空抛出 `IllegalArgumentException` Assert.notEmpty(name, "Name must not be empty");
`static <T> T`	`notNull(T object)` 断言对象是否不为`null` ,如果为`null` 抛出`IllegalArgumentException` 异常 Assert.notNull(clazz);
`static <T> T`	`notNull(T object, String errorMsgTemplate, Object... params)` 断言对象是否不为`null` ,如果为`null` 抛出`IllegalArgumentException` 异常 Assert that an object is not `null` .
`static void`	`state(boolean expression)` 检查boolean表达式，当检查结果为false时抛出 `IllegalStateException`.
`static void`	`state(boolean expression, String errorMsgTemplate, Object... params)` 检查boolean表达式，当检查结果为false时抛出 `IllegalStateException`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- Assert
```
public Assert()
```

Method Detail

isTrue

public static void isTrue(boolean expression,
                          String errorMsgTemplate,
                          Object... params)
                   throws IllegalArgumentException

断言是否为真,如果为 false 抛出 IllegalArgumentException 异常

 Assert.isTrue(i > 0, "The value must be greater than zero");

Parameters:: expression - 波尔值; errorMsgTemplate - 错误抛出异常附带的消息模板,变量用{}代替; params - 参数列表
Throws:: IllegalArgumentException - if expression is false

isTrue

public static void isTrue(boolean expression)
                   throws IllegalArgumentException

断言是否为真,如果为 false 抛出 IllegalArgumentException 异常

 Assert.isTrue(i > 0, "The value must be greater than zero");

Parameters:: expression - 波尔值
Throws:: IllegalArgumentException - if expression is false

isFalse

public static void isFalse(boolean expression,
                           String errorMsgTemplate,
                           Object... params)
                    throws IllegalArgumentException

断言是否为假,如果为 true 抛出 IllegalArgumentException 异常

 Assert.isFalse(i < 0, "The value must be greater than zero");

Parameters:: expression - 波尔值; errorMsgTemplate - 错误抛出异常附带的消息模板,变量用{}代替; params - 参数列表
Throws:: IllegalArgumentException - if expression is false

isFalse
```
public static void isFalse(boolean expression)
                    throws IllegalArgumentException
```
断言是否为假,如果为 true 抛出 IllegalArgumentException 异常
```
 Assert.isFalse(i < 0);
 
```
Parameters:

expression - 波尔值

Throws:

IllegalArgumentException - if expression is false

isNull

public static void isNull(Object object,
                          String errorMsgTemplate,
                          Object... params)
                   throws IllegalArgumentException

断言对象是否为null ,如果不为null 抛出IllegalArgumentException 异常

 Assert.isNull(value, "The value must be null");

Parameters:: object - 被检查的对象; errorMsgTemplate - 消息模板,变量使用{}表示; params - 参数列表
Throws:: IllegalArgumentException - if the object is not null

isNull
```
public static void isNull(Object object)
                   throws NullPointerException
```
断言对象是否为null ,如果不为null 抛出IllegalArgumentException 异常
```
 Assert.isNull(value);
 
```
Parameters:

object - 被检查对象

Throws:

NullPointerException - if the object is not null

notNull
```
public static <T> T notNull(T object,
                            String errorMsgTemplate,
                            Object... params)
                     throws NullPointerException
```
断言对象是否不为null ,如果为null 抛出IllegalArgumentException 异常 Assert that an object is not null .
```
 Assert.notNull(clazz, "The class must not be null");
 
```
Type Parameters:

T - 被检查对象泛型类型

Parameters:

object - 被检查对象

errorMsgTemplate - 错误消息模板,变量使用{}表示

params - 参数

Returns:

被检查后的对象

Throws:

NullPointerException - if the object is null

notNull
```
public static <T> T notNull(T object)
                     throws NullPointerException
```
断言对象是否不为null ,如果为null 抛出IllegalArgumentException 异常
```
 Assert.notNull(clazz);
 
```
Type Parameters:

T - 被检查对象类型

Parameters:

object - 被检查对象

Returns:

非空对象

Throws:

NullPointerException - if the object is null

notEmpty

public static <T extends CharSequence> T notEmpty(T text,
                                                  String errorMsgTemplate,
                                                  Object... params)
                                           throws IllegalArgumentException

检查给定字符串是否为空,为空抛出 IllegalArgumentException

 Assert.notEmpty(name, "Name must not be empty");

Type Parameters:: T - 字符串类型
Parameters:: text - 被检查字符串; errorMsgTemplate - 错误消息模板，变量使用{}表示; params - 参数
Returns:: 非空字符串
Throws:: IllegalArgumentException - 被检查字符串为空

notEmpty
```
public static <T extends CharSequence> T notEmpty(T text)
                                           throws IllegalArgumentException
```
检查给定字符串是否为空,为空抛出 IllegalArgumentException
```
 Assert.notEmpty(name);
 
```
Type Parameters:

T - 字符串类型

Parameters:

text - 被检查字符串

Returns:

被检查的字符串

Throws:

IllegalArgumentException - 被检查字符串为空

notBlank

public static <T extends CharSequence> T notBlank(T text,
                                                  String errorMsgTemplate,
                                                  Object... params)
                                           throws IllegalArgumentException

检查给定字符串是否为空白(null、空串或只包含空白符),为空抛出 IllegalArgumentException

 Assert.notBlank(name, "Name must not be blank");

Type Parameters:: T - 字符串类型
Parameters:: text - 被检查字符串; errorMsgTemplate - 错误消息模板,变量使用{}表示; params - 参数
Returns:: 非空字符串
Throws:: IllegalArgumentException - 被检查字符串为空白
See Also:: StringKit.isNotBlank(CharSequence)

notBlank
```
public static <T extends CharSequence> T notBlank(T text)
                                           throws IllegalArgumentException
```
检查给定字符串是否为空白(null、空串或只包含空白符),为空抛出 IllegalArgumentException
```
 Assert.notBlank(name, "Name must not be blank");
 
```
Type Parameters:

T - 字符串类型

Parameters:

text - 被检查字符串

Returns:

非空字符串

Throws:

IllegalArgumentException - 被检查字符串为空白

notContain

public static String notContain(String textToSearch,
                                String substring,
                                String errorMsgTemplate,
                                Object... params)
                         throws IllegalArgumentException

断言给定字符串是否不被另一个字符串包含(既是否为子串)

 Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");

Parameters:: textToSearch - 被搜索的字符串; substring - 被检查的子串; errorMsgTemplate - 异常时的消息模板; params - 参数列表
Returns:: 被检查的子串
Throws:: IllegalArgumentException - 非子串抛出异常

notContain

public static String notContain(String textToSearch,
                                String substring)
                         throws IllegalArgumentException

断言给定字符串是否不被另一个字符串包含(既是否为子串)

 Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");

Parameters:: textToSearch - 被搜索的字符串; substring - 被检查的子串
Returns:: 被检查的子串
Throws:: IllegalArgumentException - 非子串抛出异常

notEmpty

public static Object[] notEmpty(Object[] array,
                                String errorMsgTemplate,
                                Object... params)
                         throws IllegalArgumentException

断言给定数组是否包含元素,数组必须不为 null 且至少包含一个元素

 Assert.notEmpty(array, "The array must have elements");

Parameters:: array - 被检查的数组; errorMsgTemplate - 异常时的消息模板; params - 参数列表
Returns:: 被检查的数组
Throws:: IllegalArgumentException - if the object array is null or has no elements

notEmpty
```
public static Object[] notEmpty(Object[] array)
                         throws IllegalArgumentException
```
断言给定数组是否包含元素,数组必须不为 null 且至少包含一个元素
```
 Assert.notEmpty(array, "The array must have elements");
 
```
Parameters:

array - 被检查的数组

Returns:

被检查的数组

Throws:

IllegalArgumentException - if the object array is null or has no elements

noNullElements

public static <T> T[] noNullElements(T[] array,
                                     String errorMsgTemplate,
                                     Object... params)
                              throws IllegalArgumentException

断言给定数组是否不包含null元素,如果数组为空或 null将被认为不包含

 Assert.noNullElements(array, "The array must have non-null elements");

Type Parameters:: T - 数组元素类型
Parameters:: array - 被检查的数组; errorMsgTemplate - 异常时的消息模板; params - 参数列表
Returns:: 被检查的数组
Throws:: IllegalArgumentException - if the object array contains a null element

noNullElements
```
public static <T> T[] noNullElements(T[] array)
                              throws IllegalArgumentException
```
断言给定数组是否不包含null元素,如果数组为空或 null将被认为不包含
```
 Assert.noNullElements(array);
 
```
Type Parameters:

T - 数组元素类型

Parameters:

array - 被检查的数组

Returns:

被检查的数组

Throws:

IllegalArgumentException - if the object array contains a null element

notEmpty

public static <T> Collection<T> notEmpty(Collection<T> collection,
                                         String errorMsgTemplate,
                                         Object... params)
                                  throws IllegalArgumentException

断言给定集合非空

 Assert.notEmpty(collection, "Collection must have elements");

Type Parameters:: T - 集合元素类型
Parameters:: collection - 被检查的集合; errorMsgTemplate - 异常时的消息模板; params - 参数列表
Returns:: 非空集合
Throws:: IllegalArgumentException - if the collection is null or has no elements

notEmpty
```
public static <T> Collection<T> notEmpty(Collection<T> collection)
                                  throws IllegalArgumentException
```
断言给定集合非空
```
 Assert.notEmpty(collection);
 
```
Type Parameters:

T - 集合元素类型

Parameters:

collection - 被检查的集合

Returns:

被检查集合

Throws:

IllegalArgumentException - if the collection is null or has no elements

notEmpty

public static <K,V> Map<K,V> notEmpty(Map<K,V> map,
                                      String errorMsgTemplate,
                                      Object... params)
                               throws IllegalArgumentException

断言给定Map非空

 Assert.notEmpty(map, "Map must have entries");

Type Parameters:: K - Key类型; V - Value类型
Parameters:: map - 被检查的Map; errorMsgTemplate - 异常时的消息模板; params - 参数列表
Returns:: 被检查的Map
Throws:: IllegalArgumentException - if the map is null or has no entries

notEmpty
```
public static <K,V> Map<K,V> notEmpty(Map<K,V> map)
                               throws IllegalArgumentException
```
断言给定Map非空
```
 Assert.notEmpty(map, "Map must have entries");
 
```
Type Parameters:

K - Key类型

V - Value类型

Parameters:

map - 被检查的Map

Returns:

被检查的Map

Throws:

IllegalArgumentException - if the map is null or has no entries

isInstanceOf
```
public static <T> T isInstanceOf(Class<?> type,
                                 T obj)
```
断言给定对象是否是给定类的实例
```
 Assert.instanceOf(Foo.class, foo);
 
```
Type Parameters:

T - 被检查对象泛型类型

Parameters:

type - 被检查对象匹配的类型

obj - 被检查对象

Returns:

被检查的对象

Throws:

IllegalArgumentException - if the object is not an instance of clazz

See Also:

Class.isInstance(Object)

isInstanceOf

public static <T> T isInstanceOf(Class<?> type,
                                 T obj,
                                 String errorMsgTemplate,
                                 Object... params)
                          throws IllegalArgumentException

断言给定对象是否是给定类的实例

 Assert.instanceOf(Foo.class, foo);

Type Parameters:: T - 被检查对象泛型类型
Parameters:: type - 被检查对象匹配的类型; obj - 被检查对象; errorMsgTemplate - 异常时的消息模板; params - 参数列表
Returns:: 被检查对象
Throws:: IllegalArgumentException - if the object is not an instance of clazz
See Also:: Class.isInstance(Object)

isAssignable

public static void isAssignable(Class<?> superType,
                                Class<?> subType)
                         throws IllegalArgumentException

superType.isAssignableFrom(subType) 是否为 true.

 Assert.isAssignable(Number.class, myClass);

Parameters:: superType - 需要检查的父类或接口; subType - 需要检查的子类
Throws:: IllegalArgumentException - 如果子类非继承父类，抛出此异常

isAssignable

public static void isAssignable(Class<?> superType,
                                Class<?> subType,
                                String errorMsgTemplate,
                                Object... params)
                         throws IllegalArgumentException

superType.isAssignableFrom(subType) 是否为 true.

 Assert.isAssignable(Number.class, myClass);

Parameters:: superType - 需要检查的父类或接口; subType - 需要检查的子类; errorMsgTemplate - 异常时的消息模板; params - 参数列表
Throws:: IllegalArgumentException - 如果子类非继承父类，抛出此异常

state

public static void state(boolean expression,
                         String errorMsgTemplate,
                         Object... params)
                  throws IllegalStateException

检查boolean表达式，当检查结果为false时抛出 IllegalStateException.

 Assert.state(id == null, "The id property must not already be initialized");

Parameters:: expression - boolean 表达式; errorMsgTemplate - 异常时的消息模板; params - 参数列表
Throws:: IllegalStateException - if expression is false

state
```
public static void state(boolean expression)
                  throws IllegalStateException
```
检查boolean表达式，当检查结果为false时抛出 IllegalStateException.
```
 Assert.state(id == null);
 
```
Parameters:

expression - boolean 表达式

Throws:

IllegalStateException - 表达式为 false 抛出此异常

hasText
```
public static void hasText(String text,
                           String message)
```
断言给定的字符串包含有效的文本内容.
```
   Assert.hasText(name, "'name' must not be empty");
 
```
Parameters:

text - 被检查字符串

message - 如果断言失败，要使用的异常消息

Throws:

IllegalArgumentException - 表达式为 false 抛出此异常

checkIndex
```
public static int checkIndex(int index,
                             int size)
                      throws IllegalArgumentException,
                             IndexOutOfBoundsException
```
检查下标(数组、集合、字符串)是否符合要求，下标必须满足：
```
 0 ≤ index < size
 
```
Parameters:

index - 下标

size - 长度

Returns:

检查后的下标

Throws:

IllegalArgumentException - 如果size < 0 抛出此异常

IndexOutOfBoundsException - 如果index < 0或者 index ≥ size 抛出此异常

checkIndex

public static int checkIndex(int index,
                             int size,
                             String errorMsgTemplate,
                             Object... params)
                      throws IllegalArgumentException,
                             IndexOutOfBoundsException

检查下标(数组、集合、字符串)是否符合要求，下标必须满足：

 0 ≤ index < size

Parameters:: index - 下标; size - 长度; errorMsgTemplate - 异常时的消息模板; params - 参数列表
Returns:: 检查后的下标
Throws:: IllegalArgumentException - 如果size < 0 抛出此异常; IndexOutOfBoundsException - 如果index < 0或者 index ≥ size 抛出此异常

checkBetween
```
public static int checkBetween(int value,
                               int min,
                               int max)
```
检查值是否在指定范围内

Parameters:

value - 值

min - 最小值(包含)

max - 最大值(包含)

Returns:

检查后的长度值

checkBetween
```
public static long checkBetween(long value,
                                long min,
                                long max)
```
检查值是否在指定范围内

Parameters:

value - 值

min - 最小值(包含)

max - 最大值(包含)

Returns:

检查后的长度值

checkBetween

public static double checkBetween(double value,
                                  double min,
                                  double max)

检查值是否在指定范围内

Parameters:: value - 值; min - 最小值(包含); max - 最大值(包含)
Returns:: 检查后的长度值

checkBetween

public static Number checkBetween(Number value,
                                  Number min,
                                  Number max)

检查值是否在指定范围内

Parameters:: value - 值; min - 最小值(包含); max - 最大值(包含)
Returns:: 检查后的长度值

Class Assert

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Assert

Method Detail

isTrue

isTrue

isFalse

isFalse

isNull

isNull

notNull

notNull

notEmpty

notEmpty

notBlank

notBlank

notContain

notContain

notEmpty

notEmpty

noNullElements

noNullElements

notEmpty

notEmpty

notEmpty

notEmpty

isInstanceOf

isInstanceOf

isAssignable

isAssignable

state

state

hasText

checkIndex

checkIndex

checkBetween

checkBetween

checkBetween

checkBetween