LuaState

java.lang.Object
- com.naef.jnlua.LuaState

public class LuaState
extends Object

表示 Lua 实例的 JNLua 核心类。

此类对所有参数及其状态执行广泛检查。具体来说，在以下指定的条件下会抛出下列异常

异常	何时
`NullPointerException`	如果某个参数为 `null`，且 API 并未明确指定该参数可以为 `null`
`IllegalStateException`	如果 Lua 状态已关闭，且 API 并未明确指定可以在关闭的 Lua 状态上调用该方法
`IllegalArgumentException`	如果栈索引引用未定义的栈位置，且 API 并未明确指定该栈索引可以未定义
`IllegalArgumentException`	如果栈索引引用值为不同于 API 中明确指定的值类型的栈位置
`IllegalArgumentException`	如果计数为负或超出范围，且 API 并未明确指定该计数可以为负或超出范围
`LuaRuntimeException`	如果发生 Lua 运行时错误
`LuaSyntaxException`	如果 Lua 块的语法不正确
`LuaMemoryAllocationException`	如果 Lua 内存分配器用尽内存或如果 JNI 分配失败

嵌套类摘要

嵌套类
修饰符和类型类和说明

static class LuaState.GcAction
表示一个 Lua 垃圾回收器操作。

static class LuaState.Library
表示一个 Lua 库。

嵌套类
修饰符和类型	类和说明
`static class`	`LuaState.GcAction` 表示一个 Lua 垃圾回收器操作。
`static class`	`LuaState.Library` 表示一个 Lua 库。

字段摘要

字段
修饰符和类型	字段和说明
`static int`	`ENVIRONINDEX` 环境伪索引。
`static int`	`GLOBALSINDEX` 全局伪索引。
`static String`	`LUA_VERSION` Lua 版本。
`static int`	`MULTRET` 多个返回伪返回值计数。
`static int`	`REGISTRYINDEX` 注册表伪索引。
`static String`	`VERSION` JNLua 版本。
`static int`	`YIELD` 指示线程已挂起的状态。

构造函数摘要

构造函数
构造函数和说明

LuaState()
创建新实例。

LuaState(long luaState)
创建新实例。

构造函数
构造函数和说明
`LuaState()` 创建新实例。
`LuaState(long luaState)` 创建新实例。

方法摘要

方法
修饰符和类型	方法和说明
`void`	`call(int argCount, int returnCount)` 调用 Lua 函数。
`void`	`checkArg(int index, boolean condition, String msg)` 检查某个条件对于指定函数参数是否为 true。
`boolean`	`checkBoolean(int index)` 检查指定函数参数的值是否为布尔值。
`boolean`	`checkBoolean(int index, boolean d)` 检查指定函数参数的值是否为布尔值。
`byte[]`	`checkByteArray(int index)` 检查指定函数的参数值是不是字符串或数字。
`byte[]`	`checkByteArray(int index, byte[] d)` 检查指定函数的参数值是不是字符串或数字。
`int`	`checkInteger(int index)` 检查指定函数的参数值是不是数字或可以转换成数字的字符串。
`int`	`checkInteger(int index, int d)` 检查指定函数的参数值是不是数字或可以转换成数字的字符串。
`<T> T`	`checkJavaObject(int index, Class<T> clazz)` 检查指定函数的参数值是不是可以转换成指定类型的 Java 对象。
`<T> T`	`checkJavaObject(int index, Class<T> clazz, T d)` 检查指定函数的参数值是不是可以转换成指定类型的 Java 对象。
`double`	`checkNumber(int index)` 检查指定函数的参数值是不是数字或可以转换成数字的字符串。
`double`	`checkNumber(int index, double d)` 检查指定函数的参数值是不是数字或可以转换成数字的字符串。
`String`	`checkOption(int index, String[] options)` 检查指定函数的参数值是不是字符串或数字，同时匹配指定的选项。
`String`	`checkOption(int index, String[] options, String d)` 检查指定函数的参数值是不是字符串或数字，同时匹配指定的选项。
`String`	`checkString(int index)` 检查指定函数的参数值是不是字符串或数字。
`String`	`checkString(int index, String d)` 检查指定函数的参数值是不是字符串或数字。
`void`	`checkType(int index, LuaType type)` 检查指定函数的参数值是不是指定类型。
`void`	`close()` 关闭当前的 Lua 状态并释放所有资源。
`void`	`concat(int n)` 连接堆栈顶部指定的多个值，并用连接后的值替换它们。
`void`	`dump(OutputStream outputStream)` 将堆栈顶部的函数作为已编译二进制片段转储到输出流中。
`boolean`	`equal(int index1, int index2)` 返回位于两个指定堆栈索引处的值是否按照 Lua 语义相等。
`int`	`gc(LuaState.GcAction what, int data)` 执行垃圾回收操作。
`ClassLoader`	`getClassLoader()` 返回该 Lua 状态的类加载器。
`转换器`	`getConverter()` 返回该 Lua 状态的转换器。
`void`	`getFEnv(int index)` 在栈上推送指定索引处的值的环境表。
`void`	`getField(int index, String key)` 在栈上推送指定索引处的表中由指定字符串键索引的值。
`void`	`getGlobal(String name)` 在栈上推送全局变量的值。
`Java 反射器`	`getJavaReflector()` 返回该 Lua 状态的 Java 反射器。
`boolean`	`getMetafield(int index, String key)` 在栈上推送指定索引处的值的元表中具名字段的值，并返回 `true`。
`Java 函数`	`getMetamethod(Object obj, JavaReflector.Metamethod metamethod)` 返回指定对象的元方法。
`boolean`	`getMetatable(int index)` 在栈上推送指定索引处的值的元表。
`Lua 值代理`	`getProxy(int index)` 返回指定索引处 Lua 值的代理对象。
`Lua 值代理`	`getProxy(int index, Class<?>[] interfaces)` 返回一个在 Lua 中实现指定接口列表的代理对象。
`<T> T`	`getProxy(int index, Class<T> interfaze)` 返回一个在 Lua 中实现指定接口的代理对象。
`void`	`getTable(int index)` 在指定索引处的表中，在栈上推送由栈顶键索引的值。
`int`	`getTop()` 返回栈上的值的数量。
`void`	`insert(int index)` 弹出栈顶值，将其插入指定索引处，并将该索引之上的元素上移。
`boolean`	`isBoolean(int index)` 返回指定栈索引处的该值是否是布尔值。
`boolean`	`isCFunction(int index)` 返回指定栈索引处的该值是否是 C 函数。
`boolean`	`isFunction(int index)` 返回指定栈索引处的该值是否是函数（C 函数、Java 函数或 Lua 函数）。
`boolean`	`isJavaFunction(int index)` 返回指定栈索引处的该值是否是 Java 函数。
`boolean`	`isJavaObject(int index, Class<?> type)` 返回指定堆栈索引处的值是否可转换为指定类型的 Java 对象。
`boolean`	`isJavaObjectRaw(int index)` 返回指定堆栈索引处的值是否是 Java 对象。
`boolean`	`isNil(int index)` 返回指定堆栈索引处的值是否是 `nil`。
`boolean`	`isNone(int index)` 返回指定堆栈索引处的值是否未定义。
`boolean`	`isNoneOrNil(int index)` 返回指定堆栈索引处的值是否未定义或 `nil`。
`boolean`	`isNumber(int index)` 返回指定堆栈索引处的值是否为数字或可转换为数字的字符串。
`boolean`	`isOpen()` 返回此 Lua 状态是否为打开状态。
`boolean`	`isString(int index)` 返回指定堆栈索引处的值是否是字符串或数字（这类数字始终可转换成字符串）。
`boolean`	`isTable(int index)` 返回指定堆栈索引处的值是否是表。
`boolean`	`isThread(int index)` 返回指定堆栈索引处的值是否是线程。
`int`	`length(int index)` 返回指定堆栈索引处的值的长度。
`boolean`	`lessThan(int index1, int index2)` 返回第一个堆栈索引处的值是否小于第二个堆栈索引处的值（根据 Lua 语义）。
`void`	`load(InputStream inputStream, String chunkName)` 从输入流加载一个 Lua 代码块并将其作为一个函数压入堆栈。
`void`	`load(String chunk, String chunkName)` 从一个字符串加载一个 Lua 代码块并将其作为一个函数压入堆栈。
`void`	`newTable()` 创建一个新表并将其压入堆栈。
`void`	`newTable(int arrayCount, int recordCount)` 创建一个新表，并预留一定数量的数组元素和记录元素所用的空间，然后将其压入堆栈中。
`void`	`newThread()` 从堆栈中弹出新 Lua 线程的起始函数，并使用该起始函数创建新线程。
`boolean`	`next(int index)` 从堆栈中弹出键，并从指定索引处的表中弹出下一个键及其值并将其压入堆栈中。
`void`	`openLib(LuaState.Library library)` 在此 Lua 状态中打开指定的库。
`void`	`openLibs()` 在此 Lua 状态中打开 Lua 标准库和 JNLua Java 模块。
`void`	`pop(int count)` 从堆栈中弹出值。
`void`	`pushBoolean(boolean b)` 将布尔值推入堆栈。
`void`	`pushInteger(int n)` 将整数值作为数字值推入堆栈。
`void`	`pushJavaFunction(JavaFunction javaFunction)` 将 Java 函数推入堆栈。
`void`	`pushJavaObject(Object object)` 将 Java 对象连同转换信息一起推入堆栈。
`void`	`pushJavaObjectRaw(Object object)` 将 Java 对象推入堆栈。
`void`	`pushNil()` 将 nil 值推入堆栈。
`void`	`pushNumber(double n)` 将数字值推入堆栈。
`void`	`pushString(byte[] b)` 将字节数组作为字符串值推入堆栈。
`void`	`pushString(byte[] b, int count)` 将字节数组作为字符串值推入堆栈。
`void`	`pushString(String s)` 将字符串值推入堆栈。
`void`	`pushValue(int index)` 将指定索引位置的值推入堆栈顶端。
`boolean`	`rawEqual(int index1, int index2)` 绕过元表逻辑，返回两个指定堆栈索引位置的值是否根据 Lua 语义相等。
`void`	`rawGet(int index)` 绕过元表逻辑，将指定索引位置的表中由堆栈顶端键引用的值推入堆栈。
`void`	`rawGet(int index, int key)` 绕过元表逻辑，将指定索引位置的表中由指定整型键引用的值推入堆栈。
`void`	`rawSet(int index)` 绕过元表逻辑，将堆栈顶端的值置入指定索引位置的表中，使用第二高的堆栈位置上的值作为键。
`void`	`rawSet(int index, int key)` 绕过元表逻辑，将堆栈顶端的值置入指定索引位置的表中，使用指定的整型键。
`int`	`ref(int index)` 将堆栈顶端的值存储在指定索引位置的表中，并返回该表中该值的整型键作为引用。
`void`	`register(NamedJavaFunction namedJavaFunction)` 将命名 Java 函数注册为全局变量。
`void`	`register(String moduleName, NamedJavaFunction[] namedJavaFunctions)` 注册一个模块并将该模块推入堆栈。
`void`	`remove(int index)` 移除指定堆栈索引位置的值，并将该索引位置上方的元素下移。
`void`	`replace(int index)` 使用从堆栈顶端弹出的值替换指定索引位置的值。
`int`	`resume(int index, int argCount)` 恢复指定堆栈索引位置的线程，从堆栈顶端弹出指定数量的参数并将它们传递给恢复的线程。
`void`	`setClassLoader(ClassLoader classLoader)` 设置此 Lua 状态的类加载器。
`void`	`setConverter(Converter converter)` 设置此 Lua 状态的转换器。
`boolean`	`setFEnv(int index)` 将堆栈顶部的值设置为指定索引处的值的环境表。
`void`	`setField(int index, String key)` 使用指定的字符串键将堆栈顶部的值设置到指定索引处的表中。
`void`	`setGlobal(String name)` 将堆栈顶部的值设置为全局变量并从堆栈中弹出该值。
`void`	`setJavaReflector(JavaReflector javaReflector)` 设置此 Lua 状态的 Java 反射器。
`boolean`	`setMetatable(int index)` 将堆栈顶部的值设置为指定索引处的值的元表。
`void`	`setTable(int index)` 使用第二高的堆栈位置的值作为键，将堆栈顶部的值设置到指定索引处的表中。
`void`	`setTop(int index)` 将指定索引设置为堆栈的新顶部。
`int`	`status(int index)` 返回指定堆栈索引处的线程状态。
`void`	`tableMove(int index, int from, int to, int count)` 将用作数组的表中指定数量的顺序元素从一个索引移动到另一个索引。
`int`	`tableSize(int index)` 计算表中的条目数量。
`boolean`	`toBoolean(int index)` 返回指定堆栈索引处的值的布尔表示形式。
`byte[]`	`toByteArray(int index)` 返回指定堆栈索引处的值的字节数组表示形式。
`int`	`toInteger(int index)` 返回指定堆栈索引处的值的整数表示形式。
`Java 函数`	`toJavaFunction(int index)` 返回指定堆栈索引处的值的 Java 函数。
`<T> T`	`toJavaObject(int index, Class<T> type)` 返回指定堆栈索引处的值表示的特定类型 Java 对象。
`对象`	`toJavaObjectRaw(int index)` 返回指定堆栈索引处的值的 Java 对象。
`double`	`toNumber(int index)` 返回指定堆栈索引处的值的数字表示形式。
`long`	`toPointer(int index)` 返回指定堆栈索引处的值的指针表示形式。
`String`	`toString(int index)` 返回指定堆栈索引处的值的字符串表示形式。
`LuaType`	`type(int index)` 返回指定堆栈索引处的值的类型。
`String`	`typeName(int index)` 返回指定堆栈索引处的值的类型名称。
`void`	`unref(int index, int reference)` 从指定索引处的表中移除先前创建的引用。
`int`	`yield(int returnCount)` 让出正在运行的线程，从堆栈的顶部弹出指定数量的值并将它们作为返回值传递给已恢复正在运行线程的线程。

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

- 字段详情
  - REGISTRYINDEX
```
public static final int REGISTRYINDEX
```
    注册表伪索引。
    
    另请参阅
    常数字段的值
  - ENVIRONINDEX
```
public static final int ENVIRONINDEX
```
    环境伪索引。
    
    另请参阅
    常数字段的值
  - GLOBALSINDEX
```
public static final int GLOBALSINDEX
```
    全局伪索引。
    
    另请参阅
    常数字段的值
  - MULTRET
```
public static final int MULTRET
```
    多个返回伪返回值计数。
    
    另请参阅
    常数字段的值
  - YIELD
```
public static final int YIELD
```
    指示线程已挂起的状态。
    
    另请参阅
    常数字段的值
  - VERSION
```
public static final String VERSION
```
    JNLua 版本。格式为 <major>.<minor>。
    
    另请参阅
    常数字段的值
  - LUA_VERSION
```
public static final String LUA_VERSION
```
    Lua 版本。格式为 <major>.<minor>。
- 构造函数详情
  - LuaState
```
public LuaState()
```
    创建一个新实例。该 Lua 状态的类加载器将设置为调用线程的上下文类加载器。Java 反射器和转换器将用默认实现进行初始化。
    
    另请参阅
    getClassLoader(), setClassLoader(ClassLoader), getJavaReflector(), setJavaReflector(JavaReflector), getConverter(), setConverter(Converter)
  - LuaState
```
public LuaState(long luaState)
```
    创建新实例。
- 方法详情
  - getClassLoader
```
public ClassLoader getClassLoader()
```
    返回此 Lua 状态的类加载器。类加载器用于动态加载类。
    该方法可能会在已关闭的 Lua 状态上调用。
    
    返回
    类加载器
  - setClassLoader
```
public void setClassLoader(ClassLoader classLoader)
```
    设置此 Lua 状态的类加载器。类加载器用于动态加载类。
    该方法可能会在已关闭的 Lua 状态上调用。
    
    参数
    classLoader - 要设置的类加载器
  - getJavaReflector
```
public JavaReflector getJavaReflector()
```
    返回该 Lua 状态的 Java 反射器。
    该方法可能会在已关闭的 Lua 状态上调用。
    
    返回
    Java 反射器转换器
  - setJavaReflector
```
public void setJavaReflector(JavaReflector javaReflector)
```
    设置此 Lua 状态的 Java 反射器。
    该方法可能会在已关闭的 Lua 状态上调用。
    
    参数
    javaReflector - Java 反射器
  - getMetamethod
```
public JavaFunction getMetamethod(Object obj,
                         JavaReflector.Metamethod metamethod)
```
    返回指定对象的元方法。如果对象实现了 JavaReflector 接口，则首先从对象中查询元方法。如果对象提供了请求的元方法，则返回该元方法。否则，该方法可返回由此 Lua 状态中配置的 Java 反射器提供的元方法。
    需要访问元方法的客户端应该采用此方法，以确保持续地按类覆盖 Java 反射器。
    
    参数
    obj - 对象或 null
    
    返回
    Java 反射器
  - getConverter
```
public Converter getConverter()
```
    返回该 Lua 状态的转换器。
    该方法可能会在已关闭的 Lua 状态上调用。
    
    返回
    转换器
  - setConverter
```
public void setConverter(Converter converter)
```
    设置此 Lua 状态的转换器。
    该方法可能会在已关闭的 Lua 状态上调用。
    
    参数
    converter - 转换器
  - isOpen
```
public final boolean isOpen()
```
    返回此 Lua 状态是否为打开状态。
    该方法可能会在已关闭的 Lua 状态上调用。
    
    返回
    此 Lua 状态是否已打开
  - close
```
public void close()
```
    关闭当前的 Lua 状态并释放所有资源。
    该方法可在已关闭的 Lua 状态中调用，在这种情况下不会产生任何效果。
  - gc
```
public int gc(LuaState.GcAction what,
     int data)
```
    执行垃圾回收操作。
    
    参数
    what - 要执行的操作
    data - 某些操作所需的自变量（参见 Lua 参考手册）
    
    返回
    返回值取决于执行的 GC 操作（参见 Lua 参考手册）
  - openLib
```
public void openLib(LuaState.Library library)
```
    在此 Lua 状态中打开指定的库。
    
    参数
    库 - 库
  - openLibs
```
public void openLibs()
```
    在此 Lua 状态中打开 Lua 标准库和 JNLua Java 模块。
    该方法打开 LuaState.Library 枚举所定义的所有库。
  - register
```
public void register(NamedJavaFunction namedJavaFunction)
```
    将命名 Java 函数注册为全局变量。
    
    参数
    namedJavaFunction - 要注册的 Java 函数
  - register
```
public void register(String moduleName,
            NamedJavaFunction[] namedJavaFunctions)
```
    注册模块并将模块压入堆栈。允许模块名称包含点，用于定义模块层次结构。
    
    参数
    moduleName - 模块名称
    namedJavaFunctions - 模块的 Java 函数
  - load
```
public void load(InputStream inputStream,
        String chunkName)
          throws IOException
```
    从输入流中加载 Lua 片段，并将其作为函数压入堆栈。Lua 片段必须为 UTF-8 编码的源代码片段或预编译的二进制片段。
    
    参数
    inputStream - 输入流
    chunkName - 片段的名称，用于在错误信息中
    
    抛出
    
    IOException - 如果发生 IO 错误
  - load
```
public void load(String chunk,
        String chunkName)
```
    从字符串加载 Lua 片段并将其作为函数压入堆栈。字符串必须包含一个源代码片段。
    
    参数
    chunk - Lua 源代码片段
    chunkName - 片段的名称，用于在错误信息中
  - dump
```
public void dump(OutputStream outputStream)
          throws IOException
```
    将堆栈顶部的函数作为已编译二进制片段转储到输出流中。
    
    参数
    outputStream - 输出流
    
    抛出
    
    IOException - 如果发生 IO 错误
  - call
```
public void call(int argCount,
        int returnCount)
```
    调用 Lua 函数。要调用的函数和指定数量的参数都位于堆栈中。调用后，指定数量的返回值将位于堆栈中。如果已将返回值数量指定为 MULTRET，则堆栈中值的个数对应于所调用函数实际返回的值的个数。
    
    参数
    argCount - 参数的个数
    returnCount - 返回值的个数，或 MULTRET 以接受函数返回的所有值
  - getGlobal
```
public void getGlobal(String name)
```
    在栈上推送全局变量的值。
    
    参数
    name - 全局变量名称
  - setGlobal
```
public void setGlobal(String name)
               throws LuaMemoryAllocationException,
                      LuaRuntimeException
```
    将堆栈顶部的值设置为全局变量并从堆栈中弹出该值。
    
    参数
    name - 全局变量名称
    
    抛出
    
    LuaMemoryAllocationException
    
    LuaRuntimeException
  - pushBoolean
```
public void pushBoolean(boolean b)
```
    将布尔值推入堆栈。
    
    参数
    b - 要压入的布尔值
  - pushInteger
```
public void pushInteger(int n)
```
    将整数值作为数字值推入堆栈。
    
    参数
    n - 要压入的整数
  - pushJavaFunction
```
public void pushJavaFunction(JavaFunction javaFunction)
```
    将 Java 函数推入堆栈。
    
    参数
    javaFunction - 要压入的函数
  - pushJavaObjectRaw
```
public void pushJavaObjectRaw(Object object)
```
    将 Java 对象压入堆栈。对象被“按原样”压入，即无需转换。
    如果你需要压入一个表示 Java 对象的 Lua 值，则调用 pushJavaObject(object)。
    
    你无法在未转换的情况下压入 null，因为 null 不是 Java 对象。转换器会将 null 转换为 nil。
    
    参数
    object - Java 对象
    另请参阅
    pushJavaObject(Object)
  - pushJavaObject
```
public void pushJavaObject(Object object)
```
    使用转换将 Java 对象压入堆栈。对象会经配置的转换器处理。
    
    参数
    object - Java 对象
    另请参阅
    getConverter()，setConverter(Converter)
  - pushNil
```
public void pushNil()
```
    将 nil 值推入堆栈。
  - pushNumber
```
public void pushNumber(double n)
```
    将数字值推入堆栈。
    
    参数
    n - 要压入的数字
  - pushString
```
public void pushString(String s)
```
    将字符串值推入堆栈。
    
    参数
    s - 要推送的字符串值
  - pushString
```
public void pushString(byte[] b)
```
    将字节数组作为字符串值推入堆栈。
    
    参数
    b - 要推送的字节数组
  - pushString
```
public void pushString(byte[] b,
              int count)
```
    将字节数组作为字符串值推入堆栈。
    
    参数
    b - 要推送的字节数组
    count - 要从索引 0 开始推送的数组中的字节数量
  - isBoolean
```
public boolean isBoolean(int index)
```
    返回指定栈索引处的该值是否是布尔值。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为布尔值
  - isCFunction
```
public boolean isCFunction(int index)
```
    返回指定栈索引处的该值是否是 C 函数。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为函数
  - isFunction
```
public boolean isFunction(int index)
```
    返回指定栈索引处的该值是否是函数（C 函数、Java 函数或 Lua 函数）。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为函数
  - isJavaFunction
```
public boolean isJavaFunction(int index)
```
    返回指定栈索引处的该值是否是 Java 函数。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为函数
  - isJavaObjectRaw
```
public boolean isJavaObjectRaw(int index)
```
    返回指定堆栈索引处的值是否是 Java 对象。
    请注意，该方法不执行转换。如果你想检查该值是否可转换为 Java 对象，则调用 isJavaObject(index, Object.class)。
    
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为 Java 对象
    另请参阅
    isJavaObject(int, Class)
  - isJavaObject
```
public boolean isJavaObject(int index,
                   Class<?> type)
```
    返回指定的堆栈索引处的该值是否可转换为指定类型的 Java 对象。该转换由配置的转换器检查。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否可转换为指定类型的 Java 对象
    另请参阅
    setConverter(Converter)，getConverter()
  - isNil
```
public boolean isNil(int index)
```
    返回指定堆栈索引处的值是否是 nil。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为 nil
  - isNone
```
public boolean isNone(int index)
```
    返回指定堆栈索引处的值是否未定义。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否未定义
  - isNoneOrNil
```
public boolean isNoneOrNil(int index)
```
    返回指定堆栈索引处的值是否未定义或 nil。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否未定义
  - isNumber
```
public boolean isNumber(int index)
```
    返回指定堆栈索引处的值是否为数字或可转换为数字的字符串。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为数字或可转换为数字的字符串
  - isString
```
public boolean isString(int index)
```
    返回指定堆栈索引处的值是否是字符串或数字（这类数字始终可转换成字符串）。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为字符串或数字
  - isTable
```
public boolean isTable(int index)
```
    返回指定堆栈索引处的值是否是表。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为表
  - isThread
```
public boolean isThread(int index)
```
    返回指定堆栈索引处的值是否是线程。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    该值是否为线程
  - equal
```
public boolean equal(int index1,
            int index2)
```
    返回位于两个指定堆栈索引处的值是否按照 Lua 语义相等。
    
    参数
    index1 - 第一个堆栈索引
    index2 - 第二个堆栈索引
    
    返回
    这些值是否相等
  - lessThan
```
public boolean lessThan(int index1,
               int index2)
                 throws LuaMemoryAllocationException,
                        LuaRuntimeException
```
    返回第一个堆栈索引处的值是否小于第二个堆栈索引处的值（根据 Lua 语义）。
    
    参数
    index1 - 第一个堆栈索引
    index2 - 第二个堆栈索引
    
    返回
    第一个索引处的该值是否小于第二个索引处的该值
    
    抛出
    
    LuaMemoryAllocationException
    
    LuaRuntimeException
  - length
```
public int length(int index)
```
    返回指定的堆栈索引处的该值的长度。该长度的定义取决于该值类型。对于字符串，它是字符串的长度，对于表，它是长度运算符的结果。对于其他类型，返回值未定义。
    
    参数
    index - 堆栈索引
    
    返回
    长度
  - rawEqual
```
public boolean rawEqual(int index1,
               int index2)
```
    绕过元表逻辑，返回两个指定堆栈索引位置的值是否根据 Lua 语义相等。
    
    参数
    index1 - 第一个堆栈索引
    index2 - 第二个堆栈索引
    
    返回
    这些值是否相等
  - toBoolean
```
public boolean toBoolean(int index)
```
    返回指定的堆栈索引处的该值的布尔表示形式。对于 false 和 nil 以外的所有值，布尔表示形式为 true。
    
    参数
    index - 堆栈索引
    
    返回
    该值的布尔表示形式
  - toByteArray
```
public byte[] toByteArray(int index)
```
    返回指定的堆栈索引处的该值的字节数组表示形式。该值必须是字符串或数字。如果该值是数字，它会就地转换为字符串。否则，该方法返回 null。
    
    参数
    index - 堆栈索引
    
    返回
    该值的字节数组表示形式
  - toInteger
```
public int toInteger(int index)
```
    返回指定的堆栈索引处的该值的整数表示形式。该值必须是数字或可转换为数字的字符串。否则，该方法返回 0。
    
    参数
    index - 堆栈索引
    
    返回
    整数表示形式或 0
  - toJavaFunction
```
public JavaFunction toJavaFunction(int index)
```
    返回指定的堆栈索引处的该值的 Java 函数。如果该值不是 Java 函数，该方法返回 null。
    
    参数
    index - 堆栈索引
    
    返回
    Java 函数或 null
  - toJavaObjectRaw
```
public Object toJavaObjectRaw(int index)
```
    返回指定的堆栈索引处的该值的 Java 对象。如果该值不是 Java 对象，该方法返回 null。
    请注意，该方法不将值转换为 Java 对象。如果你需要表示指定索引处的该值的任何 Java 对象，则调用 toJavaObject(index, Object.class)。
    
    参数
    index - 堆栈索引
    
    返回
    Java 对象或 null
    另请参阅
    toJavaObject(int, Class)
  - toJavaObject
```
public <T> T toJavaObject(int index,
                 Class<T> type)
```
    返回表示指定的堆栈索引处的该值的指定类型的 Java 对象。该值必须可转换为指定类型的 Java 对象。该转换由配置的转换器执行。
    
    参数
    index - 堆栈索引
    type - 要转换到的 Java 类型
    
    返回
    该对象
    
    抛出
    
    ClassCastException - 如果转换器不支持该转换
    另请参阅
    getConverter()，setConverter(Converter)
  - toNumber
```
public double toNumber(int index)
```
    返回指定栈索引处的值的数字表示形式。该值必须是数字或可转换为数字的字符串。否则，该方法返回 0.0。
    
    参数
    index - 堆栈索引
    
    返回
    数字表示形式或 0.0
  - toPointer
```
public long toPointer(int index)
```
    返回指定栈索引处的值的指针表示形式。该值必须是一个表、线程、函数或用户数据（如 Java 对象）。否则，该方法返回 0L。不同的值返回不同的指针。除此之外，返回的值没有任何可移植意义。
    
    参数
    index - 堆栈索引
    
    返回
    指针表示形式或无时返回 0L
  - toString
```
public String toString(int index)
```
    返回指定栈索引处的值的字符串表示形式。该值必须是一个字符串或数字。如果该值为数字，它会就地转换为字符串。否则，该方法返回 null。
    
    参数
    index - 堆栈索引
    
    返回
    字符串表示形式或 null
  - type
```
public LuaType type(int index)
```
    返回指定堆栈索引处的值的类型。
    堆栈索引可能未定义。
    
    参数
    index - 堆栈索引
    
    返回
    类型，或者栈索引未定义时返回 null
  - typeName
```
public String typeName(int index)
```
    返回指定栈索引处类型的名称。类型名称是 Lua 类型的显示文本，但 Java 对象除外，Java 对象的类型名称是规范类名称。
    堆栈索引可能未定义。
    
    参数
    index - 索引
    
    返回
    类型名称
    另请参阅
    LuaType.displayText()，Class.getCanonicalName()
  - concat
```
public void concat(int n)
```
    连接堆栈顶部指定的多个值，并用连接后的值替换它们。
    
    参数
    n - 要连接的值的数量
  - getTop
```
public int getTop()
```
    返回栈上的值的数量。
    
    返回
    栈上的值的数量
  - insert
```
public void insert(int index)
```
    弹出栈顶值，将其插入指定索引处，并将该索引之上的元素上移。
    
    参数
    index - 堆栈索引
  - pop
```
public void pop(int count)
```
    从堆栈中弹出值。
    
    参数
    count - 要弹出的值的数量
  - pushValue
```
public void pushValue(int index)
```
    将指定索引位置的值推入堆栈顶端。
    
    参数
    index - 堆栈索引
  - remove
```
public void remove(int index)
```
    移除指定堆栈索引位置的值，并将该索引位置上方的元素下移。
    
    参数
    index - 堆栈索引
  - replace
```
public void replace(int index)
```
    使用从堆栈顶端弹出的值替换指定索引位置的值。
    
    参数
    index - 堆栈索引
  - setTop
```
public void setTop(int index)
```
    将指定索引设置为堆栈的新顶部。
    栈的最高点可能会高于当前的栈顶。在这种情况下，新值设为 nil。
    
    参数
    index - 栈的新顶部的索引
  - getTable
```
public void getTable(int index)
```
    在栈中压入表中指定索引处栈顶键所索引的值。键由表中的值替换。
    
    参数
    index - 包含表的栈索引
  - getField
```
public void getField(int index,
            String key)
```
    在栈上推送指定索引处的表中由指定字符串键索引的值。
    
    参数
    index - 包含表的栈索引
    key - 字符串键
  - newTable
```
public void newTable()
```
    创建一个新表并将其压入堆栈。
  - newTable
```
public void newTable(int arrayCount,
            int recordCount)
```
    创建一个新表，并预留一定数量的数组元素和记录元素所用的空间，然后将其压入堆栈中。
    
    参数
    arrayCount - 数组元素的数量
    recordCount - 记录元素的数量
  - next
```
public boolean next(int index)
```
    从栈中弹出一个键，并在栈中压入表中指定索引处的下一个键及其值。如果不存在下一个键，则弹出该键，但不压入任何内容。该方法返回是否存在下一个键。
    
    参数
    index - 包含表的栈索引
    
    返回
    是否存在下一个键
  - rawGet
```
public void rawGet(int index)
```
    绕过元表逻辑，在栈中压入表中指定索引处栈顶键所索引的值。键由表中的值替换。
    
    参数
    index - 包含表的栈索引
  - rawGet
```
public void rawGet(int index,
          int key)
```
    绕过元表逻辑，将指定索引位置的表中由指定整型键引用的值推入堆栈。
    
    参数
    index - 包含表的栈索引
    key - 整数键
  - rawSet
```
public void rawSet(int index)
```
    绕过元表逻辑，使用栈顶的值并在表中指定索引处设置栈中第二高的栈位置的值作为键。值和键均从栈中弹出。
    
    参数
    index - 包含表的栈索引
  - rawSet
```
public void rawSet(int index,
          int key)
```
    绕过元表逻辑，使用指定的整数键在表中指定索引处设置栈顶的值。值从栈中弹出。
    
    参数
    index - 包含表的栈索引
    key - 整数键
  - setTable
```
public void setTable(int index)
```
    使用第二个最高堆栈位置上的值作为键，在指定索引处的表中设置堆栈顶部的值。值和键都被从堆栈中弹出。
    
    参数
    index - 包含表的栈索引
  - setField
```
public void setField(int index,
            String key)
```
    使用指定的字符串键，在指定索引处的表中设置堆栈顶部的值。值从堆栈中弹出。
    
    参数
    index - 包含表的栈索引
    key - 字符串键
  - getMetafield
```
public boolean getMetafield(int index,
                   String key)
```
    在堆栈上推入指定索引处的值的元表的命名字段的值，并返回true。如果该值没有元表，或元表不包含命名字段，则不会推入任何内容，并且该方法返回false。
    
    参数
    index - 包含需要从中获取元字段的值的堆栈索引
    key - 字符串键
    
    返回
    是否将元字段推入堆栈
  - getMetatable
```
public boolean getMetatable(int index)
```
    在堆栈上推入指定索引处的值的元表。如果该值没有元表，则该方法返回false且不会推入任何内容。
    
    参数
    index - 包含需要从中获取元表的的值的堆栈索引
    
    返回
    是否将元表推入堆栈
  - setMetatable
```
public boolean setMetatable(int index)
```
    将堆栈顶部的值设置为指定索引处的值的元表。无论是否可以设置，都要从堆栈中弹出要设置的元表。
    
    参数
    index - 包含需要为其设置元表的的值的堆栈索引
    
    返回
    是否已设置元表
  - getFEnv
```
public void getFEnv(int index)
```
    在堆栈上推入指定索引处的值的环境表。如果该值没有环境表，则将nil推入堆栈。
    
    参数
    index - 包含需要从中获取环境表的的值的堆栈索引
  - setFEnv
```
public boolean setFEnv(int index)
```
    将堆栈顶部的值设置为指定索引处的值的环境表。无论是否可以设置，都要从堆栈中弹出要设置的环境表。
    
    参数
    index - 包含需要为其设置环境表的的值的堆栈索引
    
    返回
    是否已设置环境表
  - newThread
```
public void newThread()
```
    从堆栈弹出新 Lua 线程的启动函数，并使用该启动函数创建新线程。新线程被推入堆栈。
  - resume
```
public int resume(int index,
         int argCount)
```
    恢复指定堆栈索引处的线程，从堆栈顶部弹出指定数量的参数并将其传递到恢复的线程中。该方法返回作为恢复线程的返回值推入堆栈的值的数量。
    
    参数
    index - 包含线程的堆栈索引
    argCount - 要传递的参数数量
    
    返回
    线程返回的值数量
  - status
```
public int status(int index)
```
    返回指定堆栈索引处线程的状态。如果该线程处于初始状态或已完成执行，则该方法返回0。如果该线程已产生，则该方法返回 YIELD。其他返回值指示已引发异常的错误。
    
    参数
    index - 索引
    
    返回
    状态
  - yield
```
public int yield(int returnCount)
```
    产生正在运行的线程，从堆栈顶部弹出指定数量的值，并将其作为返回值传递给已恢复正在运行线程的线程。该方法必须在 Java 函数的退出点使用，即return luaState.yield(n)。
    
    参数
    returnCount - 要传递的结果数量
    
    返回
    Java 函数的返回值
  - ref
```
public int ref(int index)
```
    将堆栈顶部的值存储在指定索引处的表格中，并将该表格中该值对应的整数键作为引用返回。该值将从堆栈中弹出。
    
    参数
    index - 包含要存储该值的表格的堆栈索引
    
    返回
    引用整数键
    另请参阅
    unref(int, int)
  - unref
```
public void unref(int index,
         int reference)
```
    从指定索引处的表格中移除先前创建的引用。该值将从表格中移除，并且其引用的整数键将被释放以供重用。
    
    参数
    index - 包含存储该值的表格的堆栈索引
    reference - 引用整数键
    另请参阅
    ref(int)
  - tableSize
```
public int tableSize(int index)
```
    计算表中的条目数量。
    由于减少了 JNI 过渡，该方法在优化性能上优于相同功能的 Java 实现。
    
    参数
    index - 包含表的栈索引
    
    返回
    表格中条目的数量
  - tableMove
```
public void tableMove(int index,
             int from,
             int to,
             int count)
```
    将用作数组的表中指定数量的顺序元素从一个索引移动到另一个索引。
    由于减少了 JNI 过渡，该方法在优化性能上优于相同功能的 Java 实现。
    
    参数
    index - 包含表的栈索引
    from - 开始移动的索引
    to - 移动目标的索引
    count - 要移动的元素数量
  - checkArg
```
public void checkArg(int index,
            boolean condition,
            String msg)
```
    检查指定函数参数的条件是否为真。如果不为真，该方法会抛出 Lua 运行时异常并附带指定的错误消息。
    
    参数
    index - 参数索引
    condition - 条件
    msg - 错误消息
  - checkBoolean
```
public boolean checkBoolean(int index)
```
    检查指定函数参数的值是否为布尔值。如果是，则以布尔值的形式返回参数值。否则，该方法会抛出 Lua 运行时异常并附带描述性错误消息。
    
    参数
    index - 参数索引
    
    返回
    布尔值或默认值
  - checkBoolean
```
public boolean checkBoolean(int index,
                   boolean d)
```
    检查指定函数参数的值是否为布尔值。如果是，则以布尔值的形式返回参数值。如果指定参数的值未定义或为 nil，则该方法返回指定的默认值。否则，该方法会抛出 Lua 运行时异常并附带描述性错误消息。
    
    参数
    index - 参数索引
    d - 默认值
    
    返回
    布尔值
  - checkByteArray
```
public byte[] checkByteArray(int index)
```
    检查指定函数参数的值是否为字符串或数字。如果是，则以字节数组的形式返回参数值。否则，该方法会抛出 Lua 运行时异常并附带描述性错误消息。
    
    参数
    index - 参数索引
    
    返回
    字节数组值
  - checkByteArray
```
public byte[] checkByteArray(int index,
                    byte[] d)
```
    检查指定函数参数的值是否为字符串或数字。如果是，则以字节数组的形式返回参数值。如果指定参数的值未定义或为 nil，则该方法返回指定的默认值。否则，该方法会抛出 Lua 运行时异常并附带描述性错误消息。
    
    参数
    index - 参数索引
    d - 默认值
    
    返回
    字符串值或默认值
  - checkInteger
```
public int checkInteger(int index)
```
    检查指定函数参数的值是否为数字或可转换为数字的字符串。如果是，则以整数的形式返回参数值。否则，该方法会抛出 Lua 运行时异常并附带描述性错误消息。
    
    参数
    index - 参数索引
    
    返回
    整数值
  - checkInteger
```
public int checkInteger(int index,
               int d)
```
    检查指定函数参数的值是否为数字或可转换为数字的字符串。如果是，则以整数的形式返回参数值。如果指定参数的值未定义或为 nil，则该方法返回指定的默认值。否则，该方法会抛出 Lua 运行时异常并附带描述性错误消息。
    
    参数
    index - 参数索引
    d - 默认值
    
    返回
    整数值或默认值
  - checkNumber
```
public double checkNumber(int index)
```
    检查指定函数参数的值是否为数字或可转换为数字的字符串。如果是，则以数字的形式返回参数值。否则，该方法会抛出 Lua 运行时异常并附带描述性错误消息。
    
    参数
    index - 参数索引
    
    返回
    数字值
  - checkNumber
```
public double checkNumber(int index,
                 double d)
```
    检查指定函数参数值是否为一个数字或可转换为数字的字符串。如果是，则参数值作为数字返回。如果指定参数的值未定义或为nil，则方法返回指定的默认值。否则，该方法抛出一个带有描述性错误消息的 Lua 运行时异常。
    
    参数
    index - 参数索引
    d - 默认值
    
    返回
    数字值或默认值
  - checkJavaObject
```
public <T> T checkJavaObject(int index,
                    Class<T> clazz)
```
    检查指定函数参数值是否可以转换为指定类型的 Java 对象。如果是，则参数值作为指定类型的 Java 对象返回。否则，该方法抛出一个带有描述性错误消息的 Lua 运行时异常。
    请注意，转换器将nil转换为null。因此，如果值为nil，则该方法可能会返回null。
    
    参数
    index - 参数索引
    clazz - 预期类型
    
    返回
    Java 对象或 null
  - checkJavaObject
```
public <T> T checkJavaObject(int index,
                    Class<T> clazz,
                    T d)
```
    检查指定函数参数值是否可以转换为指定类型的 Java 对象。如果是，则参数值作为指定类型的 Java 对象返回。如果指定参数的值未定义或为nil，则方法返回指定的默认值。否则，该方法抛出一个带有描述性错误消息的 Lua 运行时异常。
    
    参数
    index - 参数索引
    clazz - 预期的类
    d - 默认值
    
    返回
    Java 对象或默认值
  - checkOption
```
public String checkOption(int index,
                 String[] options)
```
    检查指定函数参数的值是否为与指定选项之一匹配的字符串或数字。如果匹配，则参数值作为字符串返回。否则，该方法将抛出一个带有描述性错误消息的 Lua 运行时异常。
    
    参数
    index - 参数索引
    options - 选项
    
    返回
    字符串值
  - checkOption
```
public String checkOption(int index,
                 String[] options,
                 String d)
```
    检查指定函数参数的值是否为与指定选项之一匹配的字符串或数字。如果匹配，则参数值作为字符串返回。如果指定参数的值未定义或为nil，则方法返回指定的默认值。否则，该方法将抛出一个带有描述性错误消息的 Lua 运行时异常。
    
    参数
    index - 参数索引
    options - 选项
    d - 默认值
    
    返回
    字符串值或默认值
  - checkString
```
public String checkString(int index)
```
    检查指定函数参数的值是否为字符串或数字。如果匹配，则参数值作为字符串返回。否则，该方法将抛出一个带有描述性错误消息的 Lua 运行时异常。
    
    参数
    index - 参数索引
    
    返回
    字符串值
  - checkString
```
public String checkString(int index,
                 String d)
```
    检查指定函数参数的值是否为字符串或数字。如果匹配，则参数值作为字符串返回。如果指定参数的值未定义或为nil，则方法返回指定的默认值。否则，该方法将抛出一个带有描述性错误消息的 Lua 运行时异常。
    
    参数
    index - 参数索引
    d - 默认值
    
    返回
    字符串值或默认值
  - checkType
```
public void checkType(int index,
             LuaType type)
```
    检查指定函数参数的值是否为指定类型。如果不是，则该方法将抛出一个带有描述性错误消息的 Lua 运行时异常。
    
    参数
    index - 参数索引
    type - 类型
  - getProxy
```
public LuaValueProxy getProxy(int index)
```
    返回指定索引处 Lua 值的代理对象。
    
    参数
    index - 包含 Lua 值的堆栈索引
    
    返回
    Lua 值代理
  - getProxy
```
public <T> T getProxy(int index,
             Class<T> interfaze)
```
    返回实现 Lua 中指定接口的代理对象。位于指定堆栈索引处的表包含该接口中的方法名（作为键）以及实现接口方法的 Lua 函数（作为值）。返回的对象始终实现指定的接口以及 LuaValueProxy 接口。
    
    参数
    index - 包含表的栈索引
    interfaze - 接口
    
    返回
    代理对象
  - getProxy
```
public LuaValueProxy getProxy(int index,
                     Class<?>[] interfaces)
```
    以 Lua 中指定的接口列表形式返回一个代理对象，该对象实现这些接口。指定栈索引处的表包含接口中的方法名（作为键）和 Lua 函数（作为值），这些 Lua 函数负责实现接口方法。返回的对象始终会实现指定的接口，此外，它还会实现 LuaValueProxy 接口。
    
    参数
    index - 包含表的栈索引
    interfaces - 接口
    
    返回
    代理对象

类 LuaState

嵌套类摘要

字段摘要

构造函数摘要

方法摘要

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

字段详情

REGISTRYINDEX

ENVIRONINDEX

GLOBALSINDEX

MULTRET

YIELD

VERSION

LUA_VERSION

构造函数详情

LuaState

方法详情

getClassLoader

setClassLoader

getJavaReflector

setJavaReflector

getMetamethod

getConverter

setConverter

isOpen

close

gc

openLib

openLibs

register

register

load

load

dump

call

getGlobal

setGlobal

pushBoolean

pushInteger

pushJavaFunction

pushJavaObjectRaw

pushJavaObject

pushNil

pushNumber

pushString

pushString

pushString

isBoolean

isCFunction

isFunction

isJavaFunction

isJavaObjectRaw

isJavaObject

isNil

isNone

isNoneOrNil

isNumber

isString

isTable

isThread

equal

lessThan

length

rawEqual

toBoolean

toByteArray

toInteger

toJavaFunction

toJavaObjectRaw

toJavaObject

toNumber

toPointer

toString

type

typeName

concat

getTop

insert

pop