说我有这样一个arraylist：
[24,15,55,101,555]
如何根据字符串中“5”的数量对数组进行排序？如果没有五个，那么较低的数字首先出现。因此排序的数组将是：
[24,101,15,5,555]
知道怎么做吗？也许计算5次出现的数量，并且有2d数组，其中1.实际数量为2.次数为5次？然后根据2d数组的第2列对数组进行排序？我对java很新，所以请耐心等待。
答案 0 :(得分：4)
我会创建一个实现Comparator<String> interface的类。在compare方法中，检测那里5个字符的数量。如果5字符的数量相等，则使用Integer.parseInt获取数字并进行比较。
如果第一个字符串应分别小于，等于或大于第二个字符串，请确保返回小于零，0或大于零的数字，以履行compare的合同。
int compare（T o1， T o2）
比较其订单的两个参数。返回负整数，零或正整数作为第一个参数 小于，等于或大于第二个。
然后拨打Arrays.sort(yourArray, new YourStringComparator());。
答案 1 :(得分：1)
我会制作两个数组，其中一个包含没有5s的数字，另一个数字包含5s的数字。
对两者进行排序并将第一个与第二个连接起来。
答案 2 :(得分：1)
这是（1）一种非常有效，通用的方法，以及（2）一种简单有效的方法。
（1）在第一种类型中，我计算并缓存数组中每个值一次出现的数字5的次数。然后我使用泛型排序方法根据缓存的值进行排序。这比自定义比较器更好，因为出现次数仅在列表中的每个元素计算一次。
（2）在第二种情况下，我只使用自定义比较器，它更容易实现。
排序（3）和（4）分别使用字符串而不是整数来执行与（1）和（2）相同的操作。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.ListIterator;
public class DigitSort {
public static void main(String[] args) {
List<Integer> initInt = Arrays.asList(555, 55, 5, 101, 202);
final int sortDigit = 5;
// sort #1
List<Integer> ints = new ArrayList<>(initInt);
sort(ints, new ToComparable<Integer, DigitComparable>() {
@Override
public DigitComparable toComparable(Integer number) {
return number == null ? null : new DigitComparable(number, digitCount(sortDigit, number));
}
});
System.out.println("Results of int generic sort:");
for (Integer number : ints)
System.out.println(number);
// sort #2
ints = new ArrayList<>(initInt);
Collections.sort(ints, new Comparator<Integer>() {
@Override
public int compare(Integer number1, Integer number2) {
if (number1 == null && number2 == null)
return 0;
if (number1 == null)
return -1;
if (number2 == null)
return 1;
int digitCount1 = digitCount(sortDigit, number1);
int digitCount2 = digitCount(sortDigit, number2);
return
digitCount1 > 0 && digitCount2 > 0 ? digitCount1 - digitCount2 :
digitCount2 > 0 ? -1 :
digitCount1 > 0 ? 1 :
number1 - number2;
}
});
System.out.println("\nResults of int comparator sort:");
for (Integer number : ints)
System.out.println(number);
List<String> initString = new ArrayList<>(initInt.size());
for (Integer number : initInt)
initString.add(number == null ? null : number.toString());
// sort #3
List<String> strings = new ArrayList<>(initString);
sort(strings, new ToComparable<String, DigitComparable>() {
@Override
public DigitComparable toComparable(String number) {
if (number == null)
return null;
int asInt = Integer.parseInt(number);
return new DigitComparable(asInt, digitCount(sortDigit, asInt));
}
});
System.out.println("\nResults of string generic sort:");
for (String number : strings)
System.out.println(number);
// sort #4
strings = new ArrayList<>(initString);
Collections.sort(strings, new Comparator<String>() {
@Override
public int compare(String number1, String number2) {
if (number1 == null && number2 == null)
return 0;
if (number1 == null)
return -1;
if (number2 == null)
return 1;
int digitCount1 = digitCount(sortDigit, number1);
int digitCount2 = digitCount(sortDigit, number2);
return
digitCount1 > 0 && digitCount2 > 0 ? digitCount1 - digitCount2 :
digitCount2 > 0 ? -1 :
digitCount1 > 0 ? 1 :
Integer.parseInt(number1) - Integer.parseInt(number2);
}
});
System.out.println("\nResults of string comparator sort:");
for (String number : strings)
System.out.println(number);
}
private static class DigitComparable implements Comparable<DigitComparable> {
private final int number, digitCount;
DigitComparable(int number, int digitCount) {
this.number = number;
this.digitCount = digitCount;
}
@Override
public int compareTo(DigitComparable other) {
return
digitCount > 0 && other.digitCount > 0 ? digitCount - other.digitCount :
other.digitCount > 0 ? -1 :
digitCount > 0 ? 1 :
number - other.number;
}
}
protected static int digitCount(int digit, String number) {
char asChar = Character.forDigit(digit, 10);
int count = 0;
for (char c : number.toCharArray())
if (c == asChar)
++count;
return count;
}
protected static int digitCount(int digit, int number) {
number = Math.abs(number);
int count = 0;
while (number != 0) {
if (number % 10 == digit)
++count;
number /= 10;
}
return count;
}
public interface ToComparable<T, C extends Comparable<? super C>> {
C toComparable(T t);
}
public static <T, C extends Comparable<? super C>> void sort(List<T> list, ToComparable<T, C> function) {
class Pair implements Comparable<Pair> {
final T original;
final C comparable;
Pair(T original, C comparable) {
this.original = original;
this.comparable = comparable;
}
@Override
public int compareTo(Pair other) {
return
comparable == null && other.comparable == null ? 0 :
comparable == null ? -1 :
other.comparable == null ? 1 :
comparable.compareTo(other.comparable);
}
}
List<Pair> pairs = new ArrayList<>(list.size());
for (T original : list)
pairs.add(new Pair(original, function.toComparable(original)));
Collections.sort(pairs);
ListIterator<T> iter = list.listIterator();
for (Pair pair : pairs) {
iter.next();
iter.set(pair.original);
}
}
}
答案 3 :(得分：0)
首先，我假设数组列表的元素是字符串。在那种情况下，我认为你有正确的想法。我会使用a for each循环遍历每个字符串并创建一个新的2d数组列表。基本上，数组的第一维包含每个字符串中的5个数，而数组列表的第二个维包含数字0到n-1，n是原始数组中的元素数。然后手动对数组的第一个维度进行排序，并将第二个数组的元素分别移动到它们的第一个维度计数器部分。完成此操作后，您的第二个数组应该包含原始数组所在元素的顺序。使用第二个数组调整原始数组的顺序并将其返回。
希望这有帮助。