allbet网址:Guava聚集--新聚集类型

admin 2个月前 (07-18) 科技 32 0

 

Guava引入了许多JDK没有的、但我们发现显著有用的新聚集类型。这些新类型是为了和JDK聚集框架共存,而没有往JDK聚集抽象中硬塞其他观点。作为一样平常规则,Guava聚集异常精准地遵照了JDK接口左券。

一.Multiset

1.统计一个词在文档中泛起了多少次,传统的做法是这样的:

Map<String, Integer> counts = new HashMap<String, Integer>();

for (String word : words) {

    Integer count = counts.get(word);

    if (count == null) {

        counts.put(word, 1);

    } else {

        counts.put(word, count + 1);

    }

}

这种写法很拙笨,也容易失足,而且不支持同时网络多种统计信息,如总词数。我们可以做的更好。

 

2.Guava提供了多种Multiset的实现,大致对应JDK中Map的种种实现:

Map 对应的Multiset 是否支持null元素
HashMap HashMultiset
TreeMap TreeMultiset 是(若是comparator支持的话)
LinkedHashMap LinkedHashMultiset
ConcurrentHashMap ConcurrentHashMultiset
ImmutableMap ImmutableMultiset

3.Multiset的方式如下

方式 形貌
count(E) 给定元素在Multiset中的计数
elementSet() Multiset中不重复元素的聚集,类型为Set<E>
entrySet() 和Map的entrySet类似,返回Set<Multiset.Entry<E>>,其中包罗的Entry支持getElement()和getCount()方式
add(E, int) 增添给定元素在Multiset中的计数
remove(E, int) 削减给定元素在Multiset中的计数
setCount(E, int) 设置给定元素在Multiset中的计数,不能以为负数
size() 返回聚集元素的总个数(包罗重复的元素)
package collections;

import com.google.common.collect.HashMultiset;
import com.google.common.collect.Lists;
import com.google.common.collect.Multiset;

import java.util.Set;

public class GuavaMultiset {
    public static void main(String[] args) {
        Multiset<String> multiset = HashMultiset.create();
        multiset.addAll( Lists.newArrayList("I","love","China","China","is","my","love"));

        int love = multiset.count("love");
        System.out.println("love num:" + love);

        Set<String> elementSet = multiset.elementSet();
        System.out.println("Multiset中不重复元素的聚集,类型为Set<E>:" + elementSet);

        Set<Multiset.Entry<String>> entries = multiset.entrySet();//统计元素频次
        System.out.println("entrySet:" + entries);//[love x 2, China x 2, I, is, my]

        multiset.add("add",2);
        System.out.println("增添add后的数据:" + multiset);

        multiset.remove("add",2);
        System.out.println("移除add后的数据:" + multiset);

        multiset.setCount("love", 1);
        System.out.println("设置love计数为1后的数据:" + multiset);

        System.out.println("返回聚集中的总个数:" + multiset.size());
    }
}

运行效果:

 

可以用两种方式看待Multiset:

  • 没有元素顺序限制的ArrayList<E>
  • Map<E, Integer>,键为元素,值为计数

Guava的Multiset API也连系思量了这两种方式:
当把Multiset看成通俗的Collection时,它显示得就像无序的ArrayList:

  • add(E)添加单个给定元素
  • iterator()返回一个迭代器,包罗Multiset的所有元素(包罗重复的元素)
  • size()返回所有元素的总个数(包罗重复的元素)

当把Multiset看作Map<E, Integer>时,它也提供了相符性能期望的查询操作:

  • count(Object)返回给定元素的计数。HashMultiset.count的庞大度为O(1),TreeMultiset.count的庞大度为O(log n)。
  • entrySet()返回Set<Multiset.Entry<E>>,和Map的entrySet类似。
  • elementSet()返回所有不重复元素的Set<E>,和Map的keySet()类似。
  • 所有Multiset实现的内存消耗随着不重复元素的个数线性增进。

值得注重的是,除了极少数情形,Multiset和JDK中原有的Collection接口左券完全一致——详细来说,TreeMultiset在判断元素是否相等时,与TreeSet一样用compare,而不是Object.equals。另外特别注重,Multiset.addAll(Collection)可以添加Collection中的所有元素并举行计数,这比用for循环往Map添加元素和计数利便多了。

 

二.Multimap

1.传统实现

每个有履历的Java程序员都在某处实现过Map<K, List<V>>或Map<K, Set<V>>,而且要忍受这个结构的拙笨,以便做响应的营业逻辑处置。例如:

     Map<String, List<Student>> studentMap = new HashMap<>();
        for (int i = 0; i < 5; i++) {
            Student student = new Student();
            student.setName("multimap"+i);
            student.setAge(i);
            List<Student> list = studentMap.get(student.getName());
            if (list != null) {
                list.add(student);
            } else {
                list = new ArrayList<>();
                list.add(student);
                studentMap.put(student.getName(), list);
            }
            
        }

像 Map<String, List<StudentScore>> StudentScoreMap = new HashMap<String, List<StudentScore>>()这样的数据结构,自己实现起来太贫苦,你需要检查key是否存在,不存在时则建立一个,存在时在List后面添加上一个。这个历程是对照痛苦的,若是你希望检查List中的工具是否存在,删除一个工具,或者遍历整个数据结构,那么则需要更多的代码来实现。

2.关于Multimap

Guava的Multimap就提供了一个利便地把一个键对应到多个值的数据结构。让我们可以简朴优雅的实现上面庞大的数据结构,让我们的精神和时间放在实现营业逻辑上,而不是在数据结构上,下面我们详细来看看Multimap的相关知识点。

可以用两种方式思索Multimap的观点:”键-单个值映射”的聚集:

a -> 1 a -> 2 a ->4 b -> 3 c -> 5

或者”键-值聚集映射”的映射:

a -> [1, 2, 4] b -> 3 c -> 5

一样平常来说,Multimap接口应该用第一种方式看待,但asMap()视图返回Map<K, Collection<V>>,让你可以按另一种方式看待Multimap。主要的是,不会有任何键映射到空聚集:一个键要么至少到一个值,要么基本就不在Multimap中。

很少会直接使用Multimap接口,更多时刻你会用ListMultimap或SetMultimap接口,它们分别把键映射到List或Set。

3.Multimap的方式有:

方式署名 形貌 等价于
put(K, V) 添加键到单个值的映射 multimap.get(key).add(value)
putAll(K, Iterable<V>) 依次添加键到多个值的映射 Iterables.addAll(multimap.get(key), values)
remove(K, V) 移除键到值的映射;若是有这样的键值并乐成移除,返回true。 multimap.get(key).remove(value)
removeAll(K) 消灭键对应的所有值,返回的聚集包罗所有之前映射到K的值,但修改这个聚集就不会影响Multimap了。 multimap.get(key).clear()
replaceValues(K, Iterable<V>) 消灭键对应的所有值,并重新把key关联到Iterable中的每个元素。返回的聚集包罗所有之前映射到K的值。 multimap.get(key).clear(); Iterables.addAll(multimap.get(key), values)

例子:

package collections;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;

import java.util.ArrayList;
import java.util.List;

public class GuavaMultimap {
    public static void main(String[] args) {
        Multimap<String,Student> stuMultimap = ArrayListMultimap.create();
        Student student1 = new Student();
        student1.setName("student1");
        student1.setAge(1);
        stuMultimap.put("student",student1);
        stuMultimap.put("student1",student1);
        System.out.println("-------------put(K, V),添加键到单个值的映射---------------");
        System.out.println(stuMultimap);

        Student student2 = new Student();
        student2.setName("student2");
        student2.setAge(2);
        Student student3 = new Student();
        student3.setName("student3");
        student3.setAge(3);
        List<Student> stuList = new ArrayList<>();
        stuList.add(student2);
        stuList.add(student3);
        stuMultimap.putAll("student2and3",stuList);
        System.out.println("-------------putAll(K, Iterable<V>),依次添加键到多个值的映射---------------");
        System.out.println(stuMultimap);

        stuMultimap.remove("student",student1);
        System.out.println("-------------remove(K, V),移除键到值的映射;若是有这样的键值并乐成移除,返回true。---------------");
        System.out.println(stuMultimap);

        stuMultimap.removeAll("student2and3");
        System.out.println("-------------removeAll(K),消灭键对应的所有值,返回的聚集包罗所有之前映射到K的值,但修改这个聚集就不会影响Multimap了。---------------");
        System.out.println(stuMultimap);

        stuMultimap.replaceValues("student1",stuList);
        System.out.println("-------------replaceValues(K, Iterable<V>),消灭键对应的所有值,并重新把key关联到Iterable中的每个元素。返回的聚集包罗所有之前映射到K的值。---------------");
        System.out.println(stuMultimap);
    }
}

运行效果:

 

 

4.Multimap的种种实现

Multimap提供了多种形式的实现。在大多数要使用Map<K, Collection<V>>的地方,你都可以使用它们:

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

 

以上这些实现,除了immutable的实现都支持null的键和值。

*LinkedListMultimap.entries()保留了所有键和值的迭代顺序。

**LinkedHashMultimap保留了映射项的插入顺序,包罗键插入的顺序,以及键映射的所有值的插入顺序。

请注重,并非所有的Multimap都和上面列出的一样,使用Map<K, Collection<V>>来实现(特别是,一些Multimap实现用了自界说的hashTable,以最小化开销)

若是你想要更大的定制化,请用Multimaps.newMultimap(Map, Supplier<Collection>)或list和 set版本,使用自界说的Collection、List或Set实现Multimap。

 

 5.Multimap也支持一系列壮大的视图功效:  

  1.asMap把自身Multimap<K, V>映射成Map<K, Collection<V>>视图。这个Map视图支持remove和修改操作,然则不支持put和putAll。严格地来讲,当你希望传入参数是不存在的key,而且你希望返回的是null而不是一个空的可修改的聚集的时刻就可以挪用   asMap().get(key)。(你可以强制转型asMap().get(key)的效果类型-对SetMultimap的效果转成Set,对ListMultimap的效果转成List型-然则直接把ListMultimap转成Map<K, List<V>>是不行的。)
  2.entries视图是把Multimap里所有的键值对以Collection<Map.Entry<K, V>>的形式展现。
  3.keySet视图是把Multimap的键聚集作为视图
  4.keys视图返回的是个Multiset,这个Multiset是以不重复的键对应的个数作为视图。这个Multiset可以通过支持移除操作而不是添加操作来修改Multimap。
  5.values()视图能把Multimap里的所有值“平展”成一个Collection<V>。这个操作和Iterables.concat(multimap.asMap().values())很相似,只是它返回的是一个完整的Collection。

  只管Multimap的实现用到了Map,但Multimap<K, V>不是Map<K, Collection<V>>。由于两者有显著区别:
  1.Multimap.get(key)一定返回一个非null的聚集。但这不示意Multimap使用了内存来关联这些键,相反,返回的聚集只是个允许添加元素的视图。
  2.若是你喜欢像Map那样当不存在键的时刻要返回null,而不是Multimap那样返回空聚集的话,可以用asMap()返回的视图来获得Map<K, Collection<V>>。(这种情形下,你得把返回的Collection<V>强转型为List或Set)。
  3.Multimap.containsKey(key)只有在这个键存在的时刻才返回true。
  4.Multimap.entries()返回的是Multimap所有的键值对。然则若是需要key-collection的键值对,那就得用asMap().entries()。
  5.Multimap.size()返回的是entries的数目,而不是不重复键的数目。若是要获得不重复键的数目就得用Multimap.keySet().size()。

例子:

package collections;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multiset;

import java.util.Collection;
import java.util.Map;
import java.util.Set;

public class GuavaMultimap {
    public static void main(String[] args) {
        Multimap<String,Student> stuMultimap = ArrayListMultimap.create();
        Student student1 = new Student();
        student1.setName("student1");
        student1.setAge(1);
        Student student2 = new Student();
        student2.setName("student2");
        student2.setAge(2);
        Student student3 = new Student();
        student3.setName("student3");
        student3.setAge(3);
        stuMultimap.put("student1",student1);
        stuMultimap.put("student2and3",student2);
        stuMultimap.put("student2and3",student3);

        Map<String, Collection<Student>> stringCollectionMap = stuMultimap.asMap();
        System.out.println("-------------asMap把自身Multimap<K, V>映射成Map<K, Collection<V>>视图。---------------");
        System.out.println(stringCollectionMap);

        Collection<Map.Entry<String, Student>> entries = stuMultimap.entries();
        System.out.println("-------------entries视图是把Multimap里所有的键值对以Collection<Map.Entry<K, V>>的形式展现。---------------");
        System.out.println(entries);

        Set<String> strings = stuMultimap.keySet();
        System.out.println("-------------keySet视图是把Multimap的键聚集作为视图---------------");
        System.out.println(strings);

        Multiset<String> keys = stuMultimap.keys();
        System.out.println("-------------keys视图返回的是个Multiset,这个Multiset是以不重复的键对应的个数作为视图。这个Multiset可以通过支持移除操作而不是添加操作来修改Multimap。---------------");
        System.out.println(keys);

        Collection<Student> values = stuMultimap.values();
        System.out.println("-------------values()视图能把Multimap里的所有值“平展”成一个Collection<V>。---------------");
        System.out.println(values);

        Collection<Student> stus = stuMultimap.get("student1");
        System.out.println("-------------Multimap.get(key)一定返回一个非null的聚集。---------------");
        System.out.println(stus);

        boolean student1Key = stuMultimap.containsKey("student1");
        System.out.println("-------------Multimap.containsKey(key)只有在这个键存在的时刻才返回true。---------------");
        System.out.println(student1Key);

        int size = stuMultimap.size();
        System.out.println("-------------Multimap.size()返回的是entries的数目,而不是不重复键的数目。---------------");
        System.out.println(size);
    }
}

运行效果:

 

三.BiMap

  信赖有许多开发者会遇到这种情形:在开发的历程中,界说了一个Map,往往是通过key来查找value的,但若是需要通过value来查找key,我们就需要分外编写一些代码了。

  恰好BiMap提供了一种新的聚集类型,它提供了key和value的双向关联的数据结构。下面我们来看看这两者的实现:

1.传统的做法:

package com.guava;

import java.util.Map;
import java.util.Map.Entry;

import com.google.common.collect.Maps;

public class BiMapTest {
    
    public static void main(String[] args) {
        Map<Integer,String> idToName = Maps.newHashMap();
        idToName.put(1,"zhangsan");
        idToName.put(2,"lisi");
        idToName.put(3,"wangwu");
        
        System.out.println("idToName:"+idToName);     
        
        Map<String,Integer> nameToId = Maps.newHashMap();
        for(Entry<Integer, String> entry: idToName.entrySet()) {
            nameToId.put(entry.getValue(), entry.getKey());
        }
        System.out.println("nameToId:"+nameToId);
    }

}

运行效果:

 

 

上面的代码可以辅助我们实现map倒转的要求,然则另有一些我们需要思量的问题:
   1. 若何处置重复的value的情形。不思量的话,反转的时刻就会泛起笼罩的情形.
      2. 若是在反转的map中增添一个新的key,倒转前的map是否需要更新一个值呢?
在这种情形下需要思量的营业以外的内容就增添了,编写的代码也变得不那么易读了。这时我们就可以思量使用Guava中的BiMap了。 

2.使用Guava中的BiMap

package com.guava;

import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;

public class BiMapTest {
    
    public static void main(String[] args) {
        BiMap<Integer,String> idToName = HashBiMap.create();
        idToName.put(1,"zhangsan");
        idToName.put(2,"lisi");
        idToName.put(3,"wangwu");
        
        System.out.println("idToName:"+idToName);
        
        BiMap<String,Integer> nameToId = idToName.inverse();
        
        System.out.println("nameToId:"+nameToId);
    }

}

运行效果:

 

 3.关于Bimap数据的强制唯一性

在使用BiMap举行key、value反转时,会要求Value的唯一性。若是value重复了则会抛失足误:java.lang.IllegalArgumentException,例如:

package com.guava;

import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;

public class BiMapTest {
    
    public static void main(String[] args) {
        BiMap<Integer,String> idToName = HashBiMap.create();
        idToName.put(1,"zhangsan");
        idToName.put(2,"lisi");
        idToName.put(3,"wangwu");
        idToName.put(4, "wangwu");
        
        System.out.println("idToName:"+idToName);
        
        BiMap<String,Integer> nameToId = idToName.inverse();
        
        System.out.println("nameToId:"+nameToId);
    }

}

运行效果:

 

 若是我们确实需要插入重复的value值,那可以选择forcePut方式。然则我们需要注重的是前面的key也会被笼罩了。

package com.guava;

import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;

public class BiMapTest {
    
    public static void main(String[] args) {
        BiMap<Integer,String> idToName = HashBiMap.create();
        idToName.put(1,"zhangsan");
        idToName.put(2,"lisi");
        idToName.put(3,"wangwu");
        idToName.forcePut(4, "wangwu");
        
        System.out.println("idToName:"+idToName);
        
        BiMap<String,Integer> nameToId = idToName.inverse();
        
        System.out.println("nameToId:"+nameToId);
    }

}

运行效果:

 

 4.BiMap的种种实现

值实现 键实现 对应的BiMap实现
HashMap HashMap HashBiMap
ImmutableMap ImmutableMap ImmutableBiMap
EnumMap EnumMap EnumBiMap
EnumMap HashMap EnumHashBiMap


四.Table

  当我们需要多个索引的数据结构的时刻,通常情形下,我们只能用这种貌寝的Map<FirstName, Map<LastName, Person>>来实现。为此Guava提供了一个新的聚集类型-Table聚集类型,来支持这种数据结构的使用场景。Table支持“row”和“column”,而且提供多种视图。

1.例子

package com.guava;

import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;

public class TableTest {
    
    public static void main(String[] args) {
        Table<String, Integer, String> aTable = HashBasedTable.create(); 
        
        aTable.put("A", 1, "A1");
        aTable.put("A", 2, "A2");
        aTable.put("B", 2, "B2");
   
        System.out.println(aTable.column(2));  
        System.out.println(aTable.row("B"));   
        System.out.println(aTable.get("B", 2));  

        System.out.println(aTable.contains("B", 2));   
        System.out.println(aTable.containsColumn(2));   
        System.out.println(aTable.containsRow("B"));  
        System.out.println(aTable.columnMap()); 
        System.out.println(aTable.rowMap());   

        System.out.println(aTable.remove("B", 2)); 
    }

}

运行效果:

 

 2.Table的视图

  • rowMap():用Map<R, Map<C, V>>显示Table<R, C, V>。同样的, rowKeySet()返回”行”的聚集Set<R>。

  • row(r) :用Map<C, V>返回给定”行”的所有列,对这个map举行的写操作也将写入Table中。

  • 类似的列接见方式:columnMap()、columnKeySet()、column(c)。(基于列的接见会比基于的行接见稍微低效点)

  • cellSet():用元素类型为Table.Cell<R, C, V>的Set显示Table<R, C, V>。Cell类似于Map.Entry,但它是用行和列两个键区分的。

3.Table有如下几种实现:

  • HashBasedTable:本质上用HashMap<R, HashMap<C, V>>实现;

  • TreeBasedTable:本质上用TreeMap<R, TreeMap<C,V>>实现;

  • ImmutableTable:本质上用ImmutableMap<R, ImmutableMap<C, V>>实现;注:ImmutableTable对希罕或麋集的数据集都有优化。

  • ArrayTable:要求在组织时就指定行和列的巨细,本质上由一个二维数组实现,以提升接见速率和麋集Table的内存行使率。ArrayTable与其他Table的事情原理有点差别。

 

五.ClassToInstanceMap

ClassToInstanceMap是一种特殊的Map:它的键是类型,而值是相符键所指类型的工具。

为了扩展Map接口,ClassToInstanceMap分外声明晰两个方式:T getInstance(Class<T>) 和T putInstance(Class<T>, T),从而制止强制类型转换,同时保证了类型平安。

ClassToInstanceMap有唯一的泛型参数,通常称为B,代表Map支持的所有类型的上界。例如:

ClassToInstanceMap<Number> numberDefaults = MutableClassToInstanceMap.create();
numberDefaults.putInstance(Integer.class, Integer.valueOf(0));

从技术上讲,ClassToInstanceMap<B>实现了Map<Class<? extends B>, B>——或者换句话说,是一个映射B的子类型到对应实例的Map。这让ClassToInstanceMap包罗的泛型声明有点令人困惑,但请记着B始终是Map所支持类型的上界——通常B就是Object。

对于ClassToInstanceMap,Guava提供了两种有用的实现:MutableClassToInstanceMap和 ImmutableClassToInstanceMap。

例子:

package com.guava;

import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.MutableClassToInstanceMap;

public class ClassToInstanceMapTest {
    
    public static void main(String[] args) {
        ClassToInstanceMap<Object> classToInstanceMapString =MutableClassToInstanceMap.create();
        classToInstanceMapString.put(String.class, "lisi");
        classToInstanceMapString.put(Integer.class, 666);
        System.out.println("string:"+classToInstanceMapString.getInstance(String.class));
        System.out.println("Integer:"+classToInstanceMapString.getInstance(Integer.class));
    }

}

运行效果:

 

 

六.RangeSet

   RangeSet类是用来存储一些不为空的也不相交的局限的数据结构。如果需要向RangeSet的工具中加入一个新的局限,那么任何相交的部门都会被合并起来,所有的空局限都会被忽略。

   讲了这么多,我们该怎么样行使RangeSet?RangeSet类是一个接口,需要用它的子类来声明一个RangeSet型的工具,实现了RangeSet接口的类有ImmutableRangeSet和TreeRangeSet,ImmutableRangeSet是一个不能修改的RangeSet,而TreeRangeSet是行使树的形式来实现。下面主要谈TreeRangeSet的用法:

package com.guava;

import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;
import com.google.common.collect.TreeRangeSet;

public class RangeSetTest {
    
    public static void main(String[] args) {
        RangeSet<Integer> rangeSet = TreeRangeSet.create();
        rangeSet.add(Range.closed(1, 10));
        System.out.println("rangeSet:"+rangeSet);
        rangeSet.add(Range.closedOpen(11, 15)); 
        System.out.println("rangeSet:"+rangeSet);
        rangeSet.add(Range.open(15, 20));
        System.out.println("rangeSet:"+rangeSet);
        rangeSet.add(Range.openClosed(0, 0)); 
        System.out.println("rangeSet:"+rangeSet);
        rangeSet.remove(Range.open(5, 10)); 
        System.out.println("rangeSet:"+rangeSet);
    }

}

运行效果:

 

 请注重,要合并Range.closed(1, 10)和Range.closedOpen(11, 15)这样的区间,你需要首先用Range.canonical(DiscreteDomain)对区间举行预处置,例如DiscreteDomain.integers()。

注:RangeSet不支持GWT,也不支持JDK5和更早版本;由于,RangeSet需要充分行使JDK6中NavigableMap的特征。

1.RangeSet的视图

RangeSet的实现支持异常普遍的视图:

  • complement():返回RangeSet的补集视图。complement也是RangeSet类型,包罗了不相连的、非空的区间。
  • subRangeSet(Range<C>):返回RangeSet与给定Range的交集视图。这扩展了传统排序聚集中的headSet、subSet和tailSet操作。
  • asRanges():用Set<Range<C>>显示RangeSet,这样可以遍历其中的Range。
  • asSet(DiscreteDomain<C>)(仅ImmutableRangeSet支持):用ImmutableSortedSet<C>显示RangeSet,以区间中所有元素的形式而不是区间自己的形式查看。(这个操作不支持DiscreteDomain 和RangeSet都没有上界限,或都没有下界限的情形)

2.RangeSet的查询方式

为了利便操作,RangeSet直接提供了若干查询方式,其中最突出的有:

  • contains(C):RangeSet最基本的操作,判断RangeSet中是否有任何区间包罗给定元素。
  • rangeContaining(C):返回包罗给定元素的区间;若没有这样的区间,则返回null。
  • encloses(Range<C>):简朴明晰,判断RangeSet中是否有任何区间包罗给定区间。
  • span():返回包罗RangeSet中所有区间的最小区间。

七.RangeMap

RangeMap形貌了”不相交的、非空的区间”到特定值的映射。和RangeSet差别,RangeMap不会合并相邻的映射,即便相邻的区间映射到相同的值。

1.RangeMap的视图

RangeMap提供两个视图:

  • asMapOfRanges():用Map<Range<K>, V>显示RangeMap。这可以用来遍历RangeMap。
  • subRangeMap(Range<K>):用RangeMap类型返回RangeMap与给定Range的交集视图。这扩展了传统的headMap、subMap和tailMap操作。

例子:

package com.guava;

import com.google.common.collect.Range;
import com.google.common.collect.RangeMap;
import com.google.common.collect.TreeRangeMap;

public class RangeMapTest {
    
    public static void main(String[] args) {
        RangeMap<Integer, String> rangeMap = TreeRangeMap.create();
        rangeMap.put(Range.closed(1, 10), "foo"); 
        System.out.println("rangeMap:"+rangeMap);
        rangeMap.put(Range.open(3, 6), "bar"); 
        System.out.println("rangeMap:"+rangeMap);
        rangeMap.put(Range.open(10, 20), "foo"); 
        System.out.println("rangeMap:"+rangeMap);
        rangeMap.remove(Range.closed(5, 11)); 
        System.out.println("rangeMap:"+rangeMap);
        
        RangeMap<Integer, String> subRangeMap = rangeMap.subRangeMap(Range.closed(3, 15));
        System.out.println("subRangeMap:"+subRangeMap);
    }

}

运行效果:

,

AllbetGmaing客户端下载

欢迎进入AllbetGmaing客户端下载(Allbet Game):www.aLLbetgame.us,欧博官网是欧博集团的官方网站。欧博官网开放Allbet注册、Allbe代理、Allbet电脑客户端、Allbet手机版下载等业务。

Sunbet声明:该文看法仅代表作者自己,与本平台无关。转载请注明:allbet网址:Guava聚集--新聚集类型

网友评论

  • (*)

最新评论

标签列表

    文章归档

      站点信息

      • 文章总数:652
      • 页面总数:0
      • 分类总数:8
      • 标签总数:1154
      • 评论总数:290
      • 浏览总数:9318