标签: collections

我很困惑我应该从我的公共API方法和属性返回哪种集合类型.

我想到的收藏品是IList,ICollection和Collection.

返回其中一种类型总是优先于其他类型,还是取决于具体情况？

我正在编写一些使用Apache POI API的Scala代码.我想迭代java.util.Iterator我从Sheet类中获得的行.我想在for each样式循环中使用迭代器,所以我一直在尝试将其转换为原生的Scala集合,但没有运气.

我查看了Scala包装器类/特性,但我看不出如何正确使用它们.如何在不使用详细while(hasNext()) getNext()循环样式的情况下迭代Scala中的Java集合？

这是我根据正确答案编写的代码:

class IteratorWrapper[A](iter:java.util.Iterator[A])
{
    def foreach(f: A => Unit): Unit = {
        while(iter.hasNext){
          f(iter.next)
        }
    }
}

object SpreadsheetParser extends Application
{
    implicit def iteratorToWrapper[T](iter:java.util.Iterator[T]):IteratorWrapper[T] = new IteratorWrapper[T](iter)

    override def main(args:Array[String]):Unit =
    {
        val ios = new FileInputStream("assets/data.xls")
        val workbook = new HSSFWorkbook(ios)
        var sheet = workbook.getSheetAt(0)
        var rows = sheet.rowIterator()

        for (val row <- rows){
            println(row)
        }
    }
}

我正在尝试在Python中创建一组集合.我无法弄清楚该怎么做.

从空集开始xx:

xx = set([])
# Now we have some other set, for example
elements = set([2,3,4])
xx.add(elements)

但我明白了

TypeError: unhashable type: 'list'

要么

TypeError: unhashable type: 'set'

是否可以在Python中拥有一组集合？

我正在处理大量的集合,我希望能够不必处理重复的集合(集合A1,A2,......的集合B,如果Ai = Aj,则会"取消"两个集合)

我需要将a转换HashMap<String, Object>为数组; 有谁能告诉我它是如何完成的？

我能够通过从IDictionary派生并定义一个私有的SyncRoot对象,在C#中实现一个线程安全的Dictionary:

public class SafeDictionary<TKey, TValue>: IDictionary<TKey, TValue>
{
    private readonly object syncRoot = new object();
    private Dictionary<TKey, TValue> d = new Dictionary<TKey, TValue>();

    public object SyncRoot
    {
        get { return syncRoot; }
    } 

    public void Add(TKey key, TValue value)
    {
        lock (syncRoot)
        {
            d.Add(key, value);
        }
    }

    // more IDictionary members...
}

然后,我在整个消费者(多个线程)中锁定此SyncRoot对象:

例:

lock (m_MySharedDictionary.SyncRoot)
{
    m_MySharedDictionary.Add(...);
}

我能够使它工作,但这导致了一些丑陋的代码.我的问题是,是否有更好,更优雅的方式来实现线程安全的字典？

我想要List<T>一个属性的实现,可以毫无疑问地使用线程安全.

像这样的东西:

private List<T> _list;

private List<T> MyT
{
    get { // return a copy of _list; }
    set { _list = value; }
}

看来我仍然需要返回一个集合(克隆)的集合,所以如果我们在某个地方迭代集合并同时设置集合,那么就不会引发异常.

如何实现线程安全的集合属性？

如何将String数组转换为java.util.List？

从Java 1.6 Collection Framework文档:

不支持任何修改操作(例如add,remove和clear)的集合称为不可修改.[...]另外保证Collection对象中的任何更改都不可见的集合称为不可变.

第二个标准让我感到困惑.鉴于第一个集合是不可修改的,并假设原始集合引用已被丢弃,第二行中引用的更改是什么？它是指集合中保存的元素的变化,即元素的状态？

第二个问题:
对于一个不可变的集合,如何提供额外的guarentees指定？如果一个线程更新了集合中元素的状态,那么在不可变集合的线程中,状态中的那些更新是不可见的,这对于不变性是否足够？

对于一个不可变的集合,如何提供额外的guarentees指定？

我有一个List<Person>.我需要List从一个属性获得Person.

例如,我有一个Person班级:

class Person
{
    private String name;
    private String birthDate;
    public String getName() {
        return name;
    }
    public String getBirthDate() {
        return birthDate; 
    }
    Person(String name) {
        this.name = name;
    }
}

List<Person> personList = new ArrayList<>();
personList.add(new Person("David"));
personList.add(new Person("Joe"));
personList.add(new Person("Michel"));
personList.add(new Person("Barak"));

我想获得StreamAPI 的名称列表,如下所示:

List<String> names = personList.stream().somecode().collect(Collectors.toList());
names.stream().forEach(System.out::println);

#David
#Joe
#Michel
#Barak

此代码不起作用:

public class Main 
{
    public static void main(String[] args) 
    {
        List<Person> personList …

除了对反向列表理解进行列表理解之外,还有一种pythonic方法可以按值对Counter进行排序吗？如果是这样,它比这更快:

>>> from collections import Counter
>>> x = Counter({'a':5, 'b':3, 'c':7})
>>> sorted(x)
['a', 'b', 'c']
>>> sorted(x.items())
[('a', 5), ('b', 3), ('c', 7)]
>>> [(l,k) for k,l in sorted([(j,i) for i,j in x.items()])]
[('b', 3), ('a', 5), ('c', 7)]
>>> [(l,k) for k,l in sorted([(j,i) for i,j in x.items()], reverse=True)]
[('c', 7), ('a', 5), ('b', 3)