Java 搜索数组列表

我目前有一个名为list的数组列表，其中包含许多数字（双精度）。我需要将这个大数组列表拆分为8个较小的数组，我可以通过以下方式完成此操作：

//Array List "list" contains close to 8 million numbers in it
            for (int c1 = 0; c1 < list.size(); c1++)
        { //for
        counter1++;
        if (counter1 % rows ==1)
            ID.add(list.get(c1));
        else if (counter1 % rows ==2)
            Contract.add(list.get(c1));
        else if (counter1 % rows == 3)
            Date.add(list.get(c1));
        else if (counter1 % rows == 4)
            Open.add(list.get(c1));
        else if (counter1 % rows == 5)
            High.add(list.get(c1));
        else if (counter1 % rows == 6)
            Low.add(list.get(c1));
        else if (counter1 % rows == 7)
            Close.add(list.get(c1));
        else if (counter1 % rows == 8)
            Volume.add(list.get(c1));
    }  //for

//数组列表“List”中包含近800万个数字
对于（int c1=0；c1

每8个数字代表一行新的重要信息。
如。 ID合同日期开盘高位低位收盘量 ID1合同1日期1打开1高1低1关闭1卷1

---

在我问是否有更好的方法来组织这件事之前。我现在有一个不同的问题。有没有一种方法可以在使用for循环之外搜索arraylist？我可以不必像我那样组织数组列表（对于大型文档，这需要花费很长时间），而是让用户输入一个ID和合同，然后让我的程序以比使用for循环更有效的方式在代码中搜索该ID和合同吗？

重要信息的每一行都应该由Java对象表示，而不是像一些人在评论中所建议的那样通过HashMap。您使用的是面向对象的编程语言，因此创建一个名为

Contract

（或其他表示这8个字段的类），然后您将拥有一个

ArrayList=new ArrayList（）

，它将存储所有这些对象

重要信息的每一行都应该由Java对象表示，而不是像一些人在评论中所建议的那样由HashMap表示。您使用的是面向对象的编程语言，因此创建一个名为

Contract

（或其他表示这8个字段的类），然后您将拥有一个

ArrayList=new ArrayList（）

，它将存储所有这些对象

因为您已经在使用数组

分裂的过程会很长，你无法逃避

使用上面提到的Hashmap是一个好主意，对于一个键，您将在O（1）中获得值，而不是O（n）（数组）

顺便说一句，您需要注意的是，每个函数（Id.add Contract.add）都可以被抽象，并包含您想要使用的数据结构的代码，它是哈希映射、树、列表还是不相交集。（另一个答案也提到了这一点）

另一方面，要加快拆分代码的速度，请将其修改为：

此代码减少了要计算的模数。应该更快，但可能不会太多

int selector;
for (int c1 = 0; c1 < list.size(); c1++)
{
    counter1++;
    selector = counter1 = % rows;
    switch(selector)
    {
        case 1:
            ID.add(list.get(c1));
            break;
        case 2:
            Contract.add(list.get(c1));
            break;
        case 3:
            Date.add(list.get(c1));
            break;
        case 4:
            Open.add(list.get(c1));
            break;
        case 5:
            High.add(list.get(c1));
            break;
        case 6:
            Low.add(list.get(c1));
            break;
        case 7:
            Close.add(list.get(c1));
            break;
        case 8:
            Volume.add(list.get(c1));
            break;
    }
}

int选择器；
对于（int c1=0；c1

考虑到我从列表内容中了解的内容，这里有一个更快的方法。 没有求值（if/switch/modulo），只有getter，更少的迭代，没有计数器

//The list is made of block of 8 units, lets read block by block and not node by node
for (int c1 = 0; c1 < list.size()/8; c1++)
{
    ID.add(list.get(c1*8 + 1));
    Contract.add(list.get(c1*8 + 2));
    Date.add(list.get(c1*8 + 3));
    Open.add(list.get(c1*8 + 4));
    High.add(list.get(c1*8 + 5));
    Low.add(list.get(c1*8 + 6);
    Close.add(list.get(c1*8 + 7));
    Volume.add(list.get(c1*8 + 8));
}    

//列表由8个单元组成，允许逐块读取，而不是逐节点读取
对于（int c1=0；c1

使用for循环在数组中搜索

---

99%的情况下，如果有一个函数像list.find（）那样执行它，那么它将是一个for循环trew每个节点。唯一不正确的情况是，当数据结构被语言设置为非列表时。（Hashmap可以是框架的，有一个数组/列表）

，因为您已经在使用数组了

分裂的过程会很长，你无法逃避

使用上面提到的Hashmap是一个好主意，对于一个键，您将在O（1）中获得值，而不是O（n）（数组）

顺便说一句，您需要注意的是，每个函数（Id.add Contract.add）都可以被抽象，并包含您想要使用的数据结构的代码，它是一个hashmap、树、列表还是不相交的集合。（如另一个答案中所述）

另一方面，要加快拆分代码的速度，请将其修改为：

这段代码减少了要计算的模数。应该更快，但可能不会太多

int selector;
for (int c1 = 0; c1 < list.size(); c1++)
{
    counter1++;
    selector = counter1 = % rows;
    switch(selector)
    {
        case 1:
            ID.add(list.get(c1));
            break;
        case 2:
            Contract.add(list.get(c1));
            break;
        case 3:
            Date.add(list.get(c1));
            break;
        case 4:
            Open.add(list.get(c1));
            break;
        case 5:
            High.add(list.get(c1));
            break;
        case 6:
            Low.add(list.get(c1));
            break;
        case 7:
            Close.add(list.get(c1));
            break;
        case 8:
            Volume.add(list.get(c1));
            break;
    }
}

int选择器；
对于（int c1=0；c1