Question

我有一个名为empList的字符串数组，看起来像这样

我想将这些数据添加到复杂对象Employee，定义如下：

class Employee{
    public int ID;
    public List<Float> results;
}

，标准是：对于empList中的每个项目：

如果Integer.parseInt(item) >=10000 - ＆gt;添加到Employee.ID;

以下项目被解析为浮点数，并添加到当前Employee对象的results，直到，

Float.parseFloat(item) == -1 - ＆gt;完成为此Employee分配值后，转到下一个Employee。

根据这些规则，我将从字符串数组中获取3个对象。最快的方法是什么？

更新：到目前为止我所得到的：

List<Employee> employees = new ArrayList<>();

    for (int i=0; i<empList.size(); i++){
        if (Integer.parseInt(empList.get(i))>=10000) 
            employees.add(new Employee(Integer.parseInt(empList.get(i))));
 // let's say Employee has a constructor that accepts an int and assign it as ID 
        }

用它们的ID启动3个对象，然后

int populated = 0;
for (int j=0; j<empList.size(); j++){
    if (Integer.parseInt(empList.get(j)) <10000 
         && Integer.parseInt(empList.get(j)) !=1
         && !empList.get(j).isEmpty()
         )
        employees.get(populated).results.add(Float.parseFloat(empList.get(j)));
    else if (Integer.parseInt(empList.get(j)) !=1)
        populated++;
}

但是上面的内容将所有内容添加到第一个Employee，而不是在-1之后跳转到第二个Employee。

Answer 1

这应该做你想要的：

TestIndex.class

import java.util.ArrayList;
import java.util.List;

public class TestIndex {

    class Employee{
        public int ID;
        public List<Float> results;

        Employee(int id, List<Float> extractResults) {
            ID = id;
            results = extractResults;
        }

        public void print(){
            System.out.println("Employee ID: " + ID);
            System.out.print("results: ");
            for (Float f : results) {
              System.out.print(f + " "); 
            }
            System.out.println("");
        }
    }

    private int parseEmployee(float[] array, int index, List<Employee> employees) {
        List<Float> extractResults = new ArrayList<Float>();
        int id = (int)array[index];
        for(int subIndex = index + 1; subIndex < array.length; subIndex++) {
            if(array[subIndex] == -1 || array[subIndex] > 10000) {
                index = subIndex;
                break;
            } 
            extractResults.add(array[subIndex]);
        }
        employees.add(new Employee(id, extractResults));
        return index;
    }

    TestIndex()  {
        float[] array = {
                10000,  
                72.2F,  
                45.6F,  
                55.3F,  
                -1,  
                10001,  
                19.3F,  
                -1,  
                10002,  
                13.5F,  
                14.6F,  
                -1  
        };
        List<Employee> employees = new ArrayList<Employee>();
        for(Integer index = 0; index < array.length; index++) {
            if(array[index] >= 10000) {
                index = parseEmployee(array, index, employees);
            }
        }
        for(Employee employee : employees) {
            employee.print();
        }
    }

    public static void main(String[] args) {
        new TestIndex();
    }
}

修改

主要问题是填写结果的错误检查条件，正如您对帖子的评论所指出的那样。此外，在此代码中已对排序部件进行了优化

它不会解析数组两次：相反，它会将数据处理部分切断以逐渐创建对象。

通过逐步构建对象，避免了空集合检查

将对象内部subIndex偏移量反馈到主解析循环中，以便它可以立即从处理下一个Employee对象开始

对字符串数组进行分类，并将其元素添加到对象的不同部分

1 个答案: