相关疑难解决方法(0)

我有一个问题,这是一个普通的编程问题,但我的实现是在Java中,所以我将以这种方式提供我的示例

我有一个这样的课:

public class Foo {
    LinkedHashMap<String, Vector<String>> dataStructure;

    public Foo(LinkedHashMap<String, Vector<String>> dataStructure){
        this.dataStructure = dataStructure;
    }

    public String[][] allUniqueCombinations(){
        //this is what I need to do
    }
}

我需要从my生成一个嵌套数组,LinkedHashMap它代表LHM中所有值的每个唯一组合.例如,如果我的LHM看起来像这样(伪代码,但我认为你可以得到这个想法......):

{"foo" => ["1","2","3"], "bar" => ["3","2"], "baz" => ["5","6","7"]};

那么我的String [] []应该是这样的:

{
   {"foo","bar","baz"},
   {"1","3","5"},
   {"1","2","5"},
   {"1","3","6"},
   {"1","2","6"},
   {"1","3","7"},
   {"1","2","7"},
   {"2","3","5"},
   {"2","2","5"},
   {"2","3","6"},
   {"2","2","6"},
   {"2","3","7"},
   {"2","2","7"},
   {"3","3","5"},
   {"3","2","5"},
   {"3","3","6"},
   {"3","2","6"},
   {"3","3","7"},
   {"3","2","7"},
}

我认为这就是所有这些,我手动(显然)这样做,所以我可能错过了一套,但我认为这说明了我想要做的事情.只要存在所有独特的组合,每组的顺序无关紧要.另外需要明确的是,您不知道LHM中有多少元素,也不知道每个后续Vector中有多少元素.我找到的答案与你想要在一个数组中所有元素的每个独特组合的情况相匹配,但没有任何东西完全符合这一点.如果这是问题的完全重复,请在回复中添加一个链接,我将关闭该问题.

更新 - 我将我的类型更改为字符串,因为我的真实世界示例实际上是字符串.我试图使用整数来使示例更具可读性,但到目前为止我得到的答案并没有很好地转换为字符串.所以,是的,它们是数字,但在我的实际情况中,它们将是除了使用这个特定应用程序的人之外没有多大意义的字符串.所以,这只是它的抽象.

当我们不需要同步时,ArrayList比Vector更快.当我们确实需要同步集合时,我们最好使用同步包装器(如果我错了就纠正我),或者仅在对该集合进行调用时同步代码.是否存在使用Vector是最佳选择的情况？

我有一个ArrayList实例化并在后台线程上填充(我用它来存储Cursor数据).同时,它可以在主线程上访问,并通过使用foreach进行迭代.所以这显然可能导致抛出异常.

我的问题是什么是使这个类字段线程安全的最佳实践,而不是每次都复制它或使用标志？

class SomeClass {

    private final Context mContext;
    private List<String> mList = null;

    SomeClass(Context context) {
        mContext = context;
    }

    public void populateList() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                mList = new ArrayList<>();

                Cursor cursor = mContext.getContentResolver().query(
                        DataProvider.CONTENT_URI, null, null, null, null);
                try {
                    while (cursor.moveToNext()) {
                        mList.add(cursor.getString(cursor.getColumnIndex(DataProvider.NAME)));
                    }
                } catch (Exception e) {
                    Log.e("Error", e.getMessage(), e);
                } finally {
                    if (cursor != null) {
                        cursor.close();
                    }
                }
            }
        }).start();
    } …

我正在开发一个Android游戏,我只是注意到,因为onTouchEvent在UI线程上运行,并且更新/渲染方法是从一个单独的线程运行的,所以它们都会更新ArrayList包含实体的内容.显然,如果他们碰巧同时修改了列表,他们会发生冲突.

我读到Vector该类ArrayList与Vector同步的唯一区别完全相同,因此它们不会发生冲突.真的吗？如果是的话,它是否有任何性能问题或我应该关注的事情？我之前从未上过Vector课.

编辑:我实际上的意思是改变

ArrayList<Obj> list = new ArrayList<Obj>();

至

Vector<Obj> list = new Vector<Obj>()

但正如答案所说,Vector不建议使用.选定的答案解决了我的问题.

我经常认为允许使用数组作为适当的对象使用自己的方法而不是依赖于Arrays,Arrays和ArrayUtils等辅助类是个好主意.

例如:

ints.sort();                 // Arrays.sort(ints);
int[] onemore = ints.add(8); // int[] onemore = ArrayUtils.add(ints, 8);

我相信我并不是第一个有这个想法的人,但是我很难找到其他曾经写过这个想法的人.谁能帮我提一些关于这个主题的参考资料？

这被认为是好主意还是坏主意,为什么？

这是多么容易实现？

其他一些例子可能包括(但不要挂断它们,它们与问题本身无关):

int[] ints = {5,4,3,2,1};

// Arrays.sort (ints);
ints.sort();

// int pos = Arrays.asList(ints).indexOf (5);
// int pos = ArraysUtils.indexOf (ints, 5);
int pos = ints.indexOf (5);

// Arrays.reverse (ints);
ints.reverse();

Array<Integer> array = ints; // cast to super class.

// int length = Array.getLength (array);
int length = array.getLength();

// Object n = Array.get (array, 3);
Object n = array.get (3); …

话题说明了这一点.我不明白为什么std :: queue(或者通常:任何队列)本质上不是线程安全的,当没有涉及其他数据结构的迭代器时.

根据共同的规则

• 至少有一个主题是写...
• 另一个线程正在从共享资源中读取

我应该在以下示例代码中遇到冲突:

#include "stdafx.h"
#include <queue>
#include <thread>
#include <iostream>

struct response
{
    static int & getCount()
    {
        static int theCount = 0;
        return theCount;
    }

    int id;
};


std::queue<response> queue;

// generate 100 response objects and push them into the queue
void produce()
{
    for (int i = 0; i < 100; i++)
    {
        response r; 
        r.id = response::getCount()++;
        queue.push(r);
        std::cout << "produced: " << r.id << std::endl;
    }
}

// get the 100 …

我知道Vector类对于添加和删除元素[ reference ] 是线程安全的.

如果我使用ObjectOutputStream序列化Vector,我在反序列化时保证了一致(和非损坏)状态,即使其他线程在seralization期间添加和删除对象也是如此？

我找到的唯一记录方式是:

MyFragment fragment = (MyFragment) getSupportFragmentManager().findFragmentById(R.id.fragment);

但是由于Fragment是在ViewPager中实例化的,所以我没有id.

    List<Fragment> fragments = new Vector<Fragment>();
    fragments.add(Fragment.instantiate(this, Fragment1.class.getName()));
    fragments.add(Fragment.instantiate(this, Fragment2.class.getName()));
    fragments.add(Fragment.instantiate(this, Fragment3.class.getName()));

谢谢

每个人都说应该使用矢量因为性能(导致Vector在每次操作和东西之后同步).我写了一个简单的测试:

import java.util.ArrayList;
import java.util.Date;
import java.util.Vector;

public class ComparePerformance {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        Vector<Integer> vector = new Vector<Integer>();

        int size = 10000000;
        int listSum = 0;
        int vectorSum = 0;

        long startList = new Date().getTime();
        for (int i = 0; i < size; i++) {
            list.add(new Integer(1));
        }
        for (Integer integer : list) {
            listSum += integer;
        }
        long endList = new Date().getTime();
        System.out.println("List time: " + (endList - startList));

        long …

我有一个像这样的测试代码:

List<Integer> list = new ArrayList<>(1000000);

for(int i=0;i<1000000;i++){
    list.add(i);
}

List<String> values = new ArrayList<>(1000000);

list.stream().forEach(
    i->values.add(new Date().toString())
);

System.out.println(values.size()); 

运行这个,我得到了一个正确的输出:1000000.

但是,如果我将其更改stream()为parallelStream(),则:

 list.parallelStream().forEach(
    i->values.add(new Date().toString())
 );

我有一个随机输出,例如:920821.

怎么了？