Question

我正在尝试遍历大小为1024的整数列表，其内部值的结构类似于{0,0,0,0,0,0,0,0,0,3,3,3,3,3 ，3,3,1,1,1,1,1,1,1 ....}。

在遍历列表时，我正在创建一个对象，它将值与起始索引位置和结束位置一起保存。

例如，上面的结构将拉出3个对象。

第一个对象包含值0，起始位置为0，结束位置为8.

第二个对象包含值3，起始位置为9，结束位置为15.依此类推。我一直在谈论这个问题，我正在努力解决这个问题。

Answer 1

在遍历列表时，我正在创建一个对象，它将值与起始索引位置和结束位置一起保存。

只需遍历列表并在此过程中将新对象添加到另一个列表中：

ArrayList<MyObject> newList = new ArrayList<MyObject>();

for(Integer i : intList){
    int start = ...;      //your calculation to derive start
    int end = ...;        //your calculation to derive end
    int value = ...;      //your calculation to derive value
    newList.add(new MyObject(start, end, value));
}

Answer 2

您要做的是跟踪您所处的价值以及何时在列表中看到新值，创建对象然后重新初始化您的值。以下是您应该能够应用于您的问题的示例 -

int list[] = {0,0,0,0,0,0,0,0,0,3,3,3,3,3,3,3,1,1,1,1,1,1,1};
int currentVal = list[0];
int start = 0;
int end = -1;

for(int index = 1; index < list.length; index++)
{
    if(currentVal != list[index])
    {
        end = index - 1;
        System.out.println("New Object is S: " + start + ", End: " + end + ", Val: " + currentVal);
        // create the object here PositionHelper obj = new PositionHelper(start, index - 1, currentVal);
        currentVal = list[index];
        start = index;
    }
}

System.out.println("New Object is S: " + start + ", End: " + (list.length - 1) + ", Val: " + currentVal);
// create the object here PositionHelper obj = new PositionHelper(start, index - 1, currentVal);

输出

  New Object is S: 0, End: 8, Val: 0
  New Object is S: 9, End: 15, Val: 3
  New Object is S: 16, End: 22, Val: 1

请注意

您想要考虑列表中的最后一个对象，在退出for循环之前您不会知道，以便最后一个语句解释它。如果检查for循环中的最后一个结尾，您还可以添加另一个。经销商的选择！祝你好运！

Answer 3

public class Test {
  static class MyObject {
    private int begin;
    private int end;
    private int number;

    public MyObject(int begin, int end, int number) {
      this.begin = begin;
      this.end = end;
      this.number = number;
    }

    public String toString() {
      return "[begin: " + begin + ", end: " + end + ", number: " + number + "]";
    }

    //getters, setters
  }

  public static List<MyObject> traverse(int ... integers) {
    List<MyObject> result = new ArrayList<>();
    if(integers.length == 0) {
      return result;
    }
    int number = integers[0];
    int begin = 0;
    for (int i = 1; i < integers.length; i++) {
      int current = integers[i];
      if(current != number) {
        result.add(new MyObject(begin, i-1, number));
        begin = i;
        number = current;
      }
    }
    result.add(new MyObject(begin, integers.length -1, number));
    return result;
  }

  public static void main(String[] args) {
    List<MyObject> result = traverse(0,0,0,1,1,15);
    System.out.println(result);
  }
}

输出是：
[[begin：0，end：2，number：0]，[begin：3，end：4，number：1]，[begin：5，end：5，number：15]]

如何遍历整数列表并保存连续值的起始和结束位置

3 个答案: