您现在的位置是：首页 > Java

当前栏目

java:java.util.Map和java.util.Set的Key类型转换

2023-03-02 10:28:17 时间

google的guava项目提对Map供了丰富强大的转换功能(参见guava jar包中的com.google.common.collect.Maps ) 
Maps.transform系列方法可以对Map的Value类型进行转换, 
比如： 
`public static <K, V1, V2> Map<K, V2> transformEntries( Map<K, V1> fromMap,EntryTransformer<? super K, ? super V1, V2> transformer)` 
可以将一个`Map<K,V1>`转为一个`Map<K,V2>`对象。 
但是guava中并没有提供对Key的类型转换。为什么呢？ 
对Map提供Key类型转换不一定是安全的，是有风险的。比如用ByteBuffer->byte\[\]，我们知道 `byte[]`做Key是有问题的(因为两个内容相同的`byte[]`计算出的hashcode不同，所以在一般的设计中不会用`byte[]`做为key)。 
虽然实现Key类型转换并不复杂，但guava中并没有将它做为通用方法提供，以防止错误使用。对于java.util.Set也没有提供transform方法，道理是一样的。 
但是在现实设计中有的时候真的需要一个Key类型的转换，就需要自己来实现它，于是我参照guava中transform的设计，自己实现了`java.util.Map`和`java.util.Set`的Key类型转换方法(不依赖guava)。 
如下图， 
![这里写图片描述][SouthEast]

其实核心的方法就是两个静态方法，如上图红框标的，一个用于转换`Map<K1,V>`到`Map<K2,V>`，另一个用来转换`Set<E1>`到`Set<E2>` 
`TransformedMap<K1, K2, V>`，`TransformedSet<E1, E2>`两个内部类就是对应上面两个方法的实现部分. 
Set和Map的转换核心是Iterator的转换，所以从guava中抄了`TransformedIterator<F, T>`的代码实现。 
完整实现代码如下： 
CollectionUtils.java

package net.gdface.facelog.client;
 
 import java.util.AbstractMap;
 import java.util.AbstractSet;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
 public class CollectionUtils {
 
 private CollectionUtils() {}
 public static interface Function<F, T> {
 
 T apply( F input);
 }
 /**
 * dual transform type between L and R 
 * {@link #toRight(Object)} L -> R 
 * {@link #fromRight(Object)} R -> L
 * @author guyadong
 *
 * @param <L> left type
 * @param <R> right type
 */
 public static interface DualTransformer<L,R>{
 
 R toRight(L input);
 L fromRight(R input);
 }
 public static final <L,R> DualTransformer<L,R> asDualTransformer(final Function<L,R> t1,final Function<R,L>t2){
 checkNotNull(t1);
 checkNotNull(t2);
 return new DualTransformer<L,R>(){
 @Override
 public R toRight(L input) {
 return t1.apply(input);
 }
 @Override
 public L fromRight(R input) {
 return t2.apply(input);
 }
 };
 }
 public static final <L,R> Function<L,R> asToRightTransformer(final DualTransformer<L,R> dual){
 checkNotNull(dual);
 return new Function<L,R>(){
 @Override
 public R apply(L input) {
 return dual.toRight(input);
 }
 };
 }
 public static final <L,R> Function<R,L> asFromRightTransformer(final DualTransformer<L,R> dual){
 checkNotNull(dual);
 return new Function<R,L>(){
 @Override
 public L apply(R input) {
 return dual.fromRight(input);
 }
 };
 }
 private static boolean equal( Object a, Object b) {
 return a == b || (a != null && a.equals(b));
 }
 static <T> T checkNotNull(T reference) {
 if (reference == null) {
 throw new NullPointerException();
 }
 return reference;
 }
 static <V> V safeGet(Map<?, V> map, Object key) {
 checkNotNull(map);
 try {
 return map.get(key);
 } catch (ClassCastException e) {
 return null;
 } catch (NullPointerException e) {
 return null;
 }
 }
 /** @see #tranformKeys(Map, DualTransformer)*/
 public static final<K1,K2,V>Map<K2,V> tranformKeys(Map<K1,V>fromMap, 
 Function<K1, K2> transformer2, 
 Function<K2, K1> transformer1){
 return tranformKeys(fromMap,asDualTransformer(transformer2,transformer1));
 }
 /**
 * Returns a view of a map where each value is transformed by a function. All
 * other properties of the map, such as iteration order, are left intact. 
 * see also {@link com.google.common.collect.Maps#transformEntries(Map, com.google.common.collect.Maps.EntryTransformer)}
 * @param fromMap
 * @param transformer
 * @return
 */
 public static final<K1,K2,V>Map<K2,V> tranformKeys(Map<K1,V>fromMap, 
 DualTransformer<K1, K2> transformer){
 return new TransformedMap<K1, K2, V>(fromMap,transformer);
 }
 /** @see #transform(Set, DualTransformer)*/
 public static final <E1,E2>Set<E2>transform(Set<E1> fromSet, 
 Function<E1, E2> transformer2, 
 Function<E2, E1> transformer1){
 return transform(fromSet,asDualTransformer(transformer2,transformer1));
 }
 /**
 * Returns a view of a set where each key is transformed by a function. All
 * other properties of the map, such as iteration order, are left intact. 
 * see also {@link com.google.common.collect.Maps#transformEntries(Map, com.google.common.collect.Maps.EntryTransformer)}
 * @param fromSet
 * @param transformer
 * @return
 */
 public static final <E1,E2>Set<E2>transform(Set<E1> fromSet, 
 DualTransformer<E1,E2> transformer){
 return new TransformedSet<E1,E2>(fromSet,transformer);
 }
 
 /**
 * Returns an iterator that applies {@code function} to each element of {@code fromIterator}. 
 * see also {@link com.google.common.collect.Iterators#transform(Iterator, com.google.common.base.Function)}
 * @param fromIterator
 * @param transformer
 * @return
 */
 public static <F, T> Iterator<T> transform(final Iterator<F> fromIterator,
 final Function<? super F, ? extends T> transformer) {
 return new TransformedIterator<F, T>(fromIterator,transformer);
 }
 static class TransformedIterator<F, T> implements Iterator<T> {
 final Iterator<? extends F> backingIterator;
 private Function<? super F, ? extends T> transformer;
 
 TransformedIterator(Iterator<? extends F> backingIterator,Function<? super F, ? extends T> transformer) {
 this.backingIterator = checkNotNull(backingIterator);
 this.transformer = checkNotNull(transformer);
 }
 
 @Override
 public final boolean hasNext() {
 return backingIterator.hasNext();
 }
 
 @Override
 public final T next() {
 return transformer.apply(backingIterator.next());
 }
 
 @Override
 public final void remove() {
 backingIterator.remove();
 }
 }
 static class TransformedSet<E1, E2> extends AbstractSet<E2> {
 final Set<E1> fromSet;
 private final DualTransformer<E1, E2> transformer;
 
 TransformedSet(Set<E1> fromSet, DualTransformer<E1, E2> transformer) {
 checkNotNull(fromSet);
 checkNotNull(transformer);
 this.fromSet = fromSet;
 this.transformer = transformer;
 }
 @Override
 public int size() {
 return fromSet.size();
 }
 
 @Override
 public Iterator<E2> iterator() {
 return transform(fromSet.iterator(), asToRightTransformer(transformer));
 }
 
 @Override
 public boolean add(E2 e) {
 return fromSet.add(transformer.fromRight(e));
 }
 
 @SuppressWarnings("unchecked")
 @Override
 public boolean contains(Object o) {
 try {
 return fromSet.contains(transformer.fromRight((E2) o));
 } catch (ClassCastException e) {
 return false;
 }
 }
 
 @SuppressWarnings("unchecked")
 @Override
 public boolean remove(Object o) {
 try {
 return fromSet.remove(transformer.fromRight((E2) o));
 } catch (ClassCastException e) {
 return false;
 }
 }
 }
 
 static class TransformedMap<K1, K2, V> extends AbstractMap<K2, V> {
 final Map<K1, V> fromMap;
 private DualTransformer<K1,K2> transformer;
 TransformedMap(Map<K1, V> fromMap, DualTransformer<K1,K2> transformer) {
 checkNotNull(fromMap);
 checkNotNull(transformer);
 this.fromMap = fromMap;
 this.transformer = transformer;
 }
 @SuppressWarnings("unchecked")
 @Override
 public V get(Object key) {
 try {
 return fromMap.get(transformer.fromRight((K2) key));
 } catch (ClassCastException e) {
 return null;
 }
 }
 
 @SuppressWarnings("unchecked")
 @Override
 public boolean containsKey(Object key) {
 try {
 return fromMap.containsKey(transformer.fromRight((K2) key));
 } catch (ClassCastException e) {
 return false;
 }
 }
 
 @Override
 public V put(K2 key, V value) { 
 return fromMap.put(transformer.fromRight(key), value);
 }
 
 @SuppressWarnings("unchecked")
 @Override
 public V remove(Object key) {
 try {
 return fromMap.remove(transformer.fromRight((K2) key));
 } catch (ClassCastException e) {
 return null;
 }
 }
 
 @Override
 public Set<Entry<K2, V>> entrySet() {
 return new EntrySet<K2,V>(){
 
 @Override
 Map<K2, V> map() {
 return TransformedMap.this;
 }
 
 @Override
 public Iterator<java.util.Map.Entry<K2, V>> iterator() {
 return transform(fromMap.entrySet().iterator(),
 new Function<Entry<K1,V>,Entry<K2,V>>(){
 @Override
 public java.util.Map.Entry<K2, V> apply(java.util.Map.Entry<K1, V> input) {
 return new TransformedEntry<K1,K2,V>(input,asToRightTransformer(TransformedMap.this.transformer));
 }});
 }};
 }
 abstract static class EntrySet<K, V> extends AbstractSet<Entry<K, V>> {
 abstract Map<K, V> map();
 
 @Override 
 public int size() {
 return map().size();
 }
 
 @Override 
 public boolean contains(Object o) {
 if (o instanceof Entry) {
 Entry<?, ?> entry = (Entry<?, ?>) o;
 Object key = entry.getKey();
 V value = safeGet(map(), key);
 return equal(value, entry.getValue())
 && (value != null || map().containsKey(entry.getKey()));
 }
 return false;
 }
 
 @Override 
 public boolean remove(Object o) {
 if (contains(o)) {
 Entry<?, ?> entry = (Entry<?, ?>) o;
 return map().keySet().remove(entry.getKey());
 }
 return false;
 }
 }
 static class TransformedEntry<K1,K2,V> implements Entry<K2, V> {
 final Entry<K1,V>fromEntry;
 final Function<K1, K2> transformer2;
 TransformedEntry(Entry<K1,V>fromEntry,Function<K1, K2> transformer2){
 checkNotNull(fromEntry);
 this.fromEntry = fromEntry;
 checkNotNull(transformer2);
 this.transformer2 = transformer2;
 }
 @Override
 public K2 getKey() {
 return transformer2.apply(fromEntry.getKey());
 }
 
 @Override
 public V getValue() {
 return fromEntry.getValue();
 }
 
 @Override
 public V setValue(V value) {
 return fromEntry.setValue(value);
 }
 
 @Override 
 public boolean equals(Object object) {
 if(object instanceof TransformedEntry){
 return fromEntry.equals((TransformedEntry<?, ?, ?>)object);
 }
 return super.equals(object);
 }
 
 @Override 
 public int hashCode() {
 return fromEntry.hashCode();
 }
 
 @Override 
 public String toString() {
 return fromEntry.toString();
 }
 }
 }
 }

**注意：**  
transfrom方法返回的新对象是原对象的代理对象，对新对象的任何操作实际都是原对象的操作

[SouthEast]: /images/20220607/280b9a14b56e48648c51939acfe0835d.png

猜你喜欢

Cyanine 染料 | MedChemExpress
Flink被阿里巴巴买后，果然还是废了
【愚公系列】2023年01月 Dapr分布式应用运行时-组件的定义
【地铁上的Redis与C#】string 类型数据的注意事项以及应用场景
恶心，DoorDash半夜突袭，不通知就裁员
高通量筛选技术加速联合用药研究 | MedChemExpress
第十四届蓝桥杯集训——Date与Calendar函数
第十四届蓝桥杯集训——字符串函数(基础函数操作)
re:Invent 2022：亚马逊对HTAP说不！
又一家SaaS公司Elastic 宣布裁员13%。。。
PS软件安装及破解方法--所有PS软件全版本！
java蛋糕店蛋糕商城蛋糕系统网站源码
Mac版Photoshop 2020分享，破解免费直装版--所有PS软件全版本！
java字符串练习题1、反向输出字符串
Photoshop 2022 (PS 2022) 中文直装版安装教程--所有PS软件全版本！
Java校园超市系统超市商城源码超市网站
背景
Adobe Photoshop 2022软件安装教程--所有PS软件全版本！
Java实验课预约系统网站源码
飞总带大家解读 AWS re:Invent 2022大数据相关的发布，一句话总结：惨不忍睹。。。

zl程序教程

当前栏目

java:java.util.Map和java.util.Set的Key类型转换

相关文章