Java 比较ArrayList中的列表

我有一个包含以下字符串的文本文件（这些字符串是软件的版本）：

我试图找到最新的版本，在本例中，3_10_5_2_10是我试图使用java显示的版本

目前，我的代码如下：

    BufferedReader br;
    String version;
    ArrayList<List<Integer>> array = new ArrayList<List<Integer>>();
    List<Integer> liste = new ArrayList<Integer>();

    try{
        br = new BufferedReader(new FileReader(new File(FILEPATH)));

        while((version= br.readLine()) != null)
        {
            liste = Arrays.asList(version.split("_")).stream().

    map(s -> Integer.parseInt(s.trim())).collect(Collectors.toList());

            array.add(liste);
        }

        for(int i = 0; i < array.size(); i++)
        {   
            for (List l: array)
            {
                Object z = l.get(i);
                List<Object> listes = new ArrayList<Object>();
                listes.add(z);
                System.out.println(listes);
            }               
        }
        br.close();

        System.out.println(array);
    }catch(FileNotFoundException e){
        e.printStackTrace();
    }catch(IOException e){
        e.printStackTrace();
    }      

---

我想得到每个列表的元素并比较它们以找到最大的元素（最近的一个），但我不知道怎么做。

一个简单的面向对象方法是创建对象，表示版本号，我们称之为VersionNumber，它将有一个工厂方法的构造函数来解析字符串。这个VersionNumber类应该实现接口Comparable和方法compareTo

这里有一个使用Comparable的提示

---

然后你可以很容易地编写一个算法来查找max版本，或者用谷歌搜索一些库来为你做这件事。

我给你推荐了一种对象方法，用compareTo方法定义一个名为version的类，然后使用集合类上的排序方法，您可以简单地对版本进行排序

优势

• 清晰的代码
• 数据验证

Main:

public class Main {

    public static void main(String[] args){

        List<Version> versions = Arrays.asList(
                Version.create("1_10_2_0_154"),
                Version.create("3_10_5_2_10"),
                Version.create("2_10_4_1_49"),
                Version.create("3_10_5_1_37"));

        versions.sort(Version::compareTo);

        System.out.println(versions.get(0).toString());
    }

}

public class Version implements Comparable<Version> {

    private final int major;
    private final int minor;
    private final int bug;
    private final int release;
    private final int build;

    public Version(int major, int minor, int bug, int release, int build) {
        this.major = major;
        this.minor = minor;
        this.bug = bug;
        this.release = release;
        this.build = build;
    }

    public int getMajor() {
        return major;
    }

    public int getMinor() {
        return minor;
    }

    public int getBug() {
        return bug;
    }

    public int getRelease() {
        return release;
    }

    public int getBuild() {
        return build;
    }

    @Override
    public String toString() {
        return "Version{" +
                "major=" + major +
                ", minor=" + minor +
                ", bug=" + bug +
                ", release=" + release +
                ", build=" + build +
                '}';
    }



    public static Version create(String value){

        String[] splitRes = value.split("_");
        List<Integer> intValues = new ArrayList<>();

        for(String v : splitRes){
            intValues.add(Integer.parseInt(v));
        }

        return create(intValues);
    }

    public static Version create(List<Integer> values){

        if(Objects.requireNonNull(values).size() < 5)
            throw new IllegalArgumentException();

        return new Version(
                values.get(0),
                values.get(1),
                values.get(2),
                values.get(3),
                values.get(4)
        );
    }


    @Override
    public int compareTo(Version that) {
        if (this.major > that.major) {
            return -1;
        } else if (this.major < that.major) {
            return 1;
        }

        if (this.minor > that.minor) {
            return -1;
        } else if (this.minor < that.minor) {
            return 1;
        }

        if (this.bug > that.bug) {
            return -1;
        } else if (this.bug < that.bug) {
            return 1;
        }

        if (this.release > that.release) {
            return -1;
        } else if (this.release < that.release) {
            return 1;
        }

        if (this.build > that.build) {
            return -1;
        } else if (this.build < that.build) {
            return 1;
        }
        return 0;
    }
}

公共类主{
公共静态void main（字符串[]args）{
列表版本=Arrays.asList(
创建（“1_10_2_0_154”），
创建（“3_10_5_2_10”），
创建（“2_10_4_1_49”），
创建（“3_10_5_1_37”）；
versions.sort（Version:：compareTo）；
System.out.println（versions.get（0.toString（））；
}
}

版本：

public class Main {

    public static void main(String[] args){

        List<Version> versions = Arrays.asList(
                Version.create("1_10_2_0_154"),
                Version.create("3_10_5_2_10"),
                Version.create("2_10_4_1_49"),
                Version.create("3_10_5_1_37"));

        versions.sort(Version::compareTo);

        System.out.println(versions.get(0).toString());
    }

}

public class Version implements Comparable<Version> {

    private final int major;
    private final int minor;
    private final int bug;
    private final int release;
    private final int build;

    public Version(int major, int minor, int bug, int release, int build) {
        this.major = major;
        this.minor = minor;
        this.bug = bug;
        this.release = release;
        this.build = build;
    }

    public int getMajor() {
        return major;
    }

    public int getMinor() {
        return minor;
    }

    public int getBug() {
        return bug;
    }

    public int getRelease() {
        return release;
    }

    public int getBuild() {
        return build;
    }

    @Override
    public String toString() {
        return "Version{" +
                "major=" + major +
                ", minor=" + minor +
                ", bug=" + bug +
                ", release=" + release +
                ", build=" + build +
                '}';
    }



    public static Version create(String value){

        String[] splitRes = value.split("_");
        List<Integer> intValues = new ArrayList<>();

        for(String v : splitRes){
            intValues.add(Integer.parseInt(v));
        }

        return create(intValues);
    }

    public static Version create(List<Integer> values){

        if(Objects.requireNonNull(values).size() < 5)
            throw new IllegalArgumentException();

        return new Version(
                values.get(0),
                values.get(1),
                values.get(2),
                values.get(3),
                values.get(4)
        );
    }


    @Override
    public int compareTo(Version that) {
        if (this.major > that.major) {
            return -1;
        } else if (this.major < that.major) {
            return 1;
        }

        if (this.minor > that.minor) {
            return -1;
        } else if (this.minor < that.minor) {
            return 1;
        }

        if (this.bug > that.bug) {
            return -1;
        } else if (this.bug < that.bug) {
            return 1;
        }

        if (this.release > that.release) {
            return -1;
        } else if (this.release < that.release) {
            return 1;
        }

        if (this.build > that.build) {
            return -1;
        } else if (this.build < that.build) {
            return 1;
        }
        return 0;
    }
}

公共类版本实现了可比较的{
私立专业；
私家小修；
私有最终整数错误；
私人最终发布；
私人最终建造；
公共版本（int-major、int-minor、int-bug、int-release、int-build）{
this.major=major；
这个。小调=小调；
this.bug=bug；
这个。释放=释放；
this.build=build；
}
公共int getMajor（）{
返回专业；
}
公共int getMinor（）{
返回未成年人；
}
public int getBug（）{
返回错误；
}
public int getRelease（）{
返回释放；
}
公共int getBuild（）{
返回构建；
}
@凌驾
公共字符串toString（）{
返回“版本{”+
“少校=”+少校+
“，minor=“+minor”+
“，bug=“+bug+
“，release=“+release+
“，build=“+build”+
'}';
}
公共静态版本创建（字符串值）{
String[]splitRes=value.split（“”）；
List intValues=new ArrayList（）；
用于（字符串v:splitRes）{
add（Integer.parseInt（v））；
}
返回创建（intValues）；
}
公共静态版本创建（列表值）{
if（Objects.requirennoull（values）.size（）<5）
抛出新的IllegalArgumentException（）；
返回新版本(
值。获取（0），
值。获取（1），
值。获取（2），
值。获取（3），
值。获取（4）
);
}
@凌驾
public int compareTo（该版本）{
如果（this.major>that.major）{
返回-1；
}else if（this.majorthat.minor）{
返回-1；
}else if（this.minorthat.bug）{
返回-1；
}else if（this.bugthat.release）{
返回-1；
}else if（this.releasethat.build）{
返回-1；
}else if（this.build

---

更新1

正如@Henrik所建议的，我用Java8方法更新了列表排序

更新2

我反转了compareTo方法，因此现在您只需在列表上调用sort方法并传递方法引用Version:：compareTo

更新3

版本类的更具动态性的解决方案：

public class Version implements Comparable<Version> {

    private final List<Integer> values;

    public Version(List<Integer> values) {
        this.values = values;
    }

    public List<Integer> getValues() {
        return values;
    }

    @Override
    public String toString() {

        return String.join("_", values
                .stream()
                .map(Object::toString)
                .collect(Collectors.toList()));
    }

    @Override
    public int compareTo(Version that) {

        List<Integer> thatValues = that.getValues();

        for(int index = 0; index < values.size(); index++){

            Integer value = values.get(index);
            Integer thatValue = thatValues.get(index);

            if (value > thatValue) {
                return -1;
            } else if (value < thatValue) {
                return 1;
            }
        }

        return 0;
    }


    public static Version create(String value){

        String[] splitRes = value.split("_");
        List<Integer> intValues = new ArrayList<>();

        for(String v : splitRes){
            intValues.add(Integer.parseInt(v));
        }

        return new Version(intValues);
    }
}

公共类版本实现了可比较的{
私有最终列表值；
公共版本（列表值）{
这个值=值；
}
公共列表getValues（）{
返回值；
}
@凌驾
公共字符串toString（）{
返回String.join（“\ux”），值
.stream（）
.map（对象：：toString）
.collect（Collectors.toList（））；
}
@凌驾
public int compareTo（该版本）{
列出thatValues=that.getValues（）；
对于（int index=0；index该值）{
返回-1；
}else if（值<该值）{
返回1；
}
}
返回0；
}
公共静态版本创建（字符串值）{
String[]splitRes=value.split（“”）；
List intValues=new ArrayList（）；
用于（字符串v:splitRes）{
add（Integer.parseInt（v））；
}
返回新版本（intValues）；
}
}

将数组组合成一个数字，然后进行数字比较

class Scratch
{
    public static void main(String[] args)
    {
        List<List<Integer>> arr = new ArrayList<>();
        arr.add(fromArray(new Integer[]{1,10,2,0,154}));
        arr.add(fromArray(new Integer[]{3,10,5,2,10}));
        arr.add(fromArray(new Integer[]{2,10,4,1,49}));
        arr.add(fromArray(new Integer[]{3,10,5,1,37}));

        Integer[] maxLengths = {0,0,0,0,0};
        for (List<Integer> v : arr)
        {
            for(int idx = 0; idx < v.size(); idx++)
            {
                Integer n = v.get(idx);
                int curMaxLen = maxLengths[idx];
                maxLengths[idx] = Math.max(n.toString().length(), curMaxLen);
            }
        }
        Long largest = arr.stream().map(v -> {
            StringBuilder result = new StringBuilder();
            for(int idx = 0; idx < v.size(); idx++)
            {
                Integer n = v.get(idx);
                int maxLen = maxLengths[idx];
                result.append(String.format("%-" + maxLen + 's', n).replace(' ', '0'));
            }
            return result.toString();
        }).map(Long::valueOf).max(Comparator.naturalOrder()).get();
        System.out.println(largest);
    }

    public static List<Integer> fromArray(Integer[] array)
    {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list, array);
        return list;
    }
}

类刮擦
{
公共静态void main（字符串[]args）
{
List arr=new ArrayList（）；
add（fromArray（新整数[]{1,10,2,0154}））；
arr.add（从
Comparator<List<Integer>> comparator = (list1, list2) -> {
    Iterator<Integer> iteratorA = list1.iterator();
    Iterator<Integer> iteratorB = list2.iterator();

    //It iterates through each list looking for an int that is not equal to determine which one precedes the other
    while (iteratorA.hasNext() && iteratorB.hasNext()) {
        int elementA = iteratorA.next();
        int elementB = iteratorB.next();

        if (elementA > elementB) {
            return 1;
        } else if (elementA < elementB) {
            return -1;
        }
    }
    //All elements seen so far are equal. Use the list size to decide
    return iteratorA.hasNext() ? 1 : iteratorB.hasNext() ? -1 : 0;
};

Collections.sort(list, comparator);

static List<String> versions = Arrays.asList(
        "1_10_2_0_154",
        "3_10_5_2_10",
        "2_10_4_1_49",
        "3_10_5_1_37");

static Comparator<List<Integer>> c = (o1,o2) -> {
    int length = o1.size()>o2.size()?o2.size():o1.size();
    for (int i = 0; i < length; i++) {
        int i1 = o1.get(i);
        int i2 = o2.get(i);
        if (i1 != i2)
            return i1 - i2;
    }
    return 0;
};
static Comparator<List<Integer>> c2 = (o1,o2) -> {
    Iterator<Integer> i1=o1.iterator();
    Iterator<Integer> i2=o2.iterator();
    while (i1.hasNext() && i2.hasNext()){
        int i = i1.next()-i2.next();
        if (i!=0) return i;
    }
    return 0;
};

static Optional<List<Integer>> getTheMostRecentVersion(List<String> versions) {
    return versions.stream().
            map(s -> Arrays.stream(s.split("_")).
                    map(Integer::parseInt).
                    collect(Collectors.toList())).max(c2);
}

public static String getMostRecentVersion(BufferedReader in) throws IOException {
    final Comparator<String[]> version = (s1, s2) -> {
        int res = 0;

        for (int i = 0; i < 5 && res == 0; i++)
            res = Integer.compare(Integer.parseInt(s1[i]), Integer.parseInt(s2[i]));

        return res;
    };

    String str;
    String resStr = null;
    String[] resPparts = null;

    while ((str = in.readLine()) != null) {
        String[] parts = str.split("_");

        if (resStr == null || version.compare(parts, resPparts) > 0) {
            resStr = str;
            resPparts = parts;
        }
    }

    return resStr;
}

static class ListComparator<T extends Comparable<T>> implements Comparator<List<T>> {

    @Override
    public int compare(List<T> o1, List<T> o2) {
        for (int i = 0; i < Math.max(o1.size(), o2.size()); i++) {
            int diff =
                    // Off the end of both - same.
                    i >= o1.size() && i >= o2.size() ? 0
                    // Off the end of 1 - the other is greater.
                    : i >= o1.size() ? -1
                    : i >= o2.size() ? 1
                    // Normal diff.
                    : o1.get(i).compareTo(o2.get(i));
            if (diff != 0) {
                return diff;
            }
        }
        return 0;
    }
}

private static final Comparator<List<Integer>> BY_VERSION = new ListComparator<Integer>().reversed();

public void test(String[] args) {
    String[] tests = {
            "1_10_2_0_154",
            "3_10_5_2_10",
            "2_10_4_1_49",
            "3_10_5_1_37",
            "3_10_5_1_37_0"
    };
    System.out.println("Before: " + Arrays.toString(tests));
    System.out.println("After:  " + Arrays.stream(tests)
            // Split into parts.
            .map(s -> s.split("_"))
            // Map String[] to List<Integer>
            .map(a -> Arrays.stream(a).map(s -> Integer.valueOf(s)).collect(Collectors.toList()))
            // Sort it.
            .sorted(BY_VERSION)
            // Back to a new list.
            .collect(Collectors.toList()));
}