OcStarDic

# 字符串函数

# 分割，返回数组[]

$分割,字符串,正则表达式$

$分割,字符串,正则表达式,起始分割索引$
1
2
3

# 替换字符串内指定的字符

$替换,字符串,被替换的字符,新字符$
1

# 正则替换字符串内指定的字符

$替换,字符串,正则表达式,新字符$
1

# 正则判断字符串

$正则,字符串,正则表达式$
1

# 判断结尾的字符

$结尾,字符串,结尾字符$
1

# 判断开头的字符

$结尾,字符串,开头字符$

$结尾,字符串,开头字符,起始索引$
1
2
3

# 查找字符在字符串中的开头索引

$索引,字符串,字符$

$索引,字符串,字符,起始索引$
1
2
3

# 查找字符在字符串中的结尾索引

$结尾索引,字符串,字符$

$结尾索引,字符串,字符,起始索引$
1
2
3

# 将字符串转化成char数组

$char数组,字符串$
1

# 截取指定位数字符串

$截取,字符串,起始索引$

$截取,字符串,起始索引,结束索引$
1
2
3

# 获取中文声母

$声母,中文字符$

$声母,中文字符,索引$
1
2
3

# 获取中文声调

$声调,中文字符$

$声调,中文字符,索引$
1
2
3

# 获取中文韵母

$韵母,中文字符$

$韵母,中文字符,索引$
1
2
3

# 获取拼音

$拼音,中文字符(char类型)$

$拼音,中文字符(String类型)$

$韵母,中文字符,索引$
1
2
3
4
5

# 获取声调Str

$声调Str,中文字符$

$声调Str,中文字符,索引$
1
2
3

# 获取拼音英文大小写

$小写,字符串$

$大写,字符串$
1
2
3

# 特殊函数

# 随机数

$随机数,最小值,最大值$
1

# 时间戳

$时间戳$
1

# 时间

$时间,格式$
1

# 判断类型

$类型,对象$
1

# 线程休眠

$休眠,时间$
1

# 报错

$错误,字符串$
1

# 输出日志

$logd,内容$

$logw,内容$

$loge,内容$
1
2
3
4
5

# 回调运行

$回调,函数名,参数列表$
1

# 异步执行

$异步执行,函数名,参数列表$
1

# 执行

$执行,函数名,参数列表$
1

# 删除文件

$删除文件,路径$
1

# 数组函数

# JSONObject

# put 添加参数

JSONObject对象[键]=值;

$put,JSONObject对象,键,值$
1
2
3

# putAll 添加多个参数

$putAll,JSONObject对象,JSONObject对象2$
1

# 删除参数

$删除,JSONObject对象,键$

$删除,JSONObject对象,键,值$
1
2
3

# get

JSONObject对象[键]

$get,JSONObject对象,键$

$getString,JSONObject对象,键$

$getInt,JSONObject对象,键$

$getDouble,JSONObject对象,键$

$getLong,JSONObject对象,键$

$getFloat,JSONObject对象,键$

$getByte,JSONObject对象,键$

$getBytes,JSONObject对象,键$

$getBool,JSONObject对象,键$

$getObj,JSONObject对象,键$

$getJsonOb,JSONObject对象,键$

$getArr,JSONObject对象,键$
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 排序

$排序,JSONObject对象,内部方法$

$排序,JSONObject对象,布尔值$
1
2
3

# 存在键

$存在键,JSONObject对象,键$
1

# 存在值

$存在值,JSONObject对象,值$
1

# HashMap

# put 添加参数

HashMap对象[键]=值;

$put,HashMap对象,键,值$
1
2
3

# putAll 添加多个参数

$putAll,HashMap对象,HashMap对象2$
1

# get

HashMap对象[键]

$get,HashMap对象,键$
1
2
3

# 排序

$排序,HashMap对象,内部方法$

$排序,HashMap对象,布尔值$
1
2
3

# 存在键

$存在键,HashMap对象,键$
1

# 存在值

$存在值,HashMap对象,值$
1

# List

# add 添加参数

$add,List对象,值$

$add,List对象,索引,值$
1
2
3

# addAll 添加多个参数

$addAll,List对象,List对象2$
1

# get

List对象[索引]

$get,List对象,索引$
1
2
3

# 索引

$索引,List对象,元素$
1

# 结尾索引

$结尾索引,List对象,元素$
1

# 排序

$排序,List对象,内部方法$

$排序,List对象,布尔值$

$排序,List对象,键,布尔值$
1
2
3
4
5

# 判断存在

$存在,List对象,文本内容$

List对象.存在(文本内容)
1
2
3

# 正则判断数数组内容

$正则存在,List对象,正则表达式$

List对象.正则存在(正则表达式)
1
2
3

# 循环判断字符串中有没有包含数组里的某个内容

$包含匹配,List对象,文本内容$

List对象.包含匹配(文本内容)
1
2
3

# 循环正则判断字符串中数组里的某个内容(文件保存为正则表达式)

$正则匹配,List对象,文本内容$

List对象.正则匹配(文本内容)
1
2
3

# 正则过滤数组中的内容封装成JSONObject

$正则过滤,List对象,正则表达式$

List对象.正则过滤(正则表达式)
1
2
3

# 过滤数组中的内容相等封装成JSONObject

$过滤,List对象,正则表达式$

List对象.过滤(正则表达式)
1
2
3

# JSONArray

# add 添加参数

$add,JSONArray对象,值$

$add,JSONArray对象,索引,值$
1
2
3

# addAll 添加多个参数

$addAll,JSONArray对象,List对象2$
1

# get

JSONArray对象[索引]

$get,JSONArray对象,索引$

$getString,JSONArray对象,索引$

$getInt,JSONArray对象,索引$

$getDouble,JSONArray对象,索引$

$getLong,JSONArray对象,索引$

$getFloat,JSONArray对象,索引$

$getByte,JSONArray对象,索引$

$getBool,JSONArray对象,索引$

$getObj,JSONArray对象,索引$

$getJsonOb,JSONArray对象,索引$

$getArr,JSONArray对象,索引$
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 索引

$索引,JSONArray对象,元素$
1

# 结尾索引

$结尾索引,JSONArray对象,元素$
1

# 排序

$排序,JSONArray对象,内部方法$

$排序,JSONArray对象,布尔值$

$排序,JSONArray对象,键,布尔值$
1
2
3
4
5

# 判断存在

$存在,JSONArray对象,文本内容$

JSONArray对象.存在(文本内容)
1
2
3

# 正则判断数数组内容

$正则存在,JSONArray对象,正则表达式$

JSONArray对象.正则存在(正则表达式)
1
2
3

# 循环判断字符串中有没有包含数组里的某个内容

$包含匹配,JSONArray对象,文本内容$

JSONArray对象.包含匹配(文本内容)
1
2
3

# 循环正则判断字符串中数组里的某个内容(文件保存为正则表达式)

$正则匹配,JSONArray对象,文本内容$

JSONArray对象.正则匹配(文本内容)
1
2
3

# 正则过滤数组中的内容封装成JSONObject

$正则过滤,JSONArray对象,正则表达式$

JSONArray对象.正则过滤(正则表达式)
1
2
3

# 过滤数组中的内容相等封装成JSONObject

$过滤,JSONArray对象,正则表达式$

JSONArray对象.过滤(正则表达式)
1
2
3

← api访问函数 →