如何将每个循环的Java切成两半？

我在Java中大量使用for-each循环。我用它们让我的每一类对象都做“画图”，但这需要很多内存，所以我想把它切成两半，有没有办法做到每个循环而不是一个完整的列表

for(Tile tile: tiles){
tile.draw();
}

我想：

for(Tile tile: (half of)tiles){
    tile.draw();
}

---

有没有可能，或者我只需要得到瓷砖的长度，当它达到数字时，就可以打破循环？

好吧，循环总是有旧式的

。假设
tiles
是
List
的一个实例：

for（int i=0；i

或者，如果要保持迭代器顺序：

Iterator<Tile> iter = tiles.iterator();
int i = 0;
int halfway = tiles.size() / 2;
while(i < halfway)
{
  Tile tile = iter.next();
  tile.draw();
  i++;
}

Iterator iter=tiles.Iterator（）；
int i=0；
int=tiles.size（）/2；
而（我<一半）
{
Tile-Tile=iter.next（）；
tile.draw（）；
i++；
}

我只想做“瓷砖”列表的一半，需要时再做另一半

如果两半的顺序不重要，可以这样做：

int counter = 0;
for(Tile tile: tiles) {
    if (counter++ % 2 == 0) {
        tile.draw();
    }
}

另一半的计数器+++%2==1。
这里给出的答案对我来说已经很好了，但我注意到在你的问题中，你希望每个循环都有一个计数器。因此，您可以使用stream将列表减半：

List<Tile> halve =tiles.stream().limit(tiles.size()/2).collect(Collectors.toList());
for(Tile tile : halve)
{   
}

List halve=tiles.stream（）.limit（tiles.size（）/2）.collect（Collectors.toList（））；
用于（瓷砖：减半）
{   
}

这与其他答案的方法相同，只是风格选择的一个方面
既然您已经澄清了您有一个
数组列表
，那么您可以使用
子列表
函数来查看列表的前半部分

for(Tile tile: tiles.subList(0, tiles.size()/2){
  tile.draw();
}

这使用了一个
foreach
循环，代码非常简洁易读

因为子列表只是原始列表的一个视图，所以复制到新列表没有任何损失。
ooh，有几种方法可以做到这一点

JAVA

final List<Tile> tiles = .... // create the list of Tile instances
//Be sure that tiles is not empty before to do that
final List<Tile> firstHalfSubList=tiles.subList(0, tiles.size()/2);
final List<Tile> secondHalfSubList=tiles.subList(tiles.size()/2, tiles.length());

import com.google.common.collect.Lists;
import com.google.common.math.IntMath;
import java.math.RoundingMode;

final List<Tile> tiles = .... // create the list of Tile instances
final int partitionSize = IntMath.divide(tile.size(), 2, RoundingMode.UP);
final List<List<Tile>> partitions = Lists.partition(tile, partitionSize);

final List tiles=..//创建平铺实例列表
//在执行此操作之前，请确保瓷砖不为空
最终列表firstHalfSubList=tiles.subList（0，tiles.size（）/2）；
最终列表secondHalfSubList=tiles.subList（tiles.size（）/2，tiles.length（））；

请注意，这两个半列表是背景平铺，因此请使它们不可变

但我最喜欢的是使用番石榴图书馆

番石榴

final List<Tile> tiles = .... // create the list of Tile instances
//Be sure that tiles is not empty before to do that
final List<Tile> firstHalfSubList=tiles.subList(0, tiles.size()/2);
final List<Tile> secondHalfSubList=tiles.subList(tiles.size()/2, tiles.length());

import com.google.common.collect.Lists;
import com.google.common.math.IntMath;
import java.math.RoundingMode;

final List<Tile> tiles = .... // create the list of Tile instances
final int partitionSize = IntMath.divide(tile.size(), 2, RoundingMode.UP);
final List<List<Tile>> partitions = Lists.partition(tile, partitionSize);

import com.google.common.collect.list；
导入com.google.common.math.IntMath；
导入java.math.RoundingMode；
最终列表分幅=../../创建平铺实例列表
final int partitionSize=IntMath.divide（tile.size（），2，RoundingMode.UP）；
最终列表分区=Lists.partition（tile，partitionSize）；

您有一个包含两个分区的列表，您可以对它们进行迭代
 你想怎么把它切成两半？例如，取每一块备用瓷砖，或仅取前一半。。。或者以其他方式？我只想做“瓷砖”列表的一半，需要时做另一半。现在是上半场，这将如何节省你的记忆？清单的后半部分是多余的吗？绘图操作占用的内存是否与绘制的瓷砖数量成比例？我将通过将列表切成块来节省内存，因此当im在一侧时，我只浏览列表的一部分，而不是每5000+次tiles@TautvydasJalinskas那可能不是真的。浏览列表并不意味着内存中列表中的每个项目都有一个额外的副本。这假设它是一个
ArrayList
，因为如果它是一个
LinkedList
，操作并不等同于像foreach循环那样使用列表迭代器。没关系。他假设正确，这可能会有所帮助，所以我将投票。@shekharsuman:不做假设，这个问题是无法回答的。到目前为止，所有的答案都做出了OP没有具体说明的假设。@realponsignist是正确的。我添加了一个保留原始迭代器顺序的替代方法！我认为是这样。Guava是一个很好的库，Java8采纳了很多很棒的想法。