Question

我正在学习Android和Java我创建了一个课程，让我们这样说

 class x(){
    public int a; 
    public string b;
 }

然后我启动此类的列表，然后将值添加到其属性中，如此

public ArrayList<x> GetList(){

List<x> myList = new ArrayList<x>();

    x myObject = new x();
    myObject.a = 1; 
    myObject.b = "val1";
     mylist.add(x);

    y myObject = new y();
    myObject.a = 2; 
    myObject.b = "val2";
     mylist.add(y);

return myList;
}

我的问题是如何循环访问GetList（）返回

我试过

ArrayList<x> list = GetList();
Iterator<x> iterator = list.iterator();

但我不知道这是否是正确的做法，而且我不知道接下来要做什么我在Iterator上添加了一个断点，但似乎是null，列表有价值思想

Answer 1

有两种方法可以做到这一点：

for循环
使用iterator方法。

`for`循环：

for(x currentX : GetList()) {
    // Do something with the value
}

这就是＆＃34; for-each＆＃34;循环，它可能是最常见/首选的方法。语法是：

for(ObjectType variableName : InCollection)

您还可以使用标准for循环：

ArrayList<x> list = GetList();
for(int i=0; i<list.size(); i++) {
     x currentX = list.get(i);
     // Do something with the value
 }

这个的语法是：

for(someStartingValue; doSomethingWithStartingValue; conditionToStopLooping)

`iterator`方法：

Iterator<x> iterator = GetList().iterator();
while(iterator.hasNext()) {
    x currentX = iterator.next();
    // Do something with the value
}

Answer 2

您可以使用for-each循环遍历数组：

for (x item: GetList()) {
    doSomethingWithEachValue(item);
}

Answer 3

我猜你可以通过多种方式遍历arraylist。一种方法是迭代器： -

ArrayList<String> al = new ArrayList<String>();

al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");

System.out.print("Original contents of al: ");
Iterator<String> itr = al.iterator();
while (itr.hasNext()) {
  String element = itr.next();
  System.out.print(element + " ");
}

另一种方式是循环：

for(int i = 0; i < list.size(); i++){
    list[i].a = 29;
}

希望这会有所帮助。

参考

http://www.tutorialspoint.com/java/java_using_iterator.htm

http://examples.javacodegeeks.com/core-java/util/arraylist/arraylist-in-java-example-how-to-use-arraylist/

更新

由于下面关于绩效的评论，我认为我应该把它放在研究中。

Android文档

http://developer.android.com/training/articles/perf-tips.html

规定：

增强的for循环（有时也称为“for-each”循环）可用于实现Iterable接口和数组的集合＆gt;对于集合，将分配一个迭代器来对hasNext（）和next（）进行接口调用。使用ArrayList，手写的＆gt;计数循环快约3倍（有或没有JIT），但对于其他集合，增强的＆gt; for循环语法将完全等效于显式迭代器的使用。

迭代数组有几种选择：

static class Foo {
    int mSplat;
}

Foo[] mArray = ...

public void zero() {
    int sum = 0;
    for (int i = 0; i < mArray.length; ++i) {
        sum += mArray[i].mSplat;
    }
}

public void one() {
    int sum = 0;
    Foo[] localArray = mArray;
    int len = localArray.length;

    for (int i = 0; i < len; ++i) {
        sum += localArray[i].mSplat;
    }
}

public void two() {
    int sum = 0;
    for (Foo a : mArray) {
        sum += a.mSplat;
    }
}

零（）是最慢的，因为JIT还不能优化每次迭代一次获取数组长度的成本循环。
一个（）更快。它把所有东西都拉成局部变量，避免查找。只有阵列长度才能提供性能益处。
两个（）对于没有JIT的设备来说速度最快，并且无法区分来自one（）的设备与JIT。它使用增强的for循环 Java编程语言1.5版中引入的语法。

因此，您应该默认使用增强型for循环，但考虑手写的计数循环以进行性能关键的ArrayList迭代。这也是 Josh Bloch的Effective Java，第46项所述。 迭代器和索引变量都只是杂乱无章。此外，它们代表了错误的机会。

迭代集合和数组的首选习惯用法

for(Element e : elements){
    doSomething(e);
}

Josh还说当你看到冒号时：把它读作“In”。循环读取元素中的每个元素e。我并不认为这项工作是我自己的，尽管我希望如此。如果您想了解有关高效代码的更多信息，我建议您阅读Josh Bloch的Effective Java。

Answer 4

尝试以下方法：

class x {
    public int a;
    public String b;
}


private void test() {
    List<x> items = getList();
    for (x item: items) {
        System.out.print("val: " + item.a);
    }
}

private List<x> getList() {

    List<x> items = new ArrayList<x>();

    x oneObject = new x();
    oneObject.a = 1;
    oneObject.b = "val1";
    items.add(oneObject);


    x anotherObject = new x();
    anotherObject.a = 2;
    anotherObject.b = "val2";
    items.add(anotherObject);

    return items;
}

迭代通过ArrayList <t> java？</t>

4 个答案:

`for`循环：

`iterator`方法：

迭代通过ArrayList <t> java？</t>

4 个答案:

for循环：

iterator方法：

`for`循环：

`iterator`方法：