结构

不变

python中一种结构，叫做元组。

能切片，能遍历，能迭代，就是不能修改。

guava中也有，好处多多，而且底层做了更多，效率更高。

不能修改，仅此而已。

JDK	Guava
Collection	ImmutableCollection
List	ImmutableList
Set	ImmutableSet
SortedSet	ImmutableSortedSet
Map	ImmutableMap
SortedMap	ImmutableSortedMap

• 构造

方法(Immutable*)	说明
of	收集组合
copyOf	从数据集生成
sortedCopyOf	先排序，后生成
builder	构造器

Immutable*，看使用的是啥数据结构。

List的话就是ImmutableList。

        ImmutableList.of(1,2,3,4,5,6,7,8,9).asList();
        ImmutableList.copyOf(new Integer[]{
    1,2,3,4,5,6,7,8,9}).asList();
        ImmutableList.copyOf(Arrays.asList(1,2,3,4,5,6,7,8,9)).asList();
        ImmutableList.builder()
                .add(1)
                .add(2,3,4)
                .add(new Integer[]{
    5,6})
                .addAll(Arrays.asList(7,8,9))
                .build().asList();

单个的，数组，迭代对象，都可以。

asList返回的结构，比一般效率还会更高。

• 其他

使用的话，contains，get…和基本的使用方法一致。

• 更多

新结构	不变结构
Multiset	ImmutableMultiset
SortedMultiset	ImmutableSortedMultiset
Multimap	ImmutableMultimap
ListMultimap	ImmutableListMultimap
SetMultimap	ImmutableSetMultimap
BiMap	ImmutableBiMap
ClassToInstanceMap	ImmutableClassToInstanceMap
Table	ImmutableTable

这些都是guava中的新结构，后面叙述。

Multiset

• 实现类

类别	底层实现	支持null
HashMultiset	HashMap	true
TreeMultiset	TreeMap	true 看compartor是否支持
LinkedHashMultiset	LinkedHashMap	true
ConcurrentHashMultiset	ConcurrentHashMap	false
ImmutableMultiset	ImmutableMap	false

• 相关方法

方法	描述
count(E)	计数
elementSet()	元素set
entrySet()	键值对set
add(E, int)	增加计数
remove(E, int)	减少计数
setCount(E, int)	设置计数 不可为负
size()	数量
addAll(iterator)	添加全部

• 实验

    public static void main(String[] args) {
    
        HashMultiset<Integer> integers = HashMultiset.create();
        integers.addAll(Arrays.asList(1,2,3,4,5,6,7,8,9,1,2,3,4,8,9));
        integers.forEach(value-> System.out.println("value : " + value + "\tcount : " + integers.count(value)));
    }

可以看到，不会真的是set，仍然有重复。

    public static void main(String[] args) {
    
        HashMultiset<Integer> integers = HashMultiset.create();
        integers.addAll(Arrays.asList(1,2,3,4,5,6,7,8,9,1,2,3,4,8,9));
        integers
            .elementSet()
            .forEach(value-> System.out.println("value : " + value + "\tcount : " + integers.count(value)));
    }

去重效果更佳。

• SortedMultiset

特异化结构，排序后加速范围限定查询。

Multimap

Map<K, List>，这个结构用的不会少。

一对多不会只有数据库才会存在，不过Map<K, List>是真的蠢。

于是Multimap出现了。

• 实现类

实现类	key行为	value行为
ArrayListMultimap	HashMap	ArrayList
HashMultimap	HashMap	HashSet
LinkedListMultimap*	LinkedHashMap*	LinkedList*
LinkedHashMultimap**	LinkedHashMap	LinkedHashMap
TreeMultimap	TreeMap	TreeSet
ImmutableListMultimap	ImmutableMap	ImmutableList
ImmutableSetMultimap	ImmutableMap	ImmutableSet

key和value到底是什么结构的呢，自己取舍吧。

• 方法

方法	作用
get(key)	获取value
put(K, V)	增加单个value
putAll(K, Iterabl e)	增加多个value
remove(K, V)	移除单个value
removeAll(K)	移除多个value
replaceValues(K, Ite rable)	替换value
asMap	转换为Map
entries	键值对
keySet	键集合
keys	键列表
values()	值列表

• 实验

    public static void main(String[] args) {
    
        HashMultimap<String, String> hashMultimap = HashMultimap.create();
        hashMultimap.put("godme", "人民银行");
        hashMultimap.put("godme", "招商银行");
        hashMultimap.keySet().forEach(item -> {
    
            hashMultimap.get(item).forEach(item2 -> {
    
                System.out.println("account : " + item + "\tbank : " + item2);
            });
        });
    }

更多办法，需要再自测。

*有特殊操作，可以自行查阅文档，支持PDF下载哦。

BiMap

一般时候都是key->value，不过有时候也需要value->key。

不过维护两个Map实在操蛋，现在方便多了。

• 实现类

实现	key->value	value->key
HashBiMap	HashMap	HashMap
ImmutableBiMap	ImmutableMap	ImmutableMap
EnumBiMap	EnumMap	EnumMap
EnumHashBiMap	EnumMap	EnumMap

• 使用

    public static void main(String[] args) {
    
        HashBiMap<String, String> map = HashBiMap.create();
        map.forcePut("key", "value");
        System.out.println(map.inverse().get("value"));
    }

更多操作办法…可以翻源码。

记住就行，用到会查就行，记太多也不一定用到。

table

    public static void main(String[] args) {
    
        HashBasedTable<Integer,Integer ,Integer> table = HashBasedTable.create();
        table.put(1,1,11);
        table.put(2,2,22);
        table.column(1).put(2, 21);
        table.row(1).put(2, 12);
        System.out.println(table);
    }

row/column	1	2
1	11	12
2	21	22

反正我还用不到，看着就蛋疼。

ClassToInstanceMap

    public static void main(String[] args) {
    
        MutableClassToInstanceMap<Integer> table = MutableClassToInstanceMap.create();
        table.put(Integer.class, 12);
        table.put(Integer.class, 34);
        table.put(Integer.class, 56);
        table.put(Integer.class, 78);
        System.out.println(table.get(Integer.class));
    }

单例模式么这个，用不上。

RangeSet

    public static void main(String[] args) {
    
        TreeRangeSet<Integer> rangeSet = TreeRangeSet.create();
        rangeSet.add(Range.closed(1,2));
        rangeSet.add(Range.closed(2,3));
        rangeSet.add(Range.open(3,4));
        rangeSet.add(Range.closedOpen(5,6));
        rangeSet.add(Range.openClosed(7,8));
        System.out.println(rangeSet);
    }

数轴区间啊这是。

• 查询

方法	作用
contains(C)	区间是否包含元素
rangeContaining(C)	返回包含区间 不包含回null
encloses(Range)	区间是否包含区间
span()	最小区间

• 操作

方法	作用
complement()	补集
subRangeSet(Range)	交集
asRanges()	Range-Set Range的set

RangeMap

rangeMap.put(Range.open(3, 6), "bar");

• 为指定区间打标记。
• 区间交集不合并

• 方法

方法	作用
asMapOfRanges()	Range-Map
subRangeMap(Range)	交集

工具

Iterables

方法	连接
concat(Iterable)	连接
frequency(Iterable, Object)	统计
partition(Iterable, in t)	拆分
elementsEqual(Iterable, Iterable)	比较
limit(Iterable, int)	限制
addAll(Collection addT o, Iterable toAdd)	添加
contains(Iterable, Object)	包含

更多方法自己查阅，毕竟结构体都不熟悉，看这些未免有点画蛇添足。

自定义

装饰(Forwarding*)

public class Null {
    
    public static void main(String[] args) {
    
        MyList list = new MyList<Integer>(56);
    }

    public static class MyList<T> extends ForwardingList {
    
        private ArrayList<T> sourceStruct;

        public MyList(int size) {
    
            sourceStruct = new ArrayList(size);
        }

        @Override
        protected List delegate() {
    
            return sourceStruct;
        }

    }
}

delegate：返回一个根源的数据管理对象即可

然后根据想拦截的方法进行改造即可。

Forwarding*：固定前缀，后面可选好多结构体

AbstractIterator

        new AbstractIterator<Integer>(){
    
            @Override
            protected Integer computeNext() {
    
                return null;
            }
        };

内嵌一下，包装一下。

不过我感觉第一个就够我用了，其他的不看了。

总结

水平不够，我用得上的就是那些新结构。

太高深的也用不上，更别说一些操作方法。

不用就说不上理解，脱离了实际使用都是空中楼阁。

先把那些蠢笨的办法换成流畅的数据结构再说吧。