ZCron (nutz-plugins-zcron 1.r.68.v20201011 API)

java.lang.Object
- org.nutz.plugins.zcron.ZCron

```
public class ZCron
extends Object
```

构造器概要

构造器
构造器和说明

ZCron()

ZCron(String cron)

构造器
构造器和说明
`ZCron()`
`ZCron(String cron)`

方法概要

所有方法静态方法实例方法具体方法
限定符和类型	方法和说明
`static <T> T[]`	`compact(T[] array)` 让数组更紧凑这个函数可以配合 fill 来使用， fill 过的数组有些元素为 null 为了能紧凑显示，本函数去掉所有 null 元素，但是同时数组的下标信息就丢失了如果不想丢失下标信息并且还想紧凑表达请用 compactAll
`static <T> ArrayList<CronObj<T>>`	`compactAll(T[] array)` 让数组更紧凑，并保留下标信息
`<T> void`	`each(T[] array, CronEach<T> callback, Calendar c)`
`<T> void`	`each(T[] array, CronEach<T> callback, Calendar c, int off, int len, int unit)` 本函数用来迭代一个目标数组你的数组最多可以是 86400 的元素，对应一天中的每一秒，根据你给定的日期，本函数来决定具体哪个一数组项目要被执行回调当然，如果你给定日期不能匹配表达式，本函数会直接跳过执行，如果你不给定日期，则本函数一定会执行关于数组的长度涉及到一个时间的缩放问题，NutzCron 实际上是声明了一天中的一系列启动点这些点，我们可以用秒来表示，从 0－86399 分别表示一天中的任何一秒。
`<T> void`	`each(T[] array, CronEach<T> callback, Date d)`
`<T> void`	`each(T[] array, CronEach<T> callback, String ds)`
`<T> T[]`	`fill(T[] array, T obj, Calendar c)`
`<T> T[]`	`fill(T[] array, T obj, Calendar c, int off, int len, int unit)` 本函数用来填充数组它将调用 each 函数，填充数组中的匹配项。
`<T> T[]`	`fillBy(T[] array, T obj, Date d)`
`<T> T[]`	`fillBy(T[] array, T obj, long ms)`
`<T> T[]`	`fillBy(T[] array, T obj, String ds)`
`<T> T[]`	`fillByToday(T[] array, T obj)`
`String`	`getPrimaryString()`
`boolean`	`isHasTimePoints()`
`boolean`	`isHasTimeSteps()`
`static void`	`main(String[] args)`
`boolean`	`matchDate(Calendar c)` 是否匹配一个日期
`boolean`	`matchDate(Date d)` 是否匹配一个日期
`boolean`	`matchDate(String ds)` 是否匹配一个日期
`boolean`	`matchDayInMonth(int day)` 看看能不能匹配上一个月的天数
`boolean`	`matchDayInWeek(int day)` 看看能不能匹配上一周中的天数
`boolean`	`matchMonth(int m)` 匹配月
`boolean`	`matchTime(int sec)` 根据给定的秒数，判断是否匹配本表达式
`boolean`	`matchTime(String ts)` 根据给定的时间字符串，判断是否匹配本表达式
`boolean`	`matchTime(org.nutz.lang.Times.TmInfo ti)` 根据给定的时间，判断是否匹配本表达式
`boolean`	`matchYear(int year)` 匹配年
`<T extends CronOverlapor> T[]`	`overlap(T[] array, Object obj, Calendar c)`
`<T extends CronOverlapor> T[]`	`overlap(T[] array, Object obj, Calendar c, int off, int len, int unit)` 本函数用来叠加数组它将调用 each 函数，叠加数组中的匹配项。
`<T extends CronOverlapor> T[]`	`overlapBy(T[] array, Object obj, String ds)` 根据时间的毫秒数叠加数组
`<T extends CronOverlapor> T[]`	`overlapBy(T[] array, T obj, Date d)` 根据时间的毫秒数叠加数组
`<T extends CronOverlapor> T[]`	`overlapBy(T[] array, T obj, long ms)` 根据时间的毫秒数叠加数组
`<T extends CronOverlapor> T[]`	`overlapByToday(T[] array, T obj)` 根据当前时间的毫秒数叠加数组
`ZCron`	`parse(String cron)` 根据字符串，重新解析一个表达式
`ZCron`	`setPartExtDate(String str)`
`ZCron`	`setPartExtTime(String str)`
`ZCron`	`setPartStdDate(String str)`
`ZCron`	`setPartStdTime(String str)`
`String`	`toString()`
`String`	`toText(ZCroni18n i18n)` 将表达式转换成人类可以读懂的文字

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

- 构造器详细资料
  - ZCron
```
public ZCron()
```
  - ZCron
```
public ZCron(String cron)
```
- 方法详细资料
  - compact
```
public static <T> T[] compact(T[] array)
```
    让数组更紧凑
    这个函数可以配合 fill 来使用， fill 过的数组有些元素为 null
    为了能紧凑显示，本函数去掉所有 null 元素，但是同时数组的下标信息就丢失了
    如果不想丢失下标信息并且还想紧凑表达请用 compactAll
    
    类型参数:
    
    T -
    
    参数:
    
    array - 填充的数组
    
    返回:
    
    紧凑的数组（下标信息丢失）
  - compactAll
```
public static <T> ArrayList<CronObj<T>> compactAll(T[] array)
```
    让数组更紧凑，并保留下标信息
    
    类型参数:
    
    T -
    
    参数:
    
    array - 填充的数组
    
    返回:
    
    紧凑的列表（下标信息保留）
  - parse
```
public ZCron parse(String cron)
```
    根据字符串，重新解析一个表达式
    
    参数:
    
    cron - 表达式字符串
    
    返回:
    
    自身以便链式使用
  - matchDate
```
public boolean matchDate(Calendar c)
```
    是否匹配一个日期
    
    参数:
    
    c - 日期对象，时间部分无视
    
    返回:
    
    是否匹配
  - matchDate
```
public boolean matchDate(String ds)
```
    是否匹配一个日期
    
    参数:
    
    ds - 日期字符串，格式为 yyyy-MM-dd 的字符串
    
    返回:
    
    是否匹配
  - matchDate
```
public boolean matchDate(Date d)
```
    是否匹配一个日期
    
    参数:
    
    d - 日期
    
    返回:
    
    是否匹配
  - matchDayInWeek
```
public boolean matchDayInWeek(int day)
```
    看看能不能匹配上一周中的天数
    
    参数:
    
    day - 一周内的天数，1 表示周日, 2 表示周一 ... 7 表示周六
    
    返回:
    
    是否匹配
  - matchDayInMonth
```
public boolean matchDayInMonth(int day)
```
    看看能不能匹配上一个月的天数
    
    参数:
    
    day - 月中的天数，1 - 31
    
    返回:
    
    是否匹配
  - matchMonth
```
public boolean matchMonth(int m)
```
    匹配月
    
    参数:
    
    m - 月份，1-12
    
    返回:
    
    是否匹配
  - matchYear
```
public boolean matchYear(int year)
```
    匹配年
    
    参数:
    
    year - 年份，2017 等
    
    返回:
    
    是否匹配
  - matchTime
```
public boolean matchTime(int sec)
```
    根据给定的秒数，判断是否匹配本表达式
    
    参数:
    
    sec - 一天中的秒数，为 0-86399，如果超出，按 86399，如果小于，按0
    
    返回:
    
    是否匹配
  - matchTime
```
public boolean matchTime(String ts)
```
    根据给定的时间字符串，判断是否匹配本表达式
    
    参数:
    
    ts - 时间字符串，格式为 HH:mm:ss 或者 HH:MM
    
    返回:
    
    是否匹配
  - matchTime
```
public boolean matchTime(org.nutz.lang.Times.TmInfo ti)
```
    根据给定的时间，判断是否匹配本表达式
    
    参数:
    
    ti - 时间对象
    
    返回:
    
    是否匹配
  - each
```
public <T> void each(T[] array,
                     CronEach<T> callback,
                     String ds)
```
    另请参阅:
    
    each(Object[], CronEach, Calendar)
  - each
```
public <T> void each(T[] array,
                     CronEach<T> callback,
                     Date d)
```
    另请参阅:
    
    each(Object[], CronEach, Calendar)
  - each
```
public <T> void each(T[] array,
                     CronEach<T> callback,
                     Calendar c)
```
    另请参阅:
    
    #each(Object[], int, int, int, Calendar, CronEach)
  - each
```
public <T> void each(T[] array,
                     CronEach<T> callback,
                     Calendar c,
                     int off,
                     int len,
                     int unit)
```
    本函数用来迭代一个目标数组
    你的数组最多可以是 86400 的元素，对应一天中的每一秒，
    根据你给定的日期，本函数来决定具体哪个一数组项目要被执行回调
    当然，如果你给定日期不能匹配表达式，本函数会直接跳过执行，如果你不给定日期，则本函数一定会执行
    关于数组的长度涉及到一个时间的缩放问题，NutzCron 实际上是声明了一天中的一系列启动点
    这些点，我们可以用秒来表示，从 0－86399 分别表示一天中的任何一秒。
    因此，给定的数组的长度最好能把 86400 整除否则一天中最后一段时间会被忽略掉
    根据数组的长度，我就能知道，你所关心的 Cron 表达式精细程度，
    比如如果长度为 24 则，你其实仅仅关心到一个小时，如果 1440 你仅仅关心到1分钟
    同时，你可以自由的定义，比如你给定一个 400 长度的数组，那么 86400/400=216。
    因此，对你来说，时间的单位是 216 秒。
    本函数，执行的策略
    1. 得到时间单位
    2. 然后，循环数组，根据下标，我们能得到一个秒数范围
    3. 这个范围内，如果任意一秒能被匹配，就算匹配成功
    类型参数:
    
    T -
    
    参数:
    
    array - 要被访问数组
    
    callback - 如果数组下标被匹配，则要执行的回调
    
    off - 从数组的哪个下标开始访问
    
    c - 日期对象。空的话，一定会执行迭代
    
    len - 访问多少个元素
    
    unit - 一个数组元素表示多少秒
  - overlap
```
public <T extends CronOverlapor> T[] overlap(T[] array,
                                             Object obj,
                                             Calendar c,
                                             int off,
                                             int len,
                                             int unit)
```
    本函数用来叠加数组
    它将调用 each 函数，叠加数组中的匹配项。
    所谓叠加，就是数组每个元素都是一个 QzList，匹配的数组项，会 add 叠加对象。
    与之不同的，fill(Object[], Object, Calendar) 是直接替换
    
    类型参数:
    
    T -
    
    参数:
    
    array - 要被叠加的数组
    
    obj - 叠加对象
    
    c - 日期对象
    
    off - 从数组的哪个下标开始访问
    
    len - 访问多少个元素
    
    unit - 一个数组元素表示多少秒
    
    返回:
    
    数组本身以便链式赋值
    
    另请参阅:
    
    each(Object[], CronEach, Calendar)
  - overlap
```
public <T extends CronOverlapor> T[] overlap(T[] array,
                                             Object obj,
                                             Calendar c)
```
    另请参阅:
    
    overlap(CronOverlapor[], Object, Calendar, int, int, int)
  - overlapByToday
```
public <T extends CronOverlapor> T[] overlapByToday(T[] array,
                                                    T obj)
```
    根据当前时间的毫秒数叠加数组
    
    另请参阅:
    
    overlap(CronOverlapor[], Object, Calendar)
  - overlapBy
```
public <T extends CronOverlapor> T[] overlapBy(T[] array,
                                               T obj,
                                               long ms)
```
    根据时间的毫秒数叠加数组
    
    类型参数:
    
    T -
    
    参数:
    
    array - 要被叠加的数组
    
    obj - 叠加的对象
    
    ms - 毫秒数，但是仅仅其中的天这部分有意义
    
    返回:
    
    数组本身以便链式赋值
    
    另请参阅:
    
    overlap(CronOverlapor[], Object, Calendar)
  - overlapBy
```
public <T extends CronOverlapor> T[] overlapBy(T[] array,
                                               Object obj,
                                               String ds)
```
    根据时间的毫秒数叠加数组
    
    类型参数:
    
    T -
    
    参数:
    
    array - 要被叠加的数组
    
    obj - 叠加的对象
    
    ds - 日期字符串，格式为 yyyy-MM-dd 的字符串
    
    返回:
    
    数组本身以便链式赋值
    
    另请参阅:
    
    overlap(CronOverlapor[], Object, Calendar)
  - overlapBy
```
public <T extends CronOverlapor> T[] overlapBy(T[] array,
                                               T obj,
                                               Date d)
```
    根据时间的毫秒数叠加数组
    
    类型参数:
    
    T -
    
    参数:
    
    array - 要被叠加的数组
    
    obj - 叠加的对象
    
    d - 时间，但是仅仅其中的天这部分有意义
    
    返回:
    
    数组本身以便链式赋值
    
    另请参阅:
    
    overlap(CronOverlapor[], Object, Calendar)
  - fillByToday
```
public <T> T[] fillByToday(T[] array,
                           T obj)
```
    另请参阅:
    
    fill(Object[], Object, Calendar)
  - fillBy
```
public <T> T[] fillBy(T[] array,
                      T obj,
                      long ms)
```
    另请参阅:
    
    fill(Object[], Object, Calendar)
  - fillBy
```
public <T> T[] fillBy(T[] array,
                      T obj,
                      String ds)
```
    另请参阅:
    
    fill(Object[], Object, Calendar)
  - fillBy
```
public <T> T[] fillBy(T[] array,
                      T obj,
                      Date d)
```
    另请参阅:
    
    fill(Object[], Object, Calendar)
  - fill
```
public <T> T[] fill(T[] array,
                    T obj,
                    Calendar c)
```
    另请参阅:
    
    fill(Object[], Object, Calendar, int, int, int)
  - fill
```
public <T> T[] fill(T[] array,
                    T obj,
                    Calendar c,
                    int off,
                    int len,
                    int unit)
```
    本函数用来填充数组
    它将调用 each 函数，填充数组中的匹配项。
    所谓填充，就是数组每个元素都是一个 T，匹配的数组项，被设置成填充对象。
    与之不同的，overlap(CronOverlapor[], Object, Calendar) 是叠加到一个 QzList
    
    类型参数:
    
    T -
    
    参数:
    
    array - 要被填充的数组
    
    obj - 填充的对象
    
    c - 日期对象
    
    off - 从数组的哪个下标开始访问
    
    len - 访问多少个元素
    
    unit - 一个数组元素表示多少秒
    
    返回:
    
    数组本身以便链式赋值
    
    另请参阅:
    
    each(Object[], CronEach, Calendar)
  - isHasTimePoints
```
public boolean isHasTimePoints()
```
  - isHasTimeSteps
```
public boolean isHasTimeSteps()
```
  - setPartExtTime
```
public ZCron setPartExtTime(String str)
```
  - setPartStdTime
```
public ZCron setPartStdTime(String str)
```
  - setPartStdDate
```
public ZCron setPartStdDate(String str)
```
  - setPartExtDate
```
public ZCron setPartExtDate(String str)
```
  - toString
```
public String toString()
```
    覆盖:
    
    toString 在类中 Object
  - getPrimaryString
```
public String getPrimaryString()
```
  - toText
```
public String toText(ZCroni18n i18n)
```
    将表达式转换成人类可以读懂的文字
    
    参数:
    
    i18n - 为多国语言参数，结构参见 src/main/resources/org/nutz/plugins/zcron/i18n/zh_cn.js
    
    返回:
    
    人类可以读懂的字符串
  - main
```
public static void main(String[] args)
```

类 ZCron

构造器概要

方法概要

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

构造器详细资料

ZCron

ZCron

方法详细资料

compact

compactAll

parse

matchDate

matchDate

matchDate

matchDayInWeek

matchDayInMonth

matchMonth

matchYear

matchTime

matchTime

matchTime

each

each

each

each

overlap

overlap

overlapByToday

overlapBy

overlapBy

overlapBy

fillByToday

fillBy

fillBy

fillBy

fill

fill

isHasTimePoints

isHasTimeSteps

setPartExtTime

setPartStdTime

setPartStdDate

setPartExtDate

toString

getPrimaryString

toText

main