List 从列表中按片段生成项的所有可能位置

我有这门课

public class Operation {

  private double value;
  private boolean inc;

  public Operation(double value, boolean inc) {
    this.value = value;
    this.inc = inc;
  }

  public double getValue() {
    return value;
  }

  public void setValue(double value) {
    this.value = value;
  }

  public boolean isInc() {
    return inc;
  }

  public void setInc(boolean inc) {
    this.inc = inc;
  }

  @Override
  public String toString() {
    return "Operation{" + "value=" + value + ", inc=" + inc + '}';
  }

}

现在我有了这个清单

public class TestOperation {

  public static void main(String[] args) {
    List<Operation> listOperation1 = new ArrayList<>();
    listOperation1.add(new Operation(1.3, true));
    listOperation1.add(new Operation(2.7, true));
    listOperation1.add(new Operation(0.9, false));
    listOperation1.add(new Operation(0.8, false));

    //Generate posible Rotation listOperation1
    //Operation(1.3, true), Operation(2.7, true), Operation(0.9, false), Operation(0.8, false)
    //Operation(1.3, true), Operation(2.7, true), Operation(0.8, false), Operation(0.9, false)
    //Operation(2.7, true), Operation(1.3, true), Operation(0.9, false), Operation(0.8, false)
    //Operation(2.7, true), Operation(1.3, true), Operation(0.8, false), Operation(0.9, false)

    List<Operation> listOperation2 = new ArrayList<>();
    listOperation2.add(new Operation(1.5, true));
    listOperation2.add(new Operation(2.9, true));
    listOperation2.add(new Operation(4.6, true));

    //Generate posible Rotation listOperation2
    //Operation(1.5, true), Operation(2.9, true), Operation(4.6, true)
    //Operation(1.5, true), Operation(4.6, true), Operation(2.9, true)
    //Operation(2.9, true), Operation(4.6, true), Operation(1.5, true)
    //Operation(2.9, true), Operation(1.5, true), Operation(4.6, true)
    //Operation(4.6, true), Operation(2.9, true), Operation(1.5, true)
    //Operation(4.6, true), Operation(1.5, true), Operation(2.9, true)
  }

}

公共类测试操作{
公共静态void main（字符串[]args）{
List listOperation1=新建ArrayList（）；
listOperation1.add（新操作（1.3，true））；
listOperation1.add（新操作（2.7，true））；
listOperation1.add（新操作（0.9，false））；
listOperation1.add（新操作（0.8，false））；
//生成可能的旋转列表操作1
//操作（1.3，正确）、操作（2.7，正确）、操作（0.9，错误）、操作（0.8，错误）
//操作（1.3，正确）、操作（2.7，正确）、操作（0.8，错误）、操作（0.9，错误）
//操作（2.7，正确）、操作（1.3，正确）、操作（0.9，错误）、操作（0.8，错误）
//操作（2.7，正确）、操作（1.3，正确）、操作（0.8，错误）、操作（0.9，错误）
List listOperation2=新建ArrayList（）；
listOperation2.add（新操作（1.5，true））；
listOperation2.add（新操作（2.9，true））；
listOperation2.add（新操作（4.6，true））；
//生成可能的旋转列表操作2
//操作（1.5，正确）、操作（2.9，正确）、操作（4.6，正确）
//操作（1.5，正确）、操作（4.6，正确）、操作（2.9，正确）
//操作（2.9，正确）、操作（4.6，正确）、操作（1.5，正确）
//操作（2.9，正确）、操作（1.5，正确）、操作（4.6，正确）
//操作（4.6，正确）、操作（2.9，正确）、操作（1.5，正确）
//操作（4.6，正确）、操作（1.5，正确）、操作（2.9，正确）
}
}

旋转仅在

inc=true

和

inc=false

之间发生，不混合！ 项目数

inc=true

可能与

inc=false

不同。甚至，有些可能不存在

必须处理列表中所有提交的项目，不能缺少任何项目，但不能重复（像对象，不像值）

---

如何生成此旋转？

如果输入像

[真，假，真，假，真，假]

，会发生什么情况？@Holger，我忘记了这种情况，因为之前我先排序了

真

，然后是

假

，那么接下来会发生什么？或者您的任务是否意味着在旋转之前进行排序？@Holger无所谓，

true

只需使用

true

和

false

进行排序，这不会改变情况。然后，为问题添加一个示例，显示应该发生什么。根据推荐阅读改编的置换算法：简而言之，你很少会发现

LinkedList

更可取的用例，而广泛使用交换操作的代码，即

get（int）

和

set（int，T）

，肯定不是这些用例之一。@Holger谢谢你，我改变了以前的课程。我会读你的帖子。

public class JavaApplication7 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        List<Operation> listOperation1 = new ArrayList<>();
        listOperation1.add(new Operation(1.3, true));
        listOperation1.add(new Operation(2.7, true));
        listOperation1.add(new Operation(0.9, false));
        listOperation1.add(new Operation(0.8, false));

        List listOperationTrue = listOperation1.stream()
                .filter(operation -> operation.isInc())
                .collect(Collectors.toList());

        List listOperationFalse = listOperation1.stream()
                .filter(operation -> !operation.isInc())
                .collect(Collectors.toList());

        List<List<Operation>> permutationTrue = new ArrayList<>();
        permuteList(listOperationTrue, 0, permutationTrue);
        System.out.println("\npermutationTrue");
        permutationTrue.stream().forEach(System.out::print);
        System.out.println();

        List<List<Operation>> permutationFalse = new ArrayList<>();
        permuteList(listOperationFalse, 0, permutationFalse);
        System.out.println("\npermutationFalse");
        permutationFalse.stream().forEach(System.out::print);

        System.out.println("\n\npermutationTrue -> permutationFalse");
        permutationTrue.stream().forEachOrdered(pTrue -> {
            permutationFalse.stream().forEachOrdered(pFalse -> {
                pTrue.stream().forEach(System.out::print);
                System.out.print(" -> ");
                pFalse.stream().forEach(System.out::print);
                System.out.println();
            });
        });
    }

    private static void permuteList(List<Operation> listOperation, int pos, List<List<Operation>> out) {
        if (pos == listOperation.size() - 1) {
            out.add(listOperation);
        } else {
            for (int i = pos; i < listOperation.size(); i++) {
                listOperation = swap(listOperation, pos, i);
                permuteList(listOperation, pos + 1, out);
                listOperation = swap(listOperation, pos, i);
            }
        }
    }

    public static List<Operation> swap(List<Operation> listOperation, int i, int j) {
        List<Operation> outSwap = new ArrayList<>(listOperation);
        outSwap.set(i, listOperation.get(j));
        outSwap.set(j, listOperation.get(i));
        return outSwap;
    }

}

    permutationTrue
    [Operation{value=1.3, inc=true}, Operation{value=2.7, inc=true}][Operation{value=2.7, inc=true}, Operation{value=1.3, inc=true}]

    permutationFalse
    [Operation{value=0.9, inc=false}, Operation{value=0.8, inc=false}][Operation{value=0.8, inc=false}, Operation{value=0.9, inc=false}]

    permutationTrue -> permutationFalse
    Operation{value=1.3, inc=true}Operation{value=2.7, inc=true} -> Operation{value=0.9, inc=false}Operation{value=0.8, inc=false}
    Operation{value=1.3, inc=true}Operation{value=2.7, inc=true} -> Operation{value=0.8, inc=false}Operation{value=0.9, inc=false}
    Operation{value=2.7, inc=true}Operation{value=1.3, inc=true} -> Operation{value=0.9, inc=false}Operation{value=0.8, inc=false}
    Operation{value=2.7, inc=true}Operation{value=1.3, inc=true} -> Operation{value=0.8, inc=false}Operation{value=0.9, inc=false}
    BUILD SUCCESSFUL (total time: 0 seconds)