Google Guava比Apache Collections更难使用吗?[关闭]

我正在考虑让我的团队,混合技能水平,使用谷歌番石榴。在Guava之前,我会使用Apache集合(或其泛化版本)。

与Apache集合相比,Guava在某些方面似乎更强大,但对于经验不足的程序员来说,可能不太容易使用。这里有一个我认为可以作为例子的地方。

boolean foo( final List< MapLike > stuff, final String target ) {
  final String upperCaseTarget = target.toUpperCase(0;

  for( MapLike m : stuff ) {
     final Maplike n = (MapLike) m.get( "hard coded string" );
     if( n != null ) {
         final String s = n.get( "another hard code string" );
         if( s != null && s.toUpperCase().equals( upperCaseTarget ) ) {
            return true ;
         }
     }
   return false ;
}

我最初的想法是使用Apache Collections Transformers:

boolean foo( final List< MapLike > stuff, final String target ) {
   Collection< String> sa = (Collection< String >) CollectionUtils.collect( stuff, 
     TransformerUtils.chainedTransformer( new Transformer[] { 
        AppUtils.propertyTransformer("hard coded string"),
        AppUtils.propertyTransformer("another hard coded string"),
        AppUtils.upperCaseTransformer()
         } ) );

    return sa.contains( target.toUpperCase() ) ;        

}

使用番石榴,我可能有两种方法:

boolean foo( final List< MapLike > stuff, final String target ) {
   Collection< String > sa = Collections2.transform( stuff,
       Functions.compose( AppUtils.upperCaseFunction(), 
       Functions.compose( AppUtils.propertyFunction("another hard coded string"), 
                          AppUtils.propertyFunction("hard coded string") ) ) );

    return sa.contains( target.toUpperCase() ) ;    
    // or
    // Iterables.contains( sa, target.toUpperCase() );
    // which actually doesn't buy me much

}

与Apache集合相比,函数.compose(g,f)颠倒了“直观的”顺序:函数从右到左应用,而不是从左到右的“明显的”变压器直到链式变压器.

一个更微妙的问题是,当Guava返回一个实时视图时,调用 contains 在live视图上可能会多次应用(composed)函数,所以 应该做的是:

   return ImmutableSet.copy( sa ).contains( target.toUpperCase() ) ;

但我的变换集中可能有空值,所以我不能这么做。我可以把它倒进垃圾桶里java.util.Collection集合,当然。

但这对我的(经验较少的)团队来说并不明显,即使在我解释了它之后,在编码的热度中也可能会被忽略。我希望也许Iterables.contains包含()会“做正确的事情”,并且知道一些魔术的例子来区分实时视图代理和普通的旧集合,但事实并非如此。这使得Guava可能更难使用。

也许我在我的实用程序类中编写了一个静态方法来处理这个问题?

// List always uses linear search? So no value in copying?
// or perhaps I should copy it into a set?
boolean contains( final List list, final Object target ) {
  return list.contains( target ) ;
}

// Set doesn't use linear search, so copy?
boolean contains( final Set set, final Object target ) {
  //return ImmutableSet.copy( set ).contains( target ) ;
  // whoops, I might have nulls
  return Sets.newHashSet( set ).contains( target ) ;
}

或者只复制超过一定大小的集合?

// Set doesn't use linear search, so copy?
boolean contains( final Set set, final Object target ) {
  final Set search = set.size() > 16 : Sets.newHashSet( set ) : set ;
  return search.contains( target ) ;
}

我想我是在问,“为什么没有一个‘更容易的’呢?” transform 在番石榴中,我想答案是,“好吧,总是把它返回的东西转储到一个新的集合中,或者写你自己的转换来实现”。