আপনি জাভাতে দুটি সংস্করণ স্ট্রিংয়ের তুলনা করেন কীভাবে?

Question

সংস্করণ সংখ্যার তুলনা করার জন্য কি কোনও মানক আইডিয়াম আছে? আমি কেবল একটি সরল স্ট্রিং তুলনামূলক ব্যবহার করতে পারি না কারণ পয়েন্ট রিলিজের সর্বাধিক সংখ্যা কী হবে তা আমি এখনও জানি না। আমার সংস্করণগুলি তুলনা করতে হবে এবং নীচের ধারনাকে সত্য করে তুলতে হবে:

1.0 < 1.1
1.0.1 < 1.1
1.9 < 1.10

Comments

আপনি কি কেবল বিন্দুগুলি সরানোর এবং ফলস্বরূপ স্ট্রিংটিকে পূর্ণসংখ্যা হিসাবে পার্স করার চেষ্টা করেছেন? আমি বর্তমানে নিম্নলিখিত অনুরূপ কিছু ব্যবহার করছি: String version = "1.1.2".replace(".", ""); int number = Integer.parseInt(version); // = 112। আপনি এই সংখ্যাটি অন্য কোনওটির সাথে তুলনা করতে পারেন এবং এইভাবে আরও সাম্প্রতিক সংস্করণটি খুঁজে পেতে পারেন। অতিরিক্তভাবে আপনি পরীক্ষা করতে পারেন যে versionস্ট্রিংটি কিছু নির্দিষ্ট প্যাটার্নের সাথে মেলে কিনা ফলাফলটিতে \\d+\\.\\d+\\.\\dকমপক্ষে 3 টি সংখ্যা রয়েছে make

— নিবন্ধিত ব্যবহারকারী

@ নিবন্ধিত ব্যবহারকারী এটির মতো এই কীভাবে কাজ করবে: 1.12.1 এবং 1.1.34?

— kojow7

আপনাকে নিশ্চিত করতে হবে যে প্রতিটি অংশের দৈর্ঘ্য একই আকারের রয়েছে। সুতরাং আপনার উদাহরণের দুটি সংস্করণ তুলনা করতে সেগুলি অবশ্যই এই জাতীয় কিছু হবে: 1.12.01 এবং 1.01.34। জাভাতে আপনি .অক্ষরে প্রথম বিভাজন এবং প্রতিটি উপাদানগুলির দৈর্ঘ্যের তুলনা করে এটি অর্জন করতে পারেন । এরপরে সমস্ত উপাদানগুলিকে কেবল একটি স্ট্রিংয়ে রাখুন, তারপরে এটি int হিসাবে পার্স করুন এবং তারপরে অন্য সংস্করণের সাথে তুলনা করুন যা একইভাবে রূপান্তরিত হয়েছে

— নিবন্ধিত

শুধু শেয়ার করতে চেয়েছিলেন যে, এই আশ্চর্যজনক সংক্ষেপে খাঁজকাটা বাস্তবায়িত করা যায়নি stackoverflow.com/a/7737400/1195507

— rvazquezglez

Answer 1

ডিলিকে ডিলিমিটার হিসাবে টোকেনাইজ করুন এবং তারপরে বাম থেকে শুরু করে পূর্ণসংখ্যা অনুবাদ পাশাপাশি তুলনা করুন।

Comments

এটিই আমার সন্দেহ হয়েছিল যে আমাকে অবলম্বন করতে হবে। এর মধ্যে দুটি সংস্করণের স্ট্রিংয়ের সংক্ষিপ্ত আকারে টোকেনগুলির উপরে লুপিংও জড়িত। জানানোর জন্য ধন্যবাদ.

— বিল

এবং ভুলে যাবেন না আপনার সবসময় কেবলমাত্র সংখ্যা থাকবে না। কিছু অ্যাপ্লিকেশন বিল্ড নম্বর অন্তর্ভুক্ত করবে এবং এতে বিটা / ইত্যাদির জন্য 1.0.1b এর মতো জিনিস থাকতে পারে।

— জন গার্ডনার

তুমি এটা কিভাবে করো?

— বড় ম্যাকলার্জহিউজ

আপনি একটি রেজেক্স লিখুন যা স্ট্রিংটিকে ডিজিট এবং অ-অঙ্কের বিভাগে বিভক্ত করে। অঙ্কের বিভাগগুলিকে সংখ্যাগতভাবে এবং অ-অঙ্কের বিভাগগুলি অভিধানিকের সাথে তুলনা করুন। (সম্ভবত বিন্দুতে

— বিভক্তও

Answer 2

এই পুরানো পোস্টের জন্য আরও একটি সমাধান (তাদের জন্য এটি এটি সহায়তা করতে পারে):

public class Version implements Comparable<Version> {

    private String version;

    public final String get() {
        return this.version;
    }

    public Version(String version) {
        if(version == null)
            throw new IllegalArgumentException("Version can not be null");
        if(!version.matches("[0-9]+(\\.[0-9]+)*"))
            throw new IllegalArgumentException("Invalid version format");
        this.version = version;
    }

    @Override public int compareTo(Version that) {
        if(that == null)
            return 1;
        String[] thisParts = this.get().split("\\.");
        String[] thatParts = that.get().split("\\.");
        int length = Math.max(thisParts.length, thatParts.length);
        for(int i = 0; i < length; i++) {
            int thisPart = i < thisParts.length ?
                Integer.parseInt(thisParts[i]) : 0;
            int thatPart = i < thatParts.length ?
                Integer.parseInt(thatParts[i]) : 0;
            if(thisPart < thatPart)
                return -1;
            if(thisPart > thatPart)
                return 1;
        }
        return 0;
    }

    @Override public boolean equals(Object that) {
        if(this == that)
            return true;
        if(that == null)
            return false;
        if(this.getClass() != that.getClass())
            return false;
        return this.compareTo((Version) that) == 0;
    }

}

---

Version a = new Version("1.1");
Version b = new Version("1.1.1");
a.compareTo(b) // return -1 (a<b)
a.equals(b)    // return false

Version a = new Version("2.0");
Version b = new Version("1.9.9");
a.compareTo(b) // return 1 (a>b)
a.equals(b)    // return false

Version a = new Version("1.0");
Version b = new Version("1");
a.compareTo(b) // return 0 (a=b)
a.equals(b)    // return true

Version a = new Version("1");
Version b = null;
a.compareTo(b) // return 1 (a>b)
a.equals(b)    // return false

List<Version> versions = new ArrayList<Version>();
versions.add(new Version("2"));
versions.add(new Version("1.0.5"));
versions.add(new Version("1.01.0"));
versions.add(new Version("1.00.1"));
Collections.min(versions).get() // return min version
Collections.max(versions).get() // return max version

// WARNING
Version a = new Version("2.06");
Version b = new Version("2.060");
a.equals(b)    // return false

---

সম্পাদনা:

@ ডেস্কোগ: আপনার মন্তব্যের জন্য আপনাকে ধন্যবাদ, এই টুকরো কোডটি অ্যান্ড্রয়েড প্ল্যাটফর্মের জন্য তৈরি করা হয়েছে এবং গুগলের পরামর্শ অনুসারে, "ম্যাচগুলি" পদ্ধতিটি জাভা থেকে আলাদা স্ট্রিং যা একটি নিয়ামক নিদর্শন ব্যবহার করে তা পরীক্ষা করে। ( অ্যান্ড্রয়েড ডকুমেন্টেশন - জাভা ডকুমেন্টেশন )

Comments

এটি সেরা সমাধান আইএমএইচও। আমি এটিকে (! Version.matches ("[0-9] + (\\। [0-9] +) {0,2}") এ পরিবর্তন করে এবং একটি ভেরিয়েবল যুক্ত করে এটি 3 উপাদান সংস্করণ কোডগুলিতে সীমাবদ্ধ করেছি: প্রাইভেট স্ট্যাটিক ফাইনাল ইনট [] PRIME = {2, 3, 5}; আমি উপরের জন্য অনুপস্থিত হ্যাশকোড তৈরি করতে সক্ষম হয়েছি: @ ওভাররাইড পাবলিক ফাইনাল ইন হ্যাশকোড () {ফাইনাল স্ট্রিং [] পার্টস = এই.জেট () স্প্লিট ("\\।"); int হ্যাশকোড = 0; এর জন্য (int i = 0; i <যন্ত্রাংশের দৈর্ঘ্য; i++) {চূড়ান্ত int অংশ = পূর্ণসংখ্যা হ্যাশকোড + = প্রাইম [i] ^ অংশ;}} রিটার্ন হ্যাশকোড;}

— ব্যারি ইরভিন

Pattern.compile()আপনার যুক্তিটি O(N log N)জটিলতার সাথে ডাকা হয় নি, আপনার অন্তত অন্তর্ভুক্ত কলগুলিকে ক্যাশে করা উচিত ।

— লুকাশ এডার

এই বাস্তবায়ন সমান (ওজেক্ট যে) ওভাররাইড করে এবং তাই হ্যাশকোড () এর ওভাররাইড করা উচিত। দুটি বস্তু যা সমান হবে একই হ্যাশকোডটি অবশ্যই ফিরতে হবে অন্যথায় আপনি হ্যাশ সংগ্রহের সাহায্যে এই বিষয়গুলি ব্যবহার করলে আপনি সমস্যায় পড়তে পারেন।

— কলিন ফিলিপস

'নতুন সংস্করণ ("১.০") থেকে আপনি সংস্করণটির স্ট্রিংয়ের উপর হ্যাশ করতে পারবেন না equ । যে একই হ্যাশকোড ফিরে আসবে সমান // যেহেতু "1.0" সমান "1", আমরা সংস্করণ স্ট্রিং এর হ্যাশকোড আর আসতে পারবেন না @Override প্রকাশ্য int- এ হ্যাশকোড () {ফিরতি 1;}।

— কলিন ফিলিপস

Kotlin উপর রূপান্তরিত stackoverflow.com/a/61795721/6352712

— Serg Burlaka

Answer 3

ম্যাভেন ব্যবহার করা সত্যিই সহজ:

import org.apache.maven.artifact.versioning.DefaultArtifactVersion;

DefaultArtifactVersion minVersion = new DefaultArtifactVersion("1.0.1");
DefaultArtifactVersion maxVersion = new DefaultArtifactVersion("1.10");

DefaultArtifactVersion version = new DefaultArtifactVersion("1.11");

if (version.compareTo(minVersion) < 0 || version.compareTo(maxVersion) > 0) {
    System.out.println("Sorry, your version is unsupported");
}

আপনি এই পৃষ্ঠা থেকে মাভেন আর্টিফ্যাক্টের জন্য সঠিক নির্ভরতার স্ট্রিং পেতে পারেন :

<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-artifact</artifactId>
<version>3.0.3</version>
</dependency>

Comments

এটি কীভাবে করা যায় সে সম্পর্কে পরীক্ষাগুলির সংক্ষেপণ

— yclian

পারফেক্ট, চাকা পুনর্নবীকরণ করবেন না!

— লুয়ুইস মার্টিনেজ 21

কেবল একটি উদ্বেগ হ'ল: কেবলমাত্র এক কারণেই এটির প্রচুর ফাইলের সাথে এই নির্ভরতা ব্যবহার করা - একটি শ্রেণি থাকতে হবে - ডিফল্টআর্টিফ্যাক্ট ভার্সন

— সেস

@ এসএসের স্টোরেজটি সস্তা - মূল কোডটি লেখার চেয়ে পরীক্ষা করা এবং রক্ষণাবেক্ষণের তুলনায় সস্তা

— অ্যালেক্স ডিন '

নোটটি যেটি Comparable.compareTo"নেতিবাচক পূর্ণসংখ্যা, শূন্য বা ধনাত্মক পূর্ণসংখ্যার" হিসাবে প্রত্যাশিত, তাই -1 এবং +1 পরীক্ষা করা এড়ানো ভাল অভ্যাস।

— seanf

Answer 4

আপনার সংস্করণের স্ট্রিংগুলি স্বাভাবিক করতে হবে যাতে তাদের তুলনা করা যায়। কিছুটা এইরকম

import java.util.regex.Pattern;

public class Main {
    public static void main(String... args) {
        compare("1.0", "1.1");
        compare("1.0.1", "1.1");
        compare("1.9", "1.10");
        compare("1.a", "1.9");
    }

    private static void compare(String v1, String v2) {
        String s1 = normalisedVersion(v1);
        String s2 = normalisedVersion(v2);
        int cmp = s1.compareTo(s2);
        String cmpStr = cmp < 0 ? "<" : cmp > 0 ? ">" : "==";
        System.out.printf("'%s' %s '%s'%n", v1, cmpStr, v2);
    }

    public static String normalisedVersion(String version) {
        return normalisedVersion(version, ".", 4);
    }

    public static String normalisedVersion(String version, String sep, int maxWidth) {
        String[] split = Pattern.compile(sep, Pattern.LITERAL).split(version);
        StringBuilder sb = new StringBuilder();
        for (String s : split) {
            sb.append(String.format("%" + maxWidth + 's', s));
        }
        return sb.toString();
    }
}

ছাপে

'1.0' < '1.1'
'1.0.1' < '1.1'
'1.9' < '1.10'
'1.a' > '1.9'

Comments

স্বাভাবিকের মধ্যে ক্যাভেট হ'ল সেখানে থাকা প্রবন্ধের সর্বোচ্চ প্রস্থ।

— dlamblin

@ আইয়ার্ট অ্যান্ড্রয়েড ভাল বিষয়, আপনি যদি '4.1' == '4.1.0' আশা না করেন তবে আমি মনে করি এটি অর্থে অর্ডারিং।

— পিটার লরি

আমার উত্তরটি দেখুন, আমি তার উত্তরটি এখানে

— অভিনব পুরী

Answer 5

বিদ্যমান কোডটি পুনরায় ব্যবহার করার জন্য সেরা, মাভেনের তুলনামূলক ভার্সন ক্লাসটি নিন

সুবিধাদি:

• অ্যাপাচি লাইসেন্স, সংস্করণ 2.0,
• পরীক্ষা
• একাধিক প্রকল্পে ব্যবহৃত (অনুলিপি করা হয়েছে) যেমন বসন্ত-সুরক্ষা-কোর, জবিএস ইত্যাদি bo
• একাধিক বৈশিষ্ট্য
• এটি ইতিমধ্যে একটি java.lang.Comparable
• কেবলমাত্র সেই এক শ্রেণীর অনুলিপি করুন - কোনও তৃতীয় পক্ষের নির্ভরতা নেই

মাভেন-আর্টিক্যাক্টের উপর নির্ভরতা অন্তর্ভুক্ত করবেন না কারণ এটি বিভিন্ন ট্রানজিটিভ নির্ভরতা টানবে

Comments

এটি বিজ্ঞাপনের মতো পড়ে এবং অন্যান্য উত্তরের সাথে কিছু যোগ করে না।

— এডি_ক্যাট

সংস্করণ এবং খাঁটি সংস্করণ তুলনা তুলনামূলক মান পদ্ধতি সম্পর্কে যেমন প্রশ্নের সাথে প্রাসঙ্গিক এটি বেশ মানক।

— দিলিপ

এটি সেরা উত্তর। আমি বিশ্বাস করতে পারি না আরও কতজন (স্বীকৃত সহ) কিছু পরীক্ষা ছাড়াই হ্যাকি স্ট্রিং বিভক্ত করার চেষ্টা করে। কোডটি এই শ্রেণিটি ব্যবহার করে উদাহরণস্বরূপ:assertTrue(new ComparableVersion("1.1-BETA").compareTo(new ComparableVersion("1.1-RC")) < 0)

— ফ্যাবিয়ান ক্যাসলার

অসুবিধা: অনেকগুলি নির্ভরশীলতার মধ্যে টানুন, যার অর্থ আক্রমণের পৃষ্ঠের একটি হোস্ট এবং সংস্করণ সংঘাতের সম্ভাবনা।

— টুলফোজার

Answer 6

// VersionComparator.java
import java.util.Comparator;

public class VersionComparator implements Comparator {

    public boolean equals(Object o1, Object o2) {
        return compare(o1, o2) == 0;
    }

    public int compare(Object o1, Object o2) {
        String version1 = (String) o1;
        String version2 = (String) o2;

        VersionTokenizer tokenizer1 = new VersionTokenizer(version1);
        VersionTokenizer tokenizer2 = new VersionTokenizer(version2);

        int number1 = 0, number2 = 0;
        String suffix1 = "", suffix2 = "";

        while (tokenizer1.MoveNext()) {
            if (!tokenizer2.MoveNext()) {
                do {
                    number1 = tokenizer1.getNumber();
                    suffix1 = tokenizer1.getSuffix();
                    if (number1 != 0 || suffix1.length() != 0) {
                        // Version one is longer than number two, and non-zero
                        return 1;
                    }
                }
                while (tokenizer1.MoveNext());

                // Version one is longer than version two, but zero
                return 0;
            }

            number1 = tokenizer1.getNumber();
            suffix1 = tokenizer1.getSuffix();
            number2 = tokenizer2.getNumber();
            suffix2 = tokenizer2.getSuffix();

            if (number1 < number2) {
                // Number one is less than number two
                return -1;
            }
            if (number1 > number2) {
                // Number one is greater than number two
                return 1;
            }

            boolean empty1 = suffix1.length() == 0;
            boolean empty2 = suffix2.length() == 0;

            if (empty1 && empty2) continue; // No suffixes
            if (empty1) return 1; // First suffix is empty (1.2 > 1.2b)
            if (empty2) return -1; // Second suffix is empty (1.2a < 1.2)

            // Lexical comparison of suffixes
            int result = suffix1.compareTo(suffix2);
            if (result != 0) return result;

        }
        if (tokenizer2.MoveNext()) {
            do {
                number2 = tokenizer2.getNumber();
                suffix2 = tokenizer2.getSuffix();
                if (number2 != 0 || suffix2.length() != 0) {
                    // Version one is longer than version two, and non-zero
                    return -1;
                }
            }
            while (tokenizer2.MoveNext());

            // Version two is longer than version one, but zero
            return 0;
        }
        return 0;
    }
}

// VersionTokenizer.java
public class VersionTokenizer {
    private final String _versionString;
    private final int _length;

    private int _position;
    private int _number;
    private String _suffix;
    private boolean _hasValue;

    public int getNumber() {
        return _number;
    }

    public String getSuffix() {
        return _suffix;
    }

    public boolean hasValue() {
        return _hasValue;
    }

    public VersionTokenizer(String versionString) {
        if (versionString == null)
            throw new IllegalArgumentException("versionString is null");

        _versionString = versionString;
        _length = versionString.length();
    }

    public boolean MoveNext() {
        _number = 0;
        _suffix = "";
        _hasValue = false;

        // No more characters
        if (_position >= _length)
            return false;

        _hasValue = true;

        while (_position < _length) {
            char c = _versionString.charAt(_position);
            if (c < '0' || c > '9') break;
            _number = _number * 10 + (c - '0');
            _position++;
        }

        int suffixStart = _position;

        while (_position < _length) {
            char c = _versionString.charAt(_position);
            if (c == '.') break;
            _position++;
        }

        _suffix = _versionString.substring(suffixStart, _position);

        if (_position < _length) _position++;

        return true;
    }
}

উদাহরণ:

public class Main
{
    private static VersionComparator cmp;

    public static void main (String[] args)
    {
        cmp = new VersionComparator();
        Test(new String[]{"1.1.2", "1.2", "1.2.0", "1.2.1", "1.12"});
        Test(new String[]{"1.3", "1.3a", "1.3b", "1.3-SNAPSHOT"});
    }

    private static void Test(String[] versions) {
        for (int i = 0; i < versions.length; i++) {
            for (int j = i; j < versions.length; j++) {
                Test(versions[i], versions[j]);
            }
        }
    }

    private static void Test(String v1, String v2) {
        int result = cmp.compare(v1, v2);
        String op = "==";
        if (result < 0) op = "<";
        if (result > 0) op = ">";
        System.out.printf("%s %s %s\n", v1, op, v2);
    }
}

আউটপুট:

1.1.2 == 1.1.2                --->  same length and value
1.1.2 < 1.2                   --->  first number (1) less than second number (2) => -1
1.1.2 < 1.2.0                 --->  first number (1) less than second number (2) => -1
1.1.2 < 1.2.1                 --->  first number (1) less than second number (2) => -1
1.1.2 < 1.12                  --->  first number (1) less than second number (12) => -1
1.2 == 1.2                    --->  same length and value
1.2 == 1.2.0                  --->  first shorter than second, but zero
1.2 < 1.2.1                   --->  first shorter than second, and non-zero
1.2 < 1.12                    --->  first number (2) less than second number (12) => -1
1.2.0 == 1.2.0                --->  same length and value
1.2.0 < 1.2.1                 --->  first number (0) less than second number (1) => -1
1.2.0 < 1.12                  --->  first number (2) less than second number (12) => -1
1.2.1 == 1.2.1                --->  same length and value
1.2.1 < 1.12                  --->  first number (2) less than second number (12) => -1
1.12 == 1.12                  --->  same length and value

1.3 == 1.3                    --->  same length and value
1.3 > 1.3a                    --->  first suffix ('') is empty, but not second ('a') => 1
1.3 > 1.3b                    --->  first suffix ('') is empty, but not second ('b') => 1
1.3 > 1.3-SNAPSHOT            --->  first suffix ('') is empty, but not second ('-SNAPSHOT') => 1
1.3a == 1.3a                  --->  same length and value
1.3a < 1.3b                   --->  first suffix ('a') compared to second suffix ('b') => -1
1.3a < 1.3-SNAPSHOT           --->  first suffix ('a') compared to second suffix ('-SNAPSHOT') => -1
1.3b == 1.3b                  --->  same length and value
1.3b < 1.3-SNAPSHOT           --->  first suffix ('b') compared to second suffix ('-SNAPSHOT') => -1
1.3-SNAPSHOT == 1.3-SNAPSHOT  --->  same length and value

Answer 7

ভাবছেন কেন সবাই অনুমান করে যে সংস্করণগুলি কেবল পূর্ণসংখ্যা দিয়ে তৈরি - আমার ক্ষেত্রে এটি ছিল না।

চাকাটি পুনর্বিবেচনা কেন করা (সংস্করণটি সেমভার মান অনুসরণ করে)

মাভেনের মাধ্যমে প্রথমে https://github.com/vdurmont/semver4j ইনস্টল করুন

তারপরে এই গ্রন্থাগারটি ব্যবহার করুন

Semver sem = new Semver("1.2.3");
sem.isGreaterThan("1.2.2"); // true

Answer 8

public static int compareVersions(String version1, String version2){

    String[] levels1 = version1.split("\\.");
    String[] levels2 = version2.split("\\.");

    int length = Math.max(levels1.length, levels2.length);
    for (int i = 0; i < length; i++){
        Integer v1 = i < levels1.length ? Integer.parseInt(levels1[i]) : 0;
        Integer v2 = i < levels2.length ? Integer.parseInt(levels2[i]) : 0;
        int compare = v1.compareTo(v2);
        if (compare != 0){
            return compare;
        }
    }

    return 0;
}

Comments

সাধারণ ক্ষেত্রে কার্যকর।

— ক্রিস্টোফ রাউসি

আপনার ধারণার ভিত্তিতে stackoverflow.com/a/62532745/2642478

— Xan

Answer 9

আপনার প্রকল্পটিতে ইতিমধ্যে জ্যাকসন থাকলে আপনি ব্যবহার করতে পারেন com.fasterxml.jackson.core.Version:

import com.fasterxml.jackson.core.Version;
import org.junit.Test;

import static org.junit.Assert.assertTrue;

public class VersionTest {

    @Test
    public void shouldCompareVersion() {
        Version version1 = new Version(1, 11, 1, null, null, null);
        Version version2 = new Version(1, 12, 1, null, null, null);
        assertTrue(version1.compareTo(version2) < 0);
    }
}

Answer 10

public int compare(String v1, String v2) {
        v1 = v1.replaceAll("\\s", "");
        v2 = v2.replaceAll("\\s", "");
        String[] a1 = v1.split("\\.");
        String[] a2 = v2.split("\\.");
        List<String> l1 = Arrays.asList(a1);
        List<String> l2 = Arrays.asList(a2);


        int i=0;
        while(true){
            Double d1 = null;
            Double d2 = null;

            try{
                d1 = Double.parseDouble(l1.get(i));
            }catch(IndexOutOfBoundsException e){
            }

            try{
                d2 = Double.parseDouble(l2.get(i));
            }catch(IndexOutOfBoundsException e){
            }

            if (d1 != null && d2 != null) {
                if (d1.doubleValue() > d2.doubleValue()) {
                    return 1;
                } else if (d1.doubleValue() < d2.doubleValue()) {
                    return -1;
                }
            } else if (d2 == null && d1 != null) {
                if (d1.doubleValue() > 0) {
                    return 1;
                }
            } else if (d1 == null && d2 != null) {
                if (d2.doubleValue() > 0) {
                    return -1;
                }
            } else {
                break;
            }
            i++;
        }
        return 0;
    }

Answer 11

/**  
 *  written by: Stan Towianski - May 2018 
 * notes: I make assumption each of 3 version sections a.b.c is not longer then 4 digits: aaaa.bbbb.cccc-MODWORD1(-)modnum2
 * 5.10.13-release-1 becomes 0000500100013.501     6.0-snapshot becomes 0000600000000.100
 * MODWORD1 = -xyz/NotMatching, -SNAPSHOT, -ALPHA, -BETA, -RC, -RELEASE/nothing  return:  .0, .1, .2, .3, .4, .5
 * modnum2 = up to 2 digit/chars second version
 * */
public class VersionCk {

    private static boolean isVersionHigher( String baseVersion, String testVersion )
        {
        System.out.println( "versionToComparable( baseVersion ) =" + versionToComparable( baseVersion ) );
        System.out.println( "versionToComparable( testVersion ) =" + versionToComparable( testVersion ) + " is this higher ?" );
        return versionToComparable( testVersion ).compareTo( versionToComparable( baseVersion ) ) > 0;
        }

    //----  not worrying about += for something so small
    private static String versionToComparable( String version )
        {
//        System.out.println("version - " + version);
        String versionNum = version;
        int at = version.indexOf( '-' );
        if ( at >= 0 )
            versionNum = version.substring( 0, at );

        String[] numAr = versionNum.split( "\\." );
        String versionFormatted = "0";
        for ( String tmp : numAr )
            {
            versionFormatted += String.format( "%4s", tmp ).replace(' ', '0');
            }
        while ( versionFormatted.length() < 12 )  // pad out to aaaa.bbbb.cccc
            {
            versionFormatted += "0000";
            }
//        System.out.println( "converted min version =" + versionFormatted + "=   : " + versionNum );
        return versionFormatted + getVersionModifier( version, at );
        }

    //----  use order low to high: -xyz, -SNAPSHOT, -ALPHA, -BETA, -RC, -RELEASE/nothing  returns: 0, 1, 2, 3, 4, 5
    private static String getVersionModifier( String version, int at )
        {
//        System.out.println("version - " + version );
        String[] wordModsAr = { "-SNAPSHOT", "-ALPHA", "-BETA", "-RC", "-RELEASE" };        

        if ( at < 0 )
            return "." + wordModsAr.length + "00";   // make nothing = RELEASE level

        int i = 1;
        for ( String word : wordModsAr )
            {
            if ( ( at = version.toUpperCase().indexOf( word ) ) > 0 )
                return "." + i + getSecondVersionModifier( version.substring( at + word.length() ) );
            i++;
            }

        return ".000";
        }

    //----  add 2 chars for any number after first modifier.  -rc2 or -rc-2   returns 02
    private static String getSecondVersionModifier( String version )
        {
        System.out.println( "second modifier =" + version + "=" );
        Matcher m = Pattern.compile("(.*?)(\\d+).*").matcher( version );
//        if ( m.matches() )
//            System.out.println( "match ? =" + m.matches() + "=   m.group(1) =" + m.group(1) + "=   m.group(2) =" + m.group(2) + "=   m.group(3) =" + (m.groupCount() >= 3 ? m.group(3) : "x") );
//        else
//            System.out.println( "No match" );
        return m.matches() ? String.format( "%2s", m.group(2) ).replace(' ', '0') : "00";
        }

    public static void main(String[] args) 
        {
        checkVersion( "3.10.0", "3.4.0");
        checkVersion( "5.4.2", "5.4.1");
        checkVersion( "5.4.4", "5.4.5");
        checkVersion( "5.4.9", "5.4.12");
        checkVersion( "5.9.222", "5.10.12");
        checkVersion( "5.10.12", "5.10.12");
        checkVersion( "5.10.13", "5.10.14");
        checkVersion( "6.7.0", "6.8");
        checkVersion( "6.7", "2.7.0");
        checkVersion( "6", "6.3.1");
        checkVersion( "4", "4.0.0");
        checkVersion( "6.3.0", "6");
        checkVersion( "5.10.12-Alpha", "5.10.12-beTA");
        checkVersion( "5.10.13-release", "5.10.14-beta");
        checkVersion( "6.7.0", "6.8-snapshot");
        checkVersion( "6.7.1", "6.7.0-release");
        checkVersion( "6-snapshot", "6.0.0-beta");
        checkVersion( "6.0-snapshot", "6.0.0-whatthe");
        checkVersion( "5.10.12-Alpha-1", "5.10.12-alpha-2");
        checkVersion( "5.10.13-release-1", "5.10.13-release2");
        checkVersion( "10-rc42", "10.0.0-rc53");
        }

    private static void checkVersion(String baseVersion, String testVersion) 
        {
        System.out.println( "baseVersion - " + baseVersion );
        System.out.println( "testVersion - " + testVersion );
        System.out.println( "isVersionHigher = " + isVersionHigher( baseVersion, testVersion ) );
        System.out.println( "---------------");
        }

    }

কিছু আউটপুট:

---------------
baseVersion - 6.7
testVersion - 2.7.0
versionToComparable( baseVersion ) =0000600070000.500
versionToComparable( testVersion ) =0000200070000.500 is this higher ?
isVersionHigher = false
---------------
baseVersion - 6
testVersion - 6.3.1
versionToComparable( baseVersion ) =0000600000000.500
versionToComparable( testVersion ) =0000600030001.500 is this higher ?
isVersionHigher = true
---------------
baseVersion - 4
testVersion - 4.0.0
versionToComparable( baseVersion ) =0000400000000.500
versionToComparable( testVersion ) =0000400000000.500 is this higher ?
isVersionHigher = false
---------------
baseVersion - 6.3.0
testVersion - 6
versionToComparable( baseVersion ) =0000600030000.500
versionToComparable( testVersion ) =0000600000000.500 is this higher ?
isVersionHigher = false
---------------
baseVersion - 5.10.12-Alpha
testVersion - 5.10.12-beTA
second modifier ==
versionToComparable( baseVersion ) =0000500100012.200
second modifier ==
versionToComparable( testVersion ) =0000500100012.300 is this higher ?
second modifier ==
second modifier ==
isVersionHigher = true
---------------
baseVersion - 5.10.13-release
testVersion - 5.10.14-beta
second modifier ==
versionToComparable( baseVersion ) =0000500100013.500
second modifier ==
versionToComparable( testVersion ) =0000500100014.300 is this higher ?
second modifier ==
second modifier ==
isVersionHigher = true
---------------
baseVersion - 6.7.0
testVersion - 6.8-snapshot
versionToComparable( baseVersion ) =0000600070000.500
second modifier ==
versionToComparable( testVersion ) =0000600080000.100 is this higher ?
second modifier ==
isVersionHigher = true
---------------
baseVersion - 6.7.1
testVersion - 6.7.0-release
versionToComparable( baseVersion ) =0000600070001.500
second modifier ==
versionToComparable( testVersion ) =0000600070000.500 is this higher ?
second modifier ==
isVersionHigher = false
---------------
baseVersion - 6-snapshot
testVersion - 6.0.0-beta
second modifier ==
versionToComparable( baseVersion ) =0000600000000.100
second modifier ==
versionToComparable( testVersion ) =0000600000000.300 is this higher ?
second modifier ==
second modifier ==
isVersionHigher = true
---------------
baseVersion - 6.0-snapshot
testVersion - 6.0.0-whatthe
second modifier ==
versionToComparable( baseVersion ) =0000600000000.100
versionToComparable( testVersion ) =0000600000000.000 is this higher ?
second modifier ==
isVersionHigher = false
---------------
baseVersion - 5.10.12-Alpha-1
testVersion - 5.10.12-alpha-2
second modifier =-1=
versionToComparable( baseVersion ) =0000500100012.201
second modifier =-2=
versionToComparable( testVersion ) =0000500100012.202 is this higher ?
second modifier =-2=
second modifier =-1=
isVersionHigher = true
---------------
baseVersion - 5.10.13-release-1
testVersion - 5.10.13-release2
second modifier =-1=
versionToComparable( baseVersion ) =0000500100013.501
second modifier =2=
versionToComparable( testVersion ) =0000500100013.502 is this higher ?
second modifier =2=
second modifier =-1=
isVersionHigher = true
---------------
baseVersion - 10-rc42
testVersion - 10.0.0-rc53
second modifier =42=
versionToComparable( baseVersion ) =0001000000000.442
second modifier =53=
versionToComparable( testVersion ) =0001000000000.453 is this higher ?
second modifier =53=
second modifier =42=
isVersionHigher = true
---------------

Answer 12

আমি MgntUtils নামে একটি ওপেন সোর্স লাইব্রেরি লিখেছি যার স্ট্রিং সংস্করণগুলির সাথে কাজ করে এমন একটি ইউটিলিটি রয়েছে। এটি তাদের সাথে সঠিকভাবে তুলনা করে, সংস্করণ রেঞ্জগুলির সাথে আরও কাজ করে। এই লাইব্রেরিটি জাভাদোক দেখুন পদ্ধতিগুলি TextUtils.comapreVersions(...)। এটি ভারী ব্যবহার করা হয়েছে এবং ভালভাবে পরীক্ষা করা হয়েছে। এখানে নিবন্ধটি লাইব্রেরি এবং কোথায় এটি পেতে হবে তা বর্ণনা করে। এটি ম্যাভেন আর্টিক্ট হিসাবে এবং গিথুবে (উত্স এবং জাভাক সহ) উপলভ্য

Answer 13

আমার প্রকল্পগুলির জন্য আমি আমার কমন্স-সংস্করণ লাইব্রেরি https://github.com/raydac/commons-version ব্যবহার করি এটিতে দুটি সহায়ক শ্রেণি রয়েছে - সংস্করণ পার্স করার জন্য (পার্সড সংস্করণটিকে অন্য সংস্করণের অবজেক্টের সাথে তুলনা করা যায় কারণ এটি তুলনীয়) এবং সংস্করণভালিডেটর যা কিছু মত প্রকাশের জন্য সংস্করণ চেক করতে দেয়!=ide-1.1.1,>idea-1.3.4-SNAPSHOT;<1.2.3

Answer 14

আমি সিমেন্টিক ভার্সন কনভেনশন ব্যবহার করে অ্যান্ড্রয়েড প্ল্যাটফর্মে সংস্করণগুলির তুলনা করার জন্য সহজ ইউটিলিটি তৈরি করেছি । সুতরাং এটি কেবল এক্সওয়াইজেড (মেজর.মিনোর.প্যাচ) ফর্ম্যাটে স্ট্রিংয়ের জন্য কাজ করে যেখানে এক্স, ওয়াই এবং জেড অ-নেতিবাচক পূর্ণসংখ্যা। আপনি এটি আমার গিটহাবটিতে খুঁজে পেতে পারেন ।

মেথড ভার্সন ডটকম স্পয়ারভিশনস (স্ট্রিং ভি 1, স্ট্রিং ভি 2) দুটি সংস্করণের স্ট্রিং তুলনা করে। সংস্করণ সমান হলে এটি 0 প্রদান করে, সংস্করণ v1 এর আগে সংস্করণ v1 এর আগে 1, সংস্করণ v1 সংস্করণ ভি 2 এর পরে -1, সংস্করণ বিন্যাস অবৈধ থাকলে -2 আসবে।

Comments

আপনার গিটহাব লিঙ্কটি পাওয়া যায় নি

— aldok

Answer 15

public int CompareVersions(String version1, String version2)
{
    String[] string1Vals = version1.split("\\.");
    String[] string2Vals = version2.split("\\.");

    int length = Math.max(string1Vals.length, string2Vals.length);

    for (int i = 0; i < length; i++)
    {
        Integer v1 = (i < string1Vals.length)?Integer.parseInt(string1Vals[i]):0;
        Integer v2 = (i < string2Vals.length)?Integer.parseInt(string2Vals[i]):0;

        //Making sure Version1 bigger than version2
        if (v1 > v2)
        {
            return 1;
        }
        //Making sure Version1 smaller than version2
        else if(v1 < v2)
        {
            return -1;
        }
    }

    //Both are equal
    return 0;
}

Answer 16

নিজেই একটি সামান্য ফাংশন লিখেছিলেন imp

 public static boolean checkVersionUpdate(String olderVerison, String newVersion) {
        if (olderVerison.length() == 0 || newVersion.length() == 0) {
            return false;
        }
        List<String> newVerList = Arrays.asList(newVersion.split("\\."));
        List<String> oldVerList = Arrays.asList(olderVerison.split("\\."));

        int diff = newVerList.size() - oldVerList.size();
        List<String> newList = new ArrayList<>();
        if (diff > 0) {
            newList.addAll(oldVerList);
            for (int i = 0; i < diff; i++) {
                newList.add("0");
            }
            return examineArray(newList, newVerList, diff);
        } else if (diff < 0) {
            newList.addAll(newVerList);
            for (int i = 0; i < -diff; i++) {
                newList.add("0");
            }
            return examineArray(oldVerList, newList, diff);
        } else {
            return examineArray(oldVerList, newVerList, diff);
        }

    }

    public static boolean examineArray(List<String> oldList, List<String> newList, int diff) {
        boolean newVersionGreater = false;
        for (int i = 0; i < oldList.size(); i++) {
            if (Integer.parseInt(newList.get(i)) > Integer.parseInt(oldList.get(i))) {
                newVersionGreater = true;
                break;
            } else if (Integer.parseInt(newList.get(i)) < Integer.parseInt(oldList.get(i))) {
                newVersionGreater = false;
                break;
            } else {
                newVersionGreater = diff > 0;
            }
        }

        return newVersionGreater;
    }

Answer 17

সংস্করণ সংখ্যাগুলির তুলনা করার জন্য আমি একটি ছোট জাভা / অ্যান্ড্রয়েড লাইব্রেরি লিখেছি: https://github.com/G00fY2/version-compare

এটি মূলত যা করে তা হ'ল:

  public int compareVersions(String versionA, String versionB) {
    String[] versionTokensA = versionA.split("\\.");
    String[] versionTokensB = versionB.split("\\.");
    List<Integer> versionNumbersA = new ArrayList<>();
    List<Integer> versionNumbersB = new ArrayList<>();

    for (String versionToken : versionTokensA) {
      versionNumbersA.add(Integer.parseInt(versionToken));
    }
    for (String versionToken : versionTokensB) {
      versionNumbersB.add(Integer.parseInt(versionToken));
    }

    final int versionASize = versionNumbersA.size();
    final int versionBSize = versionNumbersB.size();
    int maxSize = Math.max(versionASize, versionBSize);

    for (int i = 0; i < maxSize; i++) {
      if ((i < versionASize ? versionNumbersA.get(i) : 0) > (i < versionBSize ? versionNumbersB.get(i) : 0)) {
        return 1;
      } else if ((i < versionASize ? versionNumbersA.get(i) : 0) < (i < versionBSize ? versionNumbersB.get(i) : 0)) {
        return -1;
      }
    }
    return 0;
  }

এই স্নিপেট কোনও ত্রুটি চেক বা পরিচালনা করার প্রস্তাব দেয় না। এর পাশাপাশি আমার গ্রন্থাগারটি "1.2-rc"> "1.2-beta" এর মতো প্রত্যয়কেও সমর্থন করে।

Answer 18

উপাদানগুলিতে নেতৃস্থানীয় শূন্যগুলি প্রতিস্থাপন করতে জাভা 8 স্ট্রিম ব্যবহার করা। এই কোডটি ইন্টারভিউবিট.কম এ সমস্ত পরীক্ষা পাস করেছে

public int compareVersion(String A, String B) {
    List<String> strList1 = Arrays.stream(A.split("\\."))
                                           .map(s -> s.replaceAll("^0+(?!$)", ""))
                                           .collect(Collectors.toList());
    List<String> strList2 = Arrays.stream(B.split("\\."))
                                           .map(s -> s.replaceAll("^0+(?!$)", ""))
                                           .collect(Collectors.toList());
    int len1 = strList1.size();
    int len2 = strList2.size();
    int i = 0;
    while(i < len1 && i < len2){
        if (strList1.get(i).length() > strList2.get(i).length()) return 1;
        if (strList1.get(i).length() < strList2.get(i).length()) return -1;
        int result = new Long(strList1.get(i)).compareTo(new Long(strList2.get(i)));
        if (result != 0) return result;
        i++;
    }
    while (i < len1){
        if (!strList1.get(i++).equals("0")) return 1;
    }
    while (i < len2){
        if (!strList2.get(i++).equals("0")) return -1;
    }
    return 0;
}

Answer 19

যেহেতু এই পৃষ্ঠার কোনও উত্তর মিশ্র পাঠ্যকে ভালভাবে পরিচালনা করে না, তাই আমি নিজের সংস্করণটি তৈরি করেছি:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Main {
    static double parseVersion(String v) {
        if (v.isEmpty()) {
            return 0;
        }
        Pattern p = Pattern.compile("^(\\D*)(\\d*)(\\D*)$");
        Matcher m = p.matcher(v);
    m.find();
    if (m.group(2).isEmpty()) {
      // v1.0.0.[preview]
      return -1;
    }
        double i = Integer.parseInt(m.group(2));
    if (!m.group(3).isEmpty()) {
      // v1.0.[0b]
      i -= 0.1;
    }
    return i;
    }

    public static int versionCompare(String str1, String str2) {
        String[] v1 = str1.split("\\.");
        String[] v2 = str2.split("\\.");
        int i = 0;
        for (; i < v1.length && i < v2.length; i++) {
            double iv1 = parseVersion(v1[i]);
            double iv2 = parseVersion(v2[i]);

            if (iv1 != iv2) {
                return iv1 - iv2 < 0 ? -1 : 1;
            }
        }
        if (i < v1.length) {
      // "1.0.1", "1.0"
            double iv1 = parseVersion(v1[i]);
            return iv1 < 0 ? -1 : (int)Math.ceil(iv1);
        }
        if (i < v2.length) {
            double iv2 = parseVersion(v2[i]);
            return - iv2 < 0 ? -1 : (int)Math.ceil(iv2);
        }
        return 0;
    }


  public static void main(String[] args) {
    System.out.println("versionCompare(v1.0.0, 1.0.0)");
    System.out.println(versionCompare("v1.0.0", "1.0.0")); // 0

    System.out.println("versionCompare(v1.0.0b, 1.0.0)");
    System.out.println(versionCompare("v1.0.0b", "1.0.0")); // -1

    System.out.println("versionCompare(v1.0.0.preview, 1.0.0)");
    System.out.println(versionCompare("v1.0.0.preview", "1.0.0")); // -1

    System.out.println("versionCompare(v1.0, 1.0.0)");
    System.out.println(versionCompare("v1.0", "1.0.0")); // 0

    System.out.println("versionCompare(ver1.0, 1.0.1)");
    System.out.println(versionCompare("ver1.0", "1.0.1")); // -1
  }
}

এটি এখনও আপনার ক্ষেত্রে "বিটা" এর সাথে "আলফা" তুলনা করার ক্ষেত্রে সংক্ষিপ্ত হয়ে পড়ে।

Answer 20

যে কেউ সংস্করণ নম্বরের উপর ভিত্তি করে ফোর্স আপডেট সতর্কতা প্রদর্শন করতে যাচ্ছেন তার জন্য আমার নিম্নলিখিত আইডিয়া রয়েছে। অ্যান্ড্রয়েড কারেন্ট অ্যাপ্লিকেশন সংস্করণ এবং ফায়ারবেস রিমোট কনফিগার সংস্করণের মধ্যে সংস্করণগুলির তুলনা করার সময় এটি ব্যবহার করা যেতে পারে। এটি জিজ্ঞাসা করা প্রশ্নের সঠিক উত্তর নয় তবে এটি অবশ্যই কাউকে সহায়তা করবে।

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
public class Main
{
  static String firebaseVersion = "2.1.3"; // or 2.1
  static String appVersion = "2.1.4";
  static List<String> firebaseVersionArray;
  static List<String> appVersionArray;
  static boolean isNeedToShowAlert = false;
  public static void main (String[]args)
  {
    System.out.println ("Hello World");
    firebaseVersionArray = new ArrayList<String>(Arrays.asList(firebaseVersion.split ("\\.")));
    appVersionArray = new ArrayList<String>(Arrays.asList(appVersion.split ("\\.")));
    if(appVersionArray.size() < firebaseVersionArray.size()) {
        appVersionArray.add("0");
    }
    if(firebaseVersionArray.size() < appVersionArray.size()) {
        firebaseVersionArray.add("0");
    }
    isNeedToShowAlert = needToShowAlert(); //Returns false
    System.out.println (isNeedToShowAlert);

  }
  static boolean needToShowAlert() {
      boolean result = false;
      for(int i = 0 ; i < appVersionArray.size() ; i++) {
          if (Integer.parseInt(appVersionArray.get(i)) == Integer.parseInt(firebaseVersionArray.get(i))) {
              continue;
          } else if (Integer.parseInt(appVersionArray.get(i)) > Integer.parseInt(firebaseVersionArray.get(i))){
             result = false;
             break;
          } else if (Integer.parseInt(appVersionArray.get(i)) < Integer.parseInt(firebaseVersionArray.get(i))) {
             result = true;
             break;  
          }
      }
      return result;
  }
}

আপনি এই কোডটি https://www.onlinegdb.com/online_java_compiler এ আটকানোর মাধ্যমে চালাতে পারেন

Answer 21

public static void main(String[] args) {

    String version1 = "1.0";
    String version2 = "1.0.0";
    String[] version1_splits = version1.split("\\.");
    String[] version2_splits = version2.split("\\.");
    int length = version1_splits.length >= version2_splits.length ? version1_splits.length : version2_splits.length;
    int i=0;
    for(;i<length;i++){
        int version1_int = getValue(version1_splits,i);
        int version2_int = getValue(version2_splits,i);
        if(version1_int > version2_int){
            System.out.println("version1 > version2");
            break;
        }
        else if(version1_int < version2_int){
            System.out.println("version2 > version1");
            break;
        }
        else{
            if(i == length-1)
            System.out.println("version1 = version2");
        }
    }
}

private static int getValue(String[] version1_splits, int i) {
    int temp;
    try{
        temp = Integer.valueOf(version1_splits[i]);
    }
    catch(IndexOutOfBoundsException e){
        temp=0;
    }

    return temp;
}

Answer 22

আমি এখনই এটি করেছি এবং নিজেকে জিজ্ঞাসা করেছি, এটি কি সঠিক? কারণ আমি আমার চেয়ে আগে কখনও পরিষ্কার সমাধান খুঁজে পাইনি:

আপনাকে কেবল উদাহরণের মতো স্ট্রিং সংস্করণগুলি ("1.0.0") বিভক্ত করতে হবে:

userVersion.split("\\.")

তারপরে আপনার কাছে থাকবে: {"1", "0", "0"}

এখন, আমি যে পদ্ধতিটি করেছি তা ব্যবহার করে:

isUpdateAvailable(userVersion.split("\\."), latestVersionSplit.split("\\."));

পদ্ধতি:

/**
 * Compare two versions
 *
 * @param userVersionSplit   - User string array with major, minor and patch version from user (exemple: {"5", "2", "70"})
 * @param latestVersionSplit - Latest string array with major, minor and patch version from api (example: {"5", "2", "71"})
 * @return true if user version is smaller than latest version
 */
public static boolean isUpdateAvailable(String[] userVersionSplit, String[] latestVersionSplit) {

    int majorUserVersion = Integer.parseInt(userVersionSplit[0]);
    int minorUserVersion = Integer.parseInt(userVersionSplit[1]);
    int patchUserVersion = Integer.parseInt(userVersionSplit[2]);

    int majorLatestVersion = Integer.parseInt(latestVersionSplit[0]);
    int minorLatestVersion = Integer.parseInt(latestVersionSplit[1]);
    int patchLatestVersion = Integer.parseInt(latestVersionSplit[2]);

    if (majorUserVersion <= majorLatestVersion) {
        if (majorUserVersion < majorLatestVersion) {
            return true;
        } else {
            if (minorUserVersion <= minorLatestVersion) {
                if (minorUserVersion < minorLatestVersion) {
                    return true;
                } else {
                    return patchUserVersion < patchLatestVersion;
                }
            }
        }
    }

    return false;
}

কোনও প্রতিক্রিয়ার জন্য অপেক্ষা করছি :)

Answer 23

@ অ্যালেক্সের পোস্ট কোটলিনে

class Version(inputVersion: String) : Comparable<Version> {

        var version: String
            private set

        override fun compareTo(other: Version) =
            (split() to other.split()).let {(thisParts, thatParts)->
                val length = max(thisParts.size, thatParts.size)
                for (i in 0 until length) {
                    val thisPart = if (i < thisParts.size) thisParts[i].toInt() else 0
                    val thatPart = if (i < thatParts.size) thatParts[i].toInt() else 0
                    if (thisPart < thatPart) return -1
                    if (thisPart > thatPart) return 1
                }
                 0
            }

        init {
            require(inputVersion.matches("[0-9]+(\\.[0-9]+)*".toRegex())) { "Invalid version format" }
            version = inputVersion
        }
    }

    fun Version.split() = version.split(".").toTypedArray()

ব্যবহার:

Version("1.2.4").compareTo(Version("0.0.5")) //return 1

Answer 24

https://stackoverflow.com/a/27891752/2642478 এর উপর ভিত্তি করে

class Version(private val value: String) : Comparable<Version> {
    private val splitted by lazy { value.split("-").first().split(".").map { it.toIntOrNull() ?: 0 } }

    override fun compareTo(other: Version): Int {
        for (i in 0 until maxOf(splitted.size, other.splitted.size)) {
            val compare = splitted.getOrElse(i) { 0 }.compareTo(other.splitted.getOrElse(i) { 0 })
            if (compare != 0)
                return compare
        }
        return 0
    }
}

আপনি যেমন ব্যবহার করতে পারেন:

    System.err.println(Version("1.0").compareTo( Version("1.0")))
    System.err.println(Version("1.0") < Version("1.1"))
    System.err.println(Version("1.10") > Version("1.9"))
    System.err.println(Version("1.10.1") > Version("1.10"))
    System.err.println(Version("0.0.1") < Version("1"))

Answer 25

এই কোডটি এই ধরণের তুলনা সংস্করণগুলিকে সমাধান করার চেষ্টা করে।

সংস্করণ স্পেসিফায়ারগুলির বেশিরভাগ> = 1.0 এর মতো স্ব-ব্যাখ্যামূলক। সুনির্দিষ্ট ~> এর একটি বিশেষ অর্থ রয়েছে, উদাহরণ দ্বারা সেরা দেখানো হয়েছে। ~> ২.০.৩> = ২.০.৩ এবং <২.১ এর সাথে অভিন্ন। ~> 2.1> = 2.1 এবং <3.0 এর সাথে সমান।

public static boolean apply(String cmpDeviceVersion, String reqDeviceVersion)
{
    Boolean equal           = !cmpDeviceVersion.contains(">") && !cmpDeviceVersion.contains(">=") &&
                              !cmpDeviceVersion.contains("<") && !cmpDeviceVersion.contains("<=") &&
                              !cmpDeviceVersion.contains("~>");

    Boolean between         = cmpDeviceVersion.contains("~>");
    Boolean higher          = cmpDeviceVersion.contains(">") && !cmpDeviceVersion.contains(">=") && !cmpDeviceVersion.contains("~>");
    Boolean higherOrEqual   = cmpDeviceVersion.contains(">=");

    Boolean less            = cmpDeviceVersion.contains("<") && !cmpDeviceVersion.contains("<=");
    Boolean lessOrEqual     = cmpDeviceVersion.contains("<=");

    cmpDeviceVersion        = cmpDeviceVersion.replaceAll("[<>=~]", "");
    cmpDeviceVersion        = cmpDeviceVersion.trim();

    String[] version        = cmpDeviceVersion.split("\\.");
    String[] reqVersion     = reqDeviceVersion.split("\\.");

    if(equal)
    {
        return isEqual(version, reqVersion);
    }
    else if(between)
    {
        return isBetween(version, reqVersion);
    }
    else if(higher)
    {
        return isHigher(version, reqVersion);
    }
    else if(higherOrEqual)
    {
        return isEqual(version, reqVersion) || isHigher(version, reqVersion);
    }
    else if(less)
    {
        return isLess(version, reqVersion);
    }
    else if(lessOrEqual)
    {
        return isEqual(version, reqVersion) || isLess(version, reqVersion);
    }

    return false;
}

private static boolean isEqual(String[] version, String[] reqVersion)
{
    String strVersion = StringUtils.join(version);
    String strReqVersion = StringUtils.join(reqVersion);
    if(version.length > reqVersion.length)
    {
        Integer diff = version.length - reqVersion.length;
        strReqVersion += StringUtils.repeat(".0", diff);
    }
    else if(reqVersion.length > version.length)
    {
        Integer diff = reqVersion.length - version.length;
        strVersion += StringUtils.repeat(".0", diff);
    }

    return strVersion.equals(strReqVersion);
}

private static boolean isHigher(String[] version, String[] reqVersion)
{
    String strVersion = StringUtils.join(version);
    String strReqVersion = StringUtils.join(reqVersion);
    if(version.length > reqVersion.length)
    {
        Integer diff = version.length - reqVersion.length;
        strReqVersion += StringUtils.repeat(".0", diff);
    }
    else if(reqVersion.length > version.length)
    {
        Integer diff = reqVersion.length - version.length;
        strVersion += StringUtils.repeat(".0", diff);
    }

    return strReqVersion.compareTo(strVersion) > 0;
}

private static boolean isLess(String[] version, String[] reqVersion)
{
    String strVersion = StringUtils.join(version);
    String strReqVersion = StringUtils.join(reqVersion);
    if(version.length > reqVersion.length)
    {
        Integer diff = version.length - reqVersion.length;
        strReqVersion += StringUtils.repeat(".0", diff);
    }
    else if(reqVersion.length > version.length)
    {
        Integer diff = reqVersion.length - version.length;
        strVersion += StringUtils.repeat(".0", diff);
    }

    return strReqVersion.compareTo(strVersion) < 0;
}

private static boolean isBetween(String[] version, String[] reqVersion)
{
    return (isEqual(version, reqVersion) || isHigher(version, reqVersion)) &&
            isLess(getNextVersion(version), reqVersion);
}

private static String[] getNextVersion(String[] version)
{
    String[] nextVersion = new String[version.length];
    for(int i = version.length - 1; i >= 0 ; i--)
    {
        if(i == version.length - 1)
        {
            nextVersion[i] = "0";
        }
        else if((i == version.length - 2) && NumberUtils.isNumber(version[i]))
        {
            nextVersion[i] = String.valueOf(NumberUtils.toInt(version[i]) + 1);
        }
        else
        {
            nextVersion[i] = version[i];
        }
    }
    return nextVersion;
}

Answer 26

আমি @ পিটার লরির কাছ থেকে ধারণাটি পছন্দ করেছি এবং আমি এটিকে আরও সীমাতে প্রসারিত করেছি:

    /**
    * Normalize string array, 
    * Appends zeros if string from the array
    * has length smaller than the maxLen.
    **/
    private String normalize(String[] split, int maxLen){
        StringBuilder sb = new StringBuilder("");
        for(String s : split) {
            for(int i = 0; i<maxLen-s.length(); i++) sb.append('0');
            sb.append(s);
        }
        return sb.toString();
    }

    /**
    * Removes trailing zeros of the form '.00.0...00'
    * (and does not remove zeros from, say, '4.1.100')
    **/
    public String removeTrailingZeros(String s){
        int i = s.length()-1;
        int k = s.length()-1;
        while(i >= 0 && (s.charAt(i) == '.' || s.charAt(i) == '0')){
          if(s.charAt(i) == '.') k = i-1;
          i--;  
        } 
        return s.substring(0,k+1);
    }

    /**
    * Compares two versions(works for alphabets too),
    * Returns 1 if v1 > v2, returns 0 if v1 == v2,
    * and returns -1 if v1 < v2.
    **/
    public int compareVersion(String v1, String v2) {

        // Uncomment below two lines if for you, say, 4.1.0 is equal to 4.1
        // v1 = removeTrailingZeros(v1);
        // v2 = removeTrailingZeros(v2);

        String[] splitv1 = v1.split("\\.");
        String[] splitv2 = v2.split("\\.");
        int maxLen = 0;
        for(String str : splitv1) maxLen = Math.max(maxLen, str.length());
        for(String str : splitv2) maxLen = Math.max(maxLen, str.length());
        int cmp = normalize(splitv1, maxLen).compareTo(normalize(splitv2, maxLen));
        return cmp > 0 ? 1 : (cmp < 0 ? -1 : 0);
    }

আশা করি এটি কাউকে সাহায্য করবে। এটি ইন্টারভিউবিট এবং লেটকোডে সমস্ত পরীক্ষার কেস পাস করেছে (তুলনা ভার্সন ফাংশনে দুটি লাইনকে অসুবিধায়িত করতে হবে)।

সহজেই পরীক্ষিত!

Answer 27

public class VersionComparator {

    /* loop through both version strings
     * then loop through the inner string to computer the val of the int
     * for each integer read, do num*10+<integer read>
     * and stop when stumbling upon '.'
     * When '.' is encountered...
     * see if '.' is encountered for both strings
     * if it is then compare num1 and num2 
     * if num1 == num2... iterate over p1++, p2++
     * else return (num1 > num2) ? 1 : -1
     * If both the string end then compare(num1, num2) return 0, 1, -1
     * else loop through the longer string and 
     * verify if it only has trailing zeros
     * If it only has trailing zeros then return 0
     * else it is greater than the other string
     */
    public static int compareVersions(String v1, String v2) {
        int num1 = 0;
        int num2 = 0;
        int p1 = 0;
        int p2 = 0;

        while (p1 < v1.length() && p2 < v2.length()) {
            num1 = Integer.parseInt(v1.charAt(p1) + "");
            num2 = Integer.parseInt(v2.charAt(p2) + "");
            p1++;
            p2++;

            while (p1 < v1.length() && p2 < v2.length() && v1.charAt(p1) != '.' && v2.charAt(p2) != '.') {
                if (p1 < v1.length()) num1 = num1 * 10 + Integer.parseInt(v1.charAt(p1) + "");
                if (p2 < v2.length()) num2 = num2 * 10 + Integer.parseInt(v2.charAt(p2) + "");
                p1++;
                p2++;
            }

            if (p1 < v1.length() && p2 < v2.length() && v1.charAt(p1) == '.' && v2.charAt(p2) == '.') {
                if ((num1 ^ num2) == 0) {
                    p1++;
                    p2++;
                }
                else return (num1 > num2) ? 1 : -1;
            }
            else if (p1 < v1.length() && p2 < v2.length() && v1.charAt(p1) == '.') return -1;
            else if (p1 < v1.length() && p2 < v2.length() && v2.charAt(p2) == '.') return 1;
        }

        if (p1 == v1.length() && p2 == v2.length()) {
            if ((num1 ^ num2) == 0) return 0;
            else return (num1 > num2) ? 1 : -1;
        }
        else if (p1 == v1.length()) {
            if ((num1 ^ num2) == 0) {
                while (p2 < v2.length()) {
                    if (v2.charAt(p2) != '.' && v2.charAt(p2) != '0') return -1;
                    p2++;
                }
                return 0;
            }
            else return (num1 > num2) ? 1 : -1;
        }
        else {
            if ((num1 ^ num2) == 0) {
                while (p1 < v1.length()) {
                    if (v1.charAt(p1) != '.' && v1.charAt(p1) != '0') return 1;
                    p1++;
                }
                return 0;
            }
            else return (num1 > num2) ? 1 : -1;
        }
    }

    public static void main(String[] args) {
        System.out.println(compareVersions("11.23", "11.21.1.0.0.1.0") ^ 1);
        System.out.println(compareVersions("11.21.1.0.0.1.0", "11.23") ^ -1);
        System.out.println(compareVersions("11.23", "11.23.0.0.0.1.0") ^ -1);
        System.out.println(compareVersions("11.2", "11.23") ^ -1);
        System.out.println(compareVersions("11.23", "11.21.1.0.0.1.0") ^ 1);
        System.out.println(compareVersions("1.21.1.0.0.1.0", "2.23") ^ -1);
        System.out.println(compareVersions("11.23", "11.21.1.0.0.1.0") ^ 1);
        System.out.println(compareVersions("11.23.0.0.0.0.0", "11.23") ^ 0);
        System.out.println(compareVersions("11.23", "11.21.1.0.0.1.0") ^ 1);
        System.out.println(compareVersions("1.5.1.3", "1.5.1.3.0") ^ 0);
        System.out.println(compareVersions("1.5.1.4", "1.5.1.3.0") ^ 1);
        System.out.println(compareVersions("1.2.1.3", "1.5.1.3.0") ^ -1);
        System.out.println(compareVersions("1.2.1.3", "1.22.1.3.0") ^ -1);
        System.out.println(compareVersions("1.222.1.3", "1.22.1.3.0") ^ 1);
    }
}

Answer 28

এখানে একটি অনুকূলিত বাস্তবায়ন:

public static final Comparator<CharSequence> VERSION_ORDER = new Comparator<CharSequence>() {

  @Override
  public int compare (CharSequence lhs, CharSequence rhs) {
    int ll = lhs.length(), rl = rhs.length(), lv = 0, rv = 0, li = 0, ri = 0;
    char c;
    do {
      lv = rv = 0;
      while (--ll >= 0) {
        c = lhs.charAt(li++);
        if (c < '0' || c > '9')
          break;
        lv = lv*10 + c - '0';
      }
      while (--rl >= 0) {
        c = rhs.charAt(ri++);
        if (c < '0' || c > '9')
          break;
        rv = rv*10 + c - '0';
      }
    } while (lv == rv && (ll >= 0 || rl >= 0));
    return lv - rv;
  }

};

ফলাফল:

"0.1" - "1.0" = -1
"1.0" - "1.0" = 0
"1.0" - "1.0.0" = 0
"10" - "1.0" = 9
"3.7.6" - "3.7.11" = -5
"foobar" - "1.0" = -1