我有一个特定案例,用于两个此类项目的集合:
public class Item {
private Long id;
private boolean isVisible;
}
列表 A 包含可见和不可见的项目。
列表 B 仅包含列表 A 中的可见项,但排序(索引(不同。
我需要一个结果列表,其中可见项目按 B 的相对顺序排列,并且 A 的不可见项目的相对顺序不变。到目前为止,我能做对的唯一方法是通过迭代器:
Iterator<Item> ai = A.listIterator();
Iterator<Item> bi = B.iterator();
while(ai.hasNext() && bi.hasNext()) {
Item next = ai.next();
if (next.isVisible() && B.contains(next)) {
ai.set(bi.next())
}
}
因此,我们将 B 中包含的 A 中的每个下一个可见项目替换为 B 中的项目。我想知道通过番石榴或流 API 是否有更漂亮的解决方案来解决这个问题。
实现一个比较器,用于检查两个项目是否可见,因此它们都在 B 列表中。使用它们在 B 列表中的位置来确定排序顺序。如果其中一个不可见,则订单应在 A 列表中。
class CustomSort implements Comparator<Item> {
public int compare(Item i1, Item i2) {
if (i1.isVisible() && i2.isVisible()) {
return bi.indexOf(i1) - bi.indexOf(i2);
}
return ai.indexOf(i1) - ai.indexOf(i2);
}
}
如果需要在列表 A 和列表 B 之间共享同一对象,则可以执行以下操作
循环遍历列表 A,
- 如果 a 不可见,则返回 a,
- 如果 a 可见,则返回 b。
然后合并回列表并替换列表(或根据需要创建新列表(。
AtomicInteger index = new AtomicInteger();
listA = listA.stream()
.map(a -> a.isVisible ? listB.get(index.getAndIncrement()) : a)
.collect(Collectors.toList());
假设资本=可见,小盘股=不可见
AList = { A, A, B, C, B, C, D, E };//可见和不可见。
BList = { C, D, B, A } ;仅以不同的顺序可见。
根据您的要求
"因此,我们将 B 中包含的 A 中的每个下一个可见项目替换为 B 中的项目。我想知道通过Guava或Stream API是否有更漂亮的解决方案来解决这个问题。
您希望结果为 ->
CList = { C, a, D, B, b, c, A, d, e};//将可见项目按 B 的顺序排列
您可以先过滤 A 流以仅显示可见项目,然后将该项 ID 替换为该相对位置处的 B 值。关键是要使用 AtomicInteger
AtomicInteger index = new AtomicInteger();
itemA.stream().filter(a -> a.isVisible)
.forEach(a -> {
a.id = itemB.get(index.getAndIncrement()).id;
});
以下是完整的代码:-
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.IntStream;
public class StreamExample {
public static void main(String[] args) {
List<Item> itemA = new ArrayList<>();
List<Item> itemB = new ArrayList<>();
itemA.add(new Item("A"));
itemA.add(new Item("a", false));
itemA.add(new Item("B"));
itemA.add(new Item("C"));
itemA.add(new Item("b", false));
itemA.add(new Item("c", false));
itemA.add(new Item("D"));
itemA.add(new Item("e", false));
itemB.add(new Item("C"));
itemB.add(new Item("D"));
itemB.add(new Item("B"));
itemB.add(new Item("A"));
System.out.println("BEFORE: ");
System.out.println("A: ");
itemA.forEach(System.out::print);
System.out.println("nB: ");
itemB.forEach(System.out::print);
AtomicInteger index = new AtomicInteger();
itemA.stream().filter(a -> a.isVisible)
.forEach(a -> {
a.id = itemB.get(index.getAndIncrement()).id;
});
System.out.println("nAFTER: ");
System.out.println("A: ");
itemA.forEach(System.out::print);
}
}
class Item {
String id;
boolean isVisible = true;
public Item(String id) {
this.id = id;
}
public Item(String id, boolean isVisible) {
this.id = id;
this.isVisible = isVisible;
}
@Override
public String toString() {
return " {'" + id + ''' +
'}';
}
}
以下是输出
BEFORE:
A:
{'A'} {'a'} {'B'} {'C'} {'b'} {'c'} {'D'} {'e'}
B:
{'C'} {'D'} {'B'} {'A'}
AFTER:
A:
{'C'} {'a'} {'D'} {'B'} {'b'} {'c'} {'A'} {'e'}