我正在尝试根据特定索引上的项目名称重新排列ArrayList。
目前我的名单是：
"SL"
"TA"
"VP"
"SP"
"PR"
我希望将它们重新排列为：
"SL"
"SP"
"TA"
"PR"
"VP"
但是基于名称而不是索引。
我试过这个：
for (int i=0; i< list.size(); i++){
if (list.get(i).getCategoryName().equals("SL")){
orderedDummyJSONModelList.add(list.get(i));
}
}
for (int i=0; i< list.size(); i++){
if (list.get(i).getCategoryName().equals("SP")){
orderedDummyJSONModelList.add(list.get(i));
}
}
for (int i=0; i< list.size(); i++){
if (list.get(i).getCategoryName().equals("TA")){
orderedDummyJSONModelList.add(list.get(i));
}
}
for (int i=0; i< list.size(); i++){
if (list.get(i).getCategoryName().equals("PR")){
orderedDummyJSONModelList.add(list.get(i));
}
}
for (int i=0; i< list.size(); i++){
if (list.get(i).getCategoryName().equals("VP")){
orderedDummyJSONModelList.add(list.get(i));
}
}
它工作正常，但我想知道是否有更有效的方法在1 for循环或可能是一个函数。我不希望这样做：
orderedDummyJSONModelList.add(list.get(0));
orderedDummyJSONModelList.add(list.get(3));
orderedDummyJSONModelList.add(list.get(1));
orderedDummyJSONModelList.add(list.get(4));
orderedDummyJSONModelList.add(list.get(2));
哪个也有效。有什么想法吗？
答案 0 :(得分：0)
您可以将Collection.Sort方法用作Collection.Sort(list)，因为list是List<String>您将没事。但是如果你想实现一个新的比较器：
Collections.sort(list, new NameComparator());
class NameComparator implements Comparator<String> { //You can use classes
@Override
public int compare(String a, String b) { //You can use classes
return a.compareTo(b);
}
}
编辑：
您可以根据需要定义类比较器：
class ClassComparator implements Comparator<YourClass> { //You can use classes
@Override
public int compare(YourClass a, YourClass b) { //You can use classes
return a.name.compareTo(b.name);
}
}
答案 1 :(得分：0)
密钥的关键是：您需要明确要求。
换句话说：当然可以在列表中存储的对象周围移动。但是：可能你想要以编程方式。
换句话说：正确的方法是使用内置的Collection排序机制，但提供自定义比较器。
含义：您最好找到一个定义如何来自
的算法＆＃34; SL＆＃34; ＆＃34; TA＆＃34; ＆＃34; VP＆＃34; ＆＃34; SP＆＃34; ＆＃34; PR＆＃34;
到
＆＃34; SL＆＃34; ＆＃34; SP＆＃34; ＆＃34; TA＆＃34; ＆＃34; PR＆＃34; ＆＃34; VP＆＃34;
该算法应该进入比较器实现！
关键是：你首先有一些List<X>。 X对象提供了某种方法来检索您在此处显示的字符串。因此，您必须创建一个适用于X值的Comparator<X>;并使用一些来获取那些字符串值;并根据你决定X1是＆lt;，=或＆gt;比一些X2对象！
答案 2 :(得分：0)
必需的设置：
List<String> listOfStrings = Arrays.asList("SL", "TA", "VP", "SP", "PR");
HashMap<String, Integer> sortOrder = new HashMap<>();
sortOrder.put("SL", 0);
sortOrder.put("TA", 1);
sortOrder.put("VP", 2);
sortOrder.put("SP", 3);
sortOrder.put("PR", 4);
<强>流：
List<String> sortedList = listOfStrings.stream().sorted((a, b) -> {
return Integer.compare(sortOrder.get(a), sortOrder.get(b));
}).collect(Collectors.toList());
System.out.println(sortedList);
<强>非流：
Collections.sort(listOfStrings, (a, b) -> {
return Integer.compare(sortOrder.get(a), sortOrder.get(b));
});
OR
listOfStrings.sort((a, b) -> {
return Integer.compare(sortOrder.get(a), sortOrder.get(b));
});
System.out.println(listOfStrings);
<强>输出：
[SL, TA, VP, SP, PR]
答案 3 :(得分：0)
这里的答案仅针对您的问题，仅适用于给定的输出。如果List包含其他内容，则可能会破坏您的排序，因为没有关于如何订购的规则，PR最终会随机出现。
public static void main(String[] args) {
List<String> justSomeNoRuleOrderingWithARandomPRInside = new ArrayList<String>();
justSomeNoRuleOrderingWithARandomPRInside.add("SL");
justSomeNoRuleOrderingWithARandomPRInside.add("TA");
justSomeNoRuleOrderingWithARandomPRInside.add("VP");
justSomeNoRuleOrderingWithARandomPRInside.add("SP");
justSomeNoRuleOrderingWithARandomPRInside.add("PR");
java.util.Collections.sort(justSomeNoRuleOrderingWithARandomPRInside, new NameComparator());
for(String s : justSomeNoRuleOrderingWithARandomPRInside) {
System.out.println(s);
}
}
static class NameComparator implements Comparator<String> { //You can use classes
@Override
public int compare(String a, String b) { //You can use classes
// Lets just add a T in front to make the VP appear at the end
// after TA, because why not
if (a.equals("PR")) {
a = "T"+a;
} else if(b.equals("PR")) {
b = "T"+b;
}
return a.compareTo(b);
}
}
O / P
SL
SP
TA
PR
VP
但老实说，这个解决方案是垃圾，没有任何关于如何订购这些解决方案的明确规则，一旦你改变@GhostCat试图解释的任何东西，这注定会失败。
答案 4 :(得分：0)
这个怎么样
// define the order
List<String> ORDER = Arrays.asList("SL", "SP", "TA", "PR", "VP");
List<MyObject> list = ...
list.sort((a, b) -> {
// lamba syntax for a Comparator<MyObject>
return Integer.compare(ORDER.indexOf(a.getString()), ORDER.indexOf(b.getString());
});
请注意，这将在排序列表的开头放置ORDER列表中未定义的任何字符串。这可能是也可能是不可接受的 - 可能值得检查只有有效的字符串（即ORDER的成员）才会出现在MyObject.getString（）的结果中。
答案 5 :(得分：0)
您可以使用LinkedHashMap构建索引地图。这将用于查找使用项目的类别名称进行排序的订单。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ItemSorting {
public static void main(String[] args) {
List<Item> list = new ArrayList<Item>();
IndexMap indexMap = new IndexMap("SL", "SP", "TA", "PR", "VP");
ItemComparator itemComparator = new ItemComparator(indexMap);
list.add(new Item("SL"));
list.add(new Item("TA"));
list.add(new Item("VP"));
list.add(new Item("SP"));
list.add(new Item("PR"));
Collections.sort(list, itemComparator);
for (Item item : list) {
System.out.println(item);
}
}
}
import java.util.Comparator;
public class ItemComparator implements Comparator<Item> {
private IndexMap indexMap;
public IndexMap getIndexMap() {
return indexMap;
}
public void setIndexMap(IndexMap indexMap) {
this.indexMap = indexMap;
}
public ItemComparator(IndexMap indexMap) {
this.indexMap = indexMap;
}
@Override
public int compare(Item itemA, Item itemB) {
if (itemB == null) return -1;
if (itemA == null) return 1;
if (itemA.equals(itemB)) return 0;
Integer valA = indexMap.get(itemA.getCategoryName());
Integer valB = indexMap.get(itemB.getCategoryName());
if (valB == null) return -1;
if (valA == null) return 1;
return valA.compareTo(valB);
}
}
import java.util.LinkedHashMap;
public class IndexMap extends LinkedHashMap<String, Integer> {
private static final long serialVersionUID = 7891095847767899453L;
public IndexMap(String... indicies) {
super();
if (indicies != null) {
for (int i = 0; i < indicies.length; i++) {
this.put(indicies[i], new Integer(i));
}
}
}
}
public class Item {
private String categoryName;
public Item(String categoryName) {
super();
this.categoryName = categoryName;
}
public String getCategoryName() {
return categoryName;
}
public void setCategoryName(String categoryName) {
this.categoryName = categoryName;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((categoryName == null) ? 0 : categoryName.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Item other = (Item) obj;
if (categoryName == null) {
if (other.categoryName != null) return false;
} else if (!categoryName.equals(other.categoryName)) return false;
return true;
}
@Override
public String toString() {
return String.format("Item { \"categoryName\" : \"%s\" }", categoryName);
}
}
Item { "categoryName" : "SL" }
Item { "categoryName" : "SP" }
Item { "categoryName" : "TA" }
Item { "categoryName" : "PR" }
Item { "categoryName" : "VP" }
答案 6 :(得分：0)
您可以创建一个维护位置的地图。当你遍历无序列表时，只需获取该字符串值的位置并插入新数组（不是arraylist），然后如果需要，可以将该数组转换为ArrayList。 示例代码：
Map<String,Integer> map = new HashMap<>(); //you can may be loop through and make this map
map.put("SL", 0);
map.put("SP", 1);
map.put("TA",2);
map.put("PR",3);
map.put("VP",3);
List<String> list1 // your unordered list with values in random order
String[] newArr = new String[list1.size()];
for(String strName: list1){
int position = map.get(strName);
arr[position] = strName;
}
//newArr has ordered result.
答案 7 :(得分：0)
你可以定义一个像这样的辅助方法：
public static int get(String name) {
switch (name) {
case "SL":
return 1;
case "SP":
return 2;
case "TA":
return 3;
case "PR":
return 4;
case "VP":
return 5;
default:
return 6;
}
}
并在主要方法中写下如下内容：
ArrayList<String> al = new ArrayList<>();
al.add("SL");
al.add("TA");
al.add("VP");
al.add("SP");
al.add("PR");
Collections.sort(al, (o1, o2) -> return get(o1) - get(o2); );
al.forEach((s) -> System.out.println(s));