我正在创建一种遗传算法来解决一些特定问题。由于问题很难描述,我写了一个小例子来展示我在做什么。
我有一个应随时间演变的元素列表。
每个元素都有一个适应度值,决定它的好坏程度。这是代表元素的类:
class Element implements Comparable<Element>{
private int fitness;
Element( int _fitness){
this.fitness=_fitness;
}
public int getFitness() {
return fitness;
}
@Override
public int compareTo( Element o ) {
return this.fitness-o.getFitness();
}
@Override
public String toString() {
return this.fitness+"";
}
}
最佳元素是具有最大适应度值的元素。
示例:
list_Iteration_One | list_Iteration_Two| list_Iteration_Three
Element(5) | Element(9) | Element(14)
Element(4) |Element(5) | Element(9)
Element(3) |Element(5) | Element(9)
Element(2) |Element(4) | Element(5)
Element(1) |Element(3) | Element(5)
正如我们所看到的,程序应该将元素列表作为输入,并演化这些元素以创建一个新的列表。
规则是取列表的一半并合并每两个元素以创建一个新元素。
对于所选元素,它们应该具有最大适应度值。
对于上面的示例,我使用 Element(5) + Element(4)
来创建 Element(9)
,并使用 Element(3 ) + Element(2)
创建 Element(5)
剩下的我拿了 Element(5), Element(4), Element(3)
.
对于第 3 次迭代,我正在做同样的事情,所以一次。
这是我在一次迭代中所做的事情:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class BestDataStructure {
public static void main( String[] args ) {
List<Element> list = Stream.of(new Element(5),
new Element(4),
new Element(3),
new Element(2),
new Element(1)).collect(Collectors.toCollection(ArrayList::new));
List<Element> theNewList = getTheNewList(list);
System.out.println(theNewList);
}
private static List<Element> getTheNewList( List<Element> list ) {
List<Element> theNewList = new ArrayList<>();
int numberOfTimes = list.size()/2;
Element bestElement=null;
Element secondBestElement=null;
for (int i =0; i<numberOfTimes; i++){
bestElement= Collections.max(list);
list.remove(bestElement);
secondBestElement= Collections.max(list);
list.remove(secondBestElement);
Element child = new Element(bestElement.getFitness()+secondBestElement.getFitness());
theNewList.add(child);
theNewList.add(bestElement);
theNewList.add(secondBestElement);
}
return theNewList;
}
}
class Element implements Comparable<Element>{
private int fitness;
Element( int _fitness){
this.fitness=_fitness;
}
public int getFitness() {
return fitness;
}
@Override
public int compareTo( Element o ) {
return this.fitness-o.getFitness();
}
@Override
public String toString() {
return this.fitness+"";
}
}
由于我应该处理大小(2000 到 50000 个元素之间)的 List
,因此我需要知道处理此类处理的最佳数据结构。
我每次都在 ArryList
中寻找最大元素,这是一个非常糟糕的主意。
每次迭代后的结果列表应与第一个列表具有相同的大小,不幸的是,这不是我在 getTheNewList
方法中得到的。
我也在寻找的是我应该处理这个任务的方式,我应该第一次寻找最好的元素,还是应该迭代地选择主题......
最佳答案
您可以使用 Java Streams:使用 IntStream
生成元素的前半部分并附加原始列表的前半部分。以下方法需要一个排序列表并返回一个新的排序元素列表:
private static List<Element> getTheNewList(List<Element> elements) {
int halfElements = elements.size() / 2;
return Stream.concat(
IntStream.range(0, halfElements)
.mapToObj(index -> new Element(elements.get(index * 2).getFitness() + elements.get(index * 2 + 1).getFitness())),
elements.stream().limit(halfElements + 1)
)
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
}
如果您按照以下方式使用它:
List<Element> iteration1 = Arrays.asList(
new Element(5),
new Element(4),
new Element(3),
new Element(2),
new Element(1)
);
System.out.println(iteration1);
List<Element> iteration2 = getTheNewList(iteration1);
System.out.println(iteration2);
List<Element> iteration3 = getTheNewList(iteration2);
System.out.println(iteration3);
这将打印:
[5, 4, 3, 2, 1]
[9, 5, 5, 4, 3]
[14, 9, 9, 5, 5]
关于java - 从现有列表创建元素列表,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/55305701/