TripleTable (hutool-core 6.0.0-M13 API)

java.lang.Object
- org.dromara.hutool.core.map.TripleTable<L,M,R>

类型参数:

L - 左值类型

M - 中值类型

R - 右值类型

所有已实现的接口:

Serializable
```
public class TripleTable<L,M,R>
extends Object
implements Serializable
```
三值表结构，可重复
用于提供三种值相互查找操作
查找方式为indexOf方式遍历查找，数据越多越慢。

作者:

looly

从以下版本开始:

6.0.0

另请参阅:

序列化表格

构造器概要

构造器
构造器和说明
`TripleTable(int size)` 构造
`TripleTable(List<L> lefts, List<M> middles, List<R> rights)`
`TripleTable(List<Triple<L,M,R>> triples)` 构造

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`TripleTable<L,M,R>`	`clear()` 清空
`boolean`	`containLeft(L left)` 是否含有指定左元素
`boolean`	`containMiddle(M middle)` 是否含有指定中元素
`boolean`	`containRight(R right)` 是否含有指定右元素
`Triple<L,M,R>`	`getByLeft(L lValue)` 通过左值查找三元组（所有值）
`Triple<L,M,R>`	`getByMiddle(M mValue)` 通过中值查找三元组（所有值）
`Triple<L,M,R>`	`getByRight(R rValue)` 通过右值查找三元组（所有值）
`L`	`getLeft(int index)` 获取指定index对应的左值
`L`	`getLeftByMiddle(M mValue)` 通过中间值，查找左边值如果有多个重复值，只返回找到的第一个值
`L`	`getLeftByRight(R rValue)` 通过右值，查找左边值如果有多个重复值，只返回找到的第一个值
`List<L>`	`getLefts()` 获取左列表，不可修改
`M`	`getMiddle(int index)` 获取指定index对应的中值
`M`	`getMiddleByLeft(L lValue)` 通过左值，查找中值如果有多个重复值，只返回找到的第一个值
`M`	`getMiddleByRight(R rValue)` 通过右值，查找中值如果有多个重复值，只返回找到的第一个值
`List<M>`	`getMiddles()` 获取中列表，不可修改
`R`	`getRight(int index)` 获取指定index对应的右值
`R`	`getRightByLeft(L lValue)` 通过左值，查找右值如果有多个重复值，只返回找到的第一个值
`R`	`getRightByMiddle(M mValue)` 通过中间值，查找右值如果有多个重复值，只返回找到的第一个值
`List<R>`	`getRights()` 获取右列表，不可修改
`int`	`indexOfLeft(L left)` 获取指定左元素的索引
`int`	`indexOfMiddle(M middle)` 获取指定中元素的索引
`int`	`indexOfRight(R right)` 获取指定右元素的索引
`TripleTable<L,M,R>`	`put(L lValue, M mValue, R rValue)` 加入值
`TripleTable<L,M,R>`	`remove(int index)` 移除值
`TripleTable<L,M,R>`	`setLeft(int index, L lValue)` 修改指定index对应的左值
`TripleTable<L,M,R>`	`setMiddle(int index, M mValue)` 修改指定index对应的中值
`TripleTable<L,M,R>`	`setRight(int index, R rValue)` 修改指定index对应的右值
`int`	`size()` 长度

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

- 构造器详细资料
  - TripleTable
```
public TripleTable(List<Triple<L,M,R>> triples)
```
    构造
    
    参数:
    
    triples - 三元组列表
  - TripleTable
```
public TripleTable(int size)
```
    构造
    
    参数:
    
    size - 初始容量
  - TripleTable
```
public TripleTable(List<L> lefts,
                   List<M> middles,
                   List<R> rights)
```
    参数:
    
    lefts - 左列表
    
    middles - 中列表
    
    rights - 右列表
- 方法详细资料
  - getLeftByMiddle
```
public L getLeftByMiddle(M mValue)
```
    通过中间值，查找左边值
    如果有多个重复值，只返回找到的第一个值
    
    参数:
    
    mValue - 中间值
    
    返回:
    
    左边值，未找到返回null
  - getLeftByRight
```
public L getLeftByRight(R rValue)
```
    通过右值，查找左边值
    如果有多个重复值，只返回找到的第一个值
    
    参数:
    
    rValue - 右值
    
    返回:
    
    左边值，未找到返回null
  - getMiddleByLeft
```
public M getMiddleByLeft(L lValue)
```
    通过左值，查找中值
    如果有多个重复值，只返回找到的第一个值
    
    参数:
    
    lValue - 左值
    
    返回:
    
    中值，未找到返回null
  - getMiddleByRight
```
public M getMiddleByRight(R rValue)
```
    通过右值，查找中值
    如果有多个重复值，只返回找到的第一个值
    
    参数:
    
    rValue - 右值
    
    返回:
    
    中值，未找到返回null
  - getLeft
```
public L getLeft(int index)
```
    获取指定index对应的左值
    
    参数:
    
    index - 索引
    
    返回:
    
    左值
  - getMiddle
```
public M getMiddle(int index)
```
    获取指定index对应的中值
    
    参数:
    
    index - 索引
    
    返回:
    
    中值
  - getRight
```
public R getRight(int index)
```
    获取指定index对应的右值
    
    参数:
    
    index - 索引
    
    返回:
    
    右值
  - getRightByLeft
```
public R getRightByLeft(L lValue)
```
    通过左值，查找右值
    如果有多个重复值，只返回找到的第一个值
    
    参数:
    
    lValue - 左值
    
    返回:
    
    右值，未找到返回null
  - getRightByMiddle
```
public R getRightByMiddle(M mValue)
```
    通过中间值，查找右值
    如果有多个重复值，只返回找到的第一个值
    
    参数:
    
    mValue - 中间值
    
    返回:
    
    右值，未找到返回null
  - containLeft
```
public boolean containLeft(L left)
```
    是否含有指定左元素
    
    参数:
    
    left - 左元素
    
    返回:
    
    是否含有
  - containMiddle
```
public boolean containMiddle(M middle)
```
    是否含有指定中元素
    
    参数:
    
    middle - 中元素
    
    返回:
    
    是否含有
  - containRight
```
public boolean containRight(R right)
```
    是否含有指定右元素
    
    参数:
    
    right - 右元素
    
    返回:
    
    是否含有
  - indexOfLeft
```
public int indexOfLeft(L left)
```
    获取指定左元素的索引
    
    参数:
    
    left - 左元素
    
    返回:
    
    索引，未找到返回-1
  - indexOfMiddle
```
public int indexOfMiddle(M middle)
```
    获取指定中元素的索引
    
    参数:
    
    middle - 中元素
    
    返回:
    
    索引，未找到返回-1
  - indexOfRight
```
public int indexOfRight(R right)
```
    获取指定右元素的索引
    
    参数:
    
    right - 右元素
    
    返回:
    
    索引，未找到返回-1
  - getByLeft
```
public Triple<L,M,R> getByLeft(L lValue)
```
    通过左值查找三元组（所有值）
    
    参数:
    
    lValue - 左值
    
    返回:
    
    三元组（所有值）
  - getByMiddle
```
public Triple<L,M,R> getByMiddle(M mValue)
```
    通过中值查找三元组（所有值）
    
    参数:
    
    mValue - 中值
    
    返回:
    
    三元组（所有值）
  - getByRight
```
public Triple<L,M,R> getByRight(R rValue)
```
    通过右值查找三元组（所有值）
    
    参数:
    
    rValue - 右值
    
    返回:
    
    三元组（所有值）
  - getLefts
```
public List<L> getLefts()
```
    获取左列表，不可修改
    
    返回:
    
    左列表
  - getMiddles
```
public List<M> getMiddles()
```
    获取中列表，不可修改
    
    返回:
    
    中列表
  - getRights
```
public List<R> getRights()
```
    获取右列表，不可修改
    
    返回:
    
    右列表
  - size
```
public int size()
```
    长度
    
    返回:
    
    this
  - put
```
public TripleTable<L,M,R> put(L lValue,
                              M mValue,
                              R rValue)
```
    加入值
    
    参数:
    
    lValue - 左值
    
    mValue - 中值
    
    rValue - 右值
    
    返回:
    
    this
  - setLeft
```
public TripleTable<L,M,R> setLeft(int index,
                                  L lValue)
```
    修改指定index对应的左值
    
    参数:
    
    index - 索引
    
    lValue - 左值
    
    返回:
    
    this
  - setMiddle
```
public TripleTable<L,M,R> setMiddle(int index,
                                    M mValue)
```
    修改指定index对应的中值
    
    参数:
    
    index - 索引
    
    mValue - 中值
    
    返回:
    
    this
  - setRight
```
public TripleTable<L,M,R> setRight(int index,
                                   R rValue)
```
    修改指定index对应的右值
    
    参数:
    
    index - 索引
    
    rValue - 左值
    
    返回:
    
    this
  - clear
```
public TripleTable<L,M,R> clear()
```
    清空
    
    返回:
    
    this
  - remove
```
public TripleTable<L,M,R> remove(int index)
```
    移除值
    
    参数:
    
    index - 序号
    
    返回:
    
    this

类 TripleTable<L,M,R>

构造器概要

方法概要

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

构造器详细资料

TripleTable

TripleTable

TripleTable

方法详细资料

getLeftByMiddle

getLeftByRight

getMiddleByLeft

getMiddleByRight

getLeft

getMiddle

getRight

getRightByLeft

getRightByMiddle

containLeft

containMiddle

containRight

indexOfLeft

indexOfMiddle

indexOfRight

getByLeft

getByMiddle

getByRight

getLefts

getMiddles

getRights

size

put

setLeft

setMiddle

setRight

clear

remove