কোনও স্ট্রিং জাভাতে কোনও পূর্ণসংখ্যার প্রতিনিধিত্ব করে কিনা তা যাচাই করার সর্বোত্তম উপায় কী?

Question

আমি স্ট্রিংকে পূর্ণসংখ্যায় রূপান্তর করতে পারি কিনা তা যাচাই করার জন্য আমি নীচের আইডিয়ামটি সাধারণত ব্যবহার করি।

public boolean isInteger( String input ) {
    try {
        Integer.parseInt( input );
        return true;
    }
    catch( Exception e ) {
        return false;
    }
}

এটা কি শুধু আমি, নাকি এটাকে কিছুটা হ্যাকিশ মনে হচ্ছে? এর চেয়ে ভাল উপায় কী?

---

(Benchmarks উপর ভিত্তি করে আমার উত্তর দেখার আগে উত্তর দ্বারা CodingWithSpike ) দেখার কেন আমি আমার অবস্থান বিপরীত এবং স্বীকার করেছেন জোনাস Klemming এর উত্তর এই সমস্যার। আমি মনে করি যে এই আসল কোডটি বেশিরভাগ লোকেরা ব্যবহার করবেন কারণ এটি কার্যকর করা আরও দ্রুত এবং আরও রক্ষণাবেক্ষণযোগ্য, তবে এটি যখন পূর্ণসংখ্যক ডেটা সরবরাহ করা হয় তখন এর প্রস্থের ধীরতা কম হয়।

Comments

সমাধানের জন্য RegExp সম্পর্কে আপনার ধারণা কী?

— অক্ষয় পেঠানি

Answer 1

আপনি যদি সম্ভাব্য ওভারফ্লো সমস্যার সাথে উদ্বিগ্ন না হন তবে এই ফাংশনটি ব্যবহারের চেয়ে প্রায় 20-30 গুণ দ্রুত সম্পাদন করবে Integer.parseInt()।

public static boolean isInteger(String str) {
    if (str == null) {
        return false;
    }
    int length = str.length();
    if (length == 0) {
        return false;
    }
    int i = 0;
    if (str.charAt(0) == '-') {
        if (length == 1) {
            return false;
        }
        i = 1;
    }
    for (; i < length; i++) {
        char c = str.charAt(i);
        if (c < '0' || c > '9') {
            return false;
        }
    }
    return true;
}

Comments

(সি <= '/' || সি> = ':') দেখতে কিছুটা অদ্ভুত লাগছে। আমি (c <'0' || c> '9') ব্যবহার করতাম ... জাভাতে <= এবং> = অপারেটরগুলি কী দ্রুত?

— বেনামে

কেন রিজেক্স ব্যবহার করবেন না? Str.matches ("^ -? \\ d + $") উপরের কোডের মতো নয় কী?

— ম্যাগলব

আমি এই পদ্ধতি বা মূল পদ্ধতিটি ব্যবহার করবো রেজেক্সের আগে প্রশ্ন থেকে। পারফরম্যান্সের জন্য এটি বাস্তবায়নের গতি এবং নিছক রক্ষণাবেক্ষণের জন্য আসল পদ্ধতি। রেজেক্স সমাধানটির জন্য কিছুই যাচ্ছে না।

— বিল

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

— বিল

যদি আপনি উদ্বিগ্ন থাকেন যে আপনি স্ট্রিংটিকে আসলে কোনও দীর্ঘ বা দীর্ঘায়িত করতে পারেন কিনা আপনারও এটি পরীক্ষা করে দেখতে হবে যে পূর্ণসংখ্যাটি স্ট্রিংয়ের প্রতিনিধিত্ব করে those ডেটা টাইপের সাথে খাপ খায় কিনা।

— জোনাস কে

Answer 2

আপনার কাছে এটি আছে তবে আপনার কেবল ধরা উচিত NumberFormatException।

Comments

হ্যাঁ, আপনার প্রয়োজনের চেয়ে বেশি ব্যতিক্রম ধরা এটি খারাপ ফর্ম হিসাবে বিবেচিত।

— ক্রিস

তুমি ঠিক বলছো. এনএফই হ'ল একমাত্র এটিই ফেলে দেওয়া যেতে পারে তবে এটি toোকা এখনও খারাপ অভ্যাস।

— বিল

আমি মনে করি যদি ইনপুটটি শূন্য থাকে তবে একটি এনপিই নিক্ষেপ করা যেতে পারে, সুতরাং আপনার পদ্ধতিটি সম্ভবত আপনি যেভাবেই চান তা স্পষ্টভাবে পরিচালনা করতে হবে।

— ডভ ওয়াসারম্যান

@ ডভ: আপনি ঠিক বলেছেন এনপিই এবং এনএফই দু'জনকেই স্পষ্টভাবে ধরা উচিত।

— বিল

এই প্রতিক্রিয়াটি এই প্রশ্নের সঠিক উত্তর হওয়া উচিত।

— শুক্রবার

Answer 3

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

 public void RunTests()
 {
     String str = "1234567890";

     long startTime = System.currentTimeMillis();
     for(int i = 0; i < 100000; i++)
         IsInt_ByException(str);
     long endTime = System.currentTimeMillis();
     System.out.print("ByException: ");
     System.out.println(endTime - startTime);

     startTime = System.currentTimeMillis();
     for(int i = 0; i < 100000; i++)
         IsInt_ByRegex(str);
     endTime = System.currentTimeMillis();
     System.out.print("ByRegex: ");
     System.out.println(endTime - startTime);

     startTime = System.currentTimeMillis();
     for(int i = 0; i < 100000; i++)
         IsInt_ByJonas(str);
     endTime = System.currentTimeMillis();
     System.out.print("ByJonas: ");
     System.out.println(endTime - startTime);
 }

 private boolean IsInt_ByException(String str)
 {
     try
     {
         Integer.parseInt(str);
         return true;
     }
     catch(NumberFormatException nfe)
     {
         return false;
     }
 }

 private boolean IsInt_ByRegex(String str)
 {
     return str.matches("^-?\\d+$");
 }

 public boolean IsInt_ByJonas(String str)
 {
     if (str == null) {
             return false;
     }
     int length = str.length();
     if (length == 0) {
             return false;
     }
     int i = 0;
     if (str.charAt(0) == '-') {
             if (length == 1) {
                     return false;
             }
             i = 1;
     }
     for (; i < length; i++) {
             char c = str.charAt(i);
             if (c <= '/' || c >= ':') {
                     return false;
             }
     }
     return true;
 }

আউটপুট:

বাই এক্সেক্সেশন: 31

বাইরেজেক্স: 453 (নোট: প্রতিবার প্যাটার্নটি পুনরায় সংকলন)

বাই জোনাস: 16

আমি একমত যে জোনাস কে এর সমাধানটিও সবচেয়ে শক্ত। দেখে মনে হচ্ছে সে জিতছে :)

Comments

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

— বিল

দুঃখিত তবে এই রেজেক্স পরীক্ষাটি ভাল নয়। (1) আপনার জন্য Regex ইঞ্জিন চেক করতে প্রয়োজন হবে না ^এবং $এ থেকে দ্বিতীয় সময় matchesসমগ্র স্ট্রিং Regex মেলানো, (2) str.matchesপ্রতিটি সময় তার নিজস্ব তৈরি করতে হবে Patternযা ব্যয়বহুল। পারফরম্যান্সের কারণে আমাদের এই পদ্ধতির বাইরে এই প্যাটার্নটি তৈরি করা উচিত এবং এটি ভিতরে ব্যবহার করা উচিত। (3) আমরা কেবল একটি ম্যাচার অবজেক্ট তৈরি করতে পারি এবং এটি ব্যবহার করে reset(CharSequence)ব্যবহারকারীর ডেটা পাস করতে এবং তার matches()ফলাফলটি ফিরিয়ে দিতে পারি ।

— প্লেমো

সুতরাং ভালো কিছু private final Matcher m = Pattern.compile("-?\\d+").matcher(""); private boolean byRegex(String str) { return m.reset(str).matches(); }ভাল পারফরম্যান্স করা উচিত।

— Pshemo

@ শেমো ইন্টিজার.ভেলুওফ ("1") এবং ইন্টিজার.ভ্যালুওফ ("1") উভয়ই ব্যতিক্রম ছুঁড়ে ফেলেছে তাই ^ এবং for জন্য পরীক্ষা করা যুক্তিসঙ্গত বলে মনে হচ্ছে।

— cquezel

@ ককুয়েজেল হ্যাঁ, তবে যেহেতু এটি যুক্ত করা এবং অন্তর্নিহিতভাবে আবশ্যক তা প্রয়োজন হয় না । ফলে একবার দেখে নিন এবং । আপনি দেখতে পাবেন এবং । ফিরে আসবে কারণ স্ট্রিংটি স্পেস দিয়ে শুরু হয় যা এটি পুরোপুরি রেগেক্সের সাথে মিলে যাওয়া থেকে বাধা দেয়। matches^$" 123".matches("\\d+")"123".matches("\\d+")falsetruefalse

— প্লেমো

Answer 4

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

বিল দ্য টিকটিকি থেকে অনুলিপি করা হয়েছে এবং সংকলিত সংস্করণ সহ আপডেট হয়েছে:

private final Pattern pattern = Pattern.compile("^-?\\d+$");

public void runTests() {
    String big_int = "1234567890";
    String non_int = "1234XY7890";

    long startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByException(big_int);
    long endTime = System.currentTimeMillis();
    System.out.print("ByException - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByException(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByException - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByRegex(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByRegex - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByRegex(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByRegex - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++)
            IsInt_ByCompiledRegex(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByCompiledRegex - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++)
            IsInt_ByCompiledRegex(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByCompiledRegex - non-integer data: ");
    System.out.println(endTime - startTime);


    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByJonas(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByJonas - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByJonas(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByJonas - non-integer data: ");
    System.out.println(endTime - startTime);
}

private boolean IsInt_ByException(String str)
{
    try
    {
        Integer.parseInt(str);
        return true;
    }
    catch(NumberFormatException nfe)
    {
        return false;
    }
}

private boolean IsInt_ByRegex(String str)
{
    return str.matches("^-?\\d+$");
}

private boolean IsInt_ByCompiledRegex(String str) {
    return pattern.matcher(str).find();
}

public boolean IsInt_ByJonas(String str)
{
    if (str == null) {
            return false;
    }
    int length = str.length();
    if (length == 0) {
            return false;
    }
    int i = 0;
    if (str.charAt(0) == '-') {
            if (length == 1) {
                    return false;
            }
            i = 1;
    }
    for (; i < length; i++) {
            char c = str.charAt(i);
            if (c <= '/' || c >= ':') {
                    return false;
            }
    }
    return true;
}

ফলাফল:

ByException - integer data: 45
ByException - non-integer data: 465

ByRegex - integer data: 272
ByRegex - non-integer data: 131

ByCompiledRegex - integer data: 45
ByCompiledRegex - non-integer data: 26

ByJonas - integer data: 8
ByJonas - non-integer data: 2

Comments

বাইকম্পাইলড রেজেক্স সময়কে তার সময় পরিমাপে রেগেক্স সংকলন অন্তর্ভুক্ত করতে হবে।

— মার্টিন কার্নে

@ মার্টিনকার্নি আমি এটিকে সংশোধন করেছি এবং প্যাটার্ন সংকলনটি বেঞ্চমার্ক করেছি। একথাও ঠিক যে আমার CPU- র / জে আই টি JIT দ্রুততর, কিন্তু যদি আমি এটা ফেরত ঢুকান, সংকলন সময় 336।

— টেডার 42

পরিষ্কার হতে হবে যে, 336 (এমএস) হ'ল প্যাটার্ন সংকলনটি যখন অন্যান্য সমস্ত লাইনের মতো 100k বার করা হয় তখনই ঘটে। এটি কেবল একবার সম্পন্ন হয়ে যাওয়ার সাথে, এর সময়টি মূলত শূন্য।

— tedder42

সংকলিত রেজেক্স বারে রেকর্ডটি সোজা করার জন্য ধন্যবাদ।

— LarsH

হয়তো "^[+-]?\\d+$"আরও ভাল হবে।

— অ্যাডাম

Answer 5

org.apache.commons.lang.StringUtils.isNumeric 

যদিও জাভার স্ট্যান্ডার্ড লাইব সত্যই এই জাতীয় ইউটিলিটি ফাংশনগুলি মিস করে

আমি মনে করি যে প্রতিটি জাভা প্রোগ্রামারের জন্য অ্যাপাচি কমন্স একটি "আবশ্যক"

খুব খারাপ এটি জাভা 5 এ পোর্ট করা হয়নি

Comments

— এটির

অন্য সমস্যাটি নেতিবাচক সংখ্যা, তবে আমিও +1 করি, যেহেতু আমার দৃষ্টিতে এই পদ্ধতিটি একটি ভাল সমাধানের নিকটে আসে comes

— Sandris

Answer 6

এটি "পূর্ণসংখ্যায় রূপান্তরিত হতে পারে" দ্বারা আপনি কী বোঝাতে চান তার উপর এটি আংশিকভাবে নির্ভর করে।

যদি আপনার অর্থ "জাভাতে কোনও ইন্টে রূপান্তর করা যায়" তবে জোনাসের উত্তরটি একটি ভাল শুরু, তবে কাজটি পুরোপুরি শেষ করে না। এটি উদাহরণস্বরূপ 99999999999999999999999999999999 পাস করবে। আমি পদ্ধতিটির শেষে আপনার নিজের প্রশ্ন থেকে স্বাভাবিক চেষ্টা / ধরার কলটি যুক্ত করব।

চরিত্র অনুসারে চরিত্রের চেকগুলি দক্ষতার সাথে "একেবারে পূর্ণসংখ্যক নয়" ক্ষেত্রে অস্বীকার করবে, "এটি একটি পূর্ণসংখ্যার তবে জাভা এটি পরিচালনা করতে পারে না" ধীর ব্যতিক্রমের পথে ধরা পড়ে। আপনি হাত দ্বারা এই বিট করতে পারেন, তবে এটি অনেক বেশি জটিল হবে।

Answer 7

রিজেপেক্স সম্পর্কে কেবল একটি মন্তব্য। এখানে প্রদত্ত প্রতিটি উদাহরণ ভুল! আপনি যদি রেজিএক্সপ ব্যবহার করতে চান তবে ভুলে যাবেন না যে প্যাটার্নটি সংকলন করতে অনেক সময় লাগে। এই:

str.matches("^-?\\d+$")

এবং এটিও:

Pattern.matches("-?\\d+", input);

প্রতিটি পদ্ধতি কলে প্যাটার্ন সংকলন ঘটায়। এটি সঠিকভাবে ব্যবহার করতে অনুসরণ করুন:

import java.util.regex.Pattern;

/**
 * @author Rastislav Komara
 */
public class NaturalNumberChecker {
    public static final Pattern PATTERN = Pattern.compile("^\\d+$");

    boolean isNaturalNumber(CharSequence input) {
        return input != null && PATTERN.matcher(input).matches();
    }
}

Comments

আপনি সময়ের আগে ম্যাচার তৈরি করে এবং ইনপুটটিতে এটি প্রয়োগ করার জন্য এর পুনরায় সেট () পদ্ধতিটি ব্যবহার করে কিছুটা আরও কার্য সম্পাদন করতে পারেন।

— অ্যালান মুর

Answer 8

পেয়ারা সংস্করণ রয়েছে:

import com.google.common.primitives.Ints;

Integer intValue = Ints.tryParse(stringValue);

এটি স্ট্রিংকে বিশ্লেষণ করতে ব্যর্থ হলে এটি ব্যতিক্রম ছুঁড়ে ফেলার পরিবর্তে নালায় ফিরে আসবে।

Comments

সেরা উত্তর আইএমএইচও। নিজের সমাধান সমাধানের পরিবর্তে ভাল পরীক্ষিত গ্রন্থাগারগুলি ব্যবহার করুন। (এছাড়াও আলোচনা দেখুন এখানে ।)

— অলিভিয়ের Cailloux

Answer 9

আমি র‌্যালি 25 টির উত্তর থেকে কোডটি অনুলিপি করেছি এবং অ-পূর্ণসংখ্যক ডেটার জন্য কিছু পরীক্ষা যুক্ত করেছি। ফলাফলগুলি অনস্বীকার্যভাবে জোনাস ক্লেমিংয়ের পোস্ট করা পদ্ধতির পক্ষে। আমি প্রাথমিকভাবে পোস্ট করা ব্যতিক্রম পদ্ধতির ফলাফলগুলি যখন আপনার পূর্ণসংখ্যার ডেটা থাকে তখন বেশ ভাল হয় তবে আপনি যখন না করেন তখন সেগুলি সবচেয়ে খারাপ হয়, যখন রেজেক্স সমাধানের ফলাফল হয় (যে আমি প্রচুর লোক ব্যবহার করব) ছিল ধারাবাহিকভাবে খারাপ। সংকলিত রেজেক্স উদাহরণের জন্য ফিলিপের উত্তর দেখুন , যা অনেক দ্রুত।

public void runTests()
{
    String big_int = "1234567890";
    String non_int = "1234XY7890";

    long startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByException(big_int);
    long endTime = System.currentTimeMillis();
    System.out.print("ByException - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByException(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByException - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByRegex(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByRegex - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByRegex(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByRegex - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByJonas(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByJonas - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByJonas(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByJonas - non-integer data: ");
    System.out.println(endTime - startTime);
}

private boolean IsInt_ByException(String str)
{
    try
    {
        Integer.parseInt(str);
        return true;
    }
    catch(NumberFormatException nfe)
    {
        return false;
    }
}

private boolean IsInt_ByRegex(String str)
{
    return str.matches("^-?\\d+$");
}

public boolean IsInt_ByJonas(String str)
{
    if (str == null) {
            return false;
    }
    int length = str.length();
    if (length == 0) {
            return false;
    }
    int i = 0;
    if (str.charAt(0) == '-') {
            if (length == 1) {
                    return false;
            }
            i = 1;
    }
    for (; i < length; i++) {
            char c = str.charAt(i);
            if (c <= '/' || c >= ':') {
                    return false;
            }
    }
    return true;
}

ফলাফল:

ByException - integer data: 47
ByException - non-integer data: 547

ByRegex - integer data: 390
ByRegex - non-integer data: 313

ByJonas - integer data: 0
ByJonas - non-integer data: 16

Answer 10

এটি সংক্ষিপ্ত, তবে সংক্ষিপ্ততর অগত্যা আরও ভাল নয় (এবং এটি ড্যানেটেলের মন্তব্যে নির্দেশিত অনুসারে পরিসংখ্যানের বাইরে পূর্ণসংখ্যার মানগুলি ধরবে না ):

input.matches("^-?\\d+$");

ব্যক্তিগতভাবে, যেহেতু বাস্তবায়নটি কোনও সহায়ক পদ্ধতিতে সঠিকভাবে কাঠবিড়ালি করা হয়েছে এবং সঠিকতা ট্রাম্পের দৈর্ঘ্যের কারণে আমি আপনার কাছে যা কিছু আছে তার সাথে কিছুটা যেতে চাই (বেস ব্যাসটি ধরার Exceptionপরিবর্তে বিয়োগফল NumberFormatException)।

Comments

এবং জাভা ইন্টিজারগুলি ধরার জন্য \\ d {1,10, নিখুঁত না হলেও, \\ d + এর চেয়ে ভাল

— ম্যাগলব

Answer 11

আপনি স্ট্রিং ক্লাসের মিলগুলির পদ্ধতিটি ব্যবহার করতে পারেন। [0-9] এটি হতে পারে এমন সমস্ত মান উপস্থাপন করে, + এর অর্থ এটি কমপক্ষে একটি অক্ষর দীর্ঘ হতে হবে, এবং * এর অর্থ এটি শূন্য বা আরও বেশি অক্ষর দীর্ঘ হতে পারে।

boolean isNumeric = yourString.matches("[0-9]+"); // 1 or more characters long, numbers only
boolean isNumeric = yourString.matches("[0-9]*"); // 0 or more characters long, numbers only

Comments

এনবি এটি "+10" বা "-10") এর সাথে মেলে না, যা সাধারণত বৈধ পূর্ণসংখ্যা হিসাবে অন্তর্ভুক্ত হবে

— টিম উইন্টল

Answer 12

কেমন:

return Pattern.matches("-?\\d+", input);

Comments

পূর্ণসংখ্যা সম্পর্কে কি হবে 999999999999999999999999999999999999?

— ড্যানটেল

নেতিবাচক চিহ্নের জন্য পরীক্ষা করতে ভুলবেন না।

— জেরেমি রুটেন

আপনার কি রেগেক্সের শুরু এবং শেষ অংশটি নোঙ্গর করার দরকার নেই, তাই আপনি "আআ -৯৯৯৩z" পাস করবেন না?

— টিম হাওল্যান্ড 13

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

— অ্যালান মুর

Answer 13

এটি জোনাস ক্লেমিং উত্তরটির একটি জাভা 8 প্রকরণ:

public static boolean isInteger(String str) {
    return str != null && str.length() > 0 &&
         IntStream.range(0, str.length()).allMatch(i -> i == 0 && (str.charAt(i) == '-' || str.charAt(i) == '+')
                  || Character.isDigit(str.charAt(i)));
}

পরীক্ষার কোড:

public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {
    Arrays.asList("1231231", "-1232312312", "[phone]", "qwqe123123211", "2", "0000000001111", "", "123-", "++123",
            "123-23", null, "+-123").forEach(s -> {
        System.out.printf("%15s %s%n", s, isInteger(s));
    });
}

পরীক্ষার কোডের ফলাফল:

        1231231 true
    -1232312312 true
   [phone] true
  qwqe123123211 false
              2 true
  0000000001111 true
                false
           123- false
          ++123 false
         123-23 false
           null false
          +-123 false

Answer 14

আপনি কেবল নাম্বার ফর্ম্যাট এক্সেকশন চেক করুন : -

 String value="123";
 try  
 {  
    int s=Integer.parseInt(any_int_val);
    // do something when integer values comes 
 }  
 catch(NumberFormatException nfe)  
 {  
          // do something when string values comes 
 }  

Answer 15

যদি আপনার স্ট্রিং অ্যারেতে খাঁটি পূর্ণসংখ্যা এবং স্ট্রিং থাকে তবে নীচের কোডটিতে কাজ করা উচিত। আপনাকে কেবল প্রথম চরিত্রটি দেখতে হবে। উদাহরণস্বরূপ ["4", "44", "এবিসি", "77", "বন্ড"]

if (Character.isDigit(string.charAt(0))) {
    //Do something with int
}

Answer 16

আপনি স্ক্যানার ক্লাসটিও ব্যবহার করতে পারেন, এবং হ্যান্সেক্সটেন্ট () ব্যবহার করতে পারেন - এবং এটি আপনাকে অন্যান্য ধরণের জন্যও যেমন ভাসমান ইত্যাদি পরীক্ষা করতে দেয় allows

Comments

এই উত্তরটি আমার প্রয়োজনীয় একটি অনুস্মারক দিয়েছে। আমি সম্পূর্ণরূপে ভুলে গেছি স্ক্যানার যেমন একটি ফাংশন ছিল। টি-আপ

— হুব্রো

Answer 17

যদি আপনি যাচাই করতে চান যে স্ট্রিংটি কোনও পূর্ণসংখ্যার টাইপ অনুসারে পূর্ণসংখ্যার প্রতিনিধিত্ব করে কিনা, আমি জোনাসের জবাবটিতে কিছুটা পরিবর্তন করেছি, যাতে পূর্ণসংখ্যার প্রতিনিধিত্বকারী স্ট্রিংগুলি। এমএক্স_ভ্যালু বা পূর্ণসংখ্যার চেয়ে বড় আকারের। MIN_VALUE এখন ফিরে আসবে will মিথ্যা। উদাহরণস্বরূপ: "3147483647" মিথ্যা প্রত্যাবর্তন করবে কারণ 3147483647 2147483647 এর চেয়ে বড়, এবং তেমনিভাবে "-2147483649" মিথ্যাও ফিরিয়ে দেবে কারণ -2147483649 -2147483648 এর চেয়ে ছোট is

public static boolean isInt(String s) {
  if(s == null) {
    return false;
  }
  s = s.trim(); //Don't get tricked by whitespaces.
  int len = s.length();
  if(len == 0) {
    return false;
  }
  //The bottom limit of an int is -2147483648 which is 11 chars long.
  //[note that the upper limit (2147483647) is only 10 chars long]
  //Thus any string with more than 11 chars, even if represents a valid integer, 
  //it won't fit in an int.
  if(len > 11) {
    return false;
  }
  char c = s.charAt(0);
  int i = 0;
  //I don't mind the plus sign, so "+13" will return true.
  if(c == '-' || c == '+') {
    //A single "+" or "-" is not a valid integer.
    if(len == 1) {
      return false;
    }
    i = 1;
  }
  //Check if all chars are digits
  for(; i < len; i++) {
    c = s.charAt(i);
    if(c < '0' || c > '9') {
      return false;
    }
  }
  //If we reached this point then we know for sure that the string has at
  //most 11 chars and that they're all digits (the first one might be a '+'
  // or '-' thought).
  //Now we just need to check, for 10 and 11 chars long strings, if the numbers
  //represented by the them don't surpass the limits.
  c = s.charAt(0);
  char l;
  String limit;
  if(len == 10 && c != '-' && c != '+') {
    limit = "2147483647";
    //Now we are going to compare each char of the string with the char in
    //the limit string that has the same index, so if the string is "ABC" and
    //the limit string is "DEF" then we are gonna compare A to D, B to E and so on.
    //c is the current string's char and l is the corresponding limit's char
    //Note that the loop only continues if c == l. Now imagine that our string
    //is "2150000000", 2 == 2 (next), 1 == 1 (next), 5 > 4 as you can see,
    //because 5 > 4 we can guarantee that the string will represent a bigger integer.
    //Similarly, if our string was "2139999999", when we find out that 3 < 4,
    //we can also guarantee that the integer represented will fit in an int.
    for(i = 0; i < len; i++) {
      c = s.charAt(i);
      l = limit.charAt(i);
      if(c > l) {
        return false;
      }
      if(c < l) {
        return true;
      }
    }
  }
  c = s.charAt(0);
  if(len == 11) {
    //If the first char is neither '+' nor '-' then 11 digits represent a 
    //bigger integer than 2147483647 (10 digits).
    if(c != '+' && c != '-') {
      return false;
    }
    limit = (c == '-') ? "-2147483648" : "[phone]";
    //Here we're applying the same logic that we applied in the previous case
    //ignoring the first char.
    for(i = 1; i < len; i++) {
      c = s.charAt(i);
      l = limit.charAt(i);
      if(c > l) {
        return false;
      }
      if(c < l) {
        return true;
      }
    }
  }
  //The string passed all tests, so it must represent a number that fits
  //in an int...
  return true;
}

Comments

আপনি কি দয়া করে আপনার উত্তরটি সম্পাদনা করতে পারেন এবং ব্যাখ্যা করতে পারেন কীভাবে এটি আপনার উল্লিখিত পূর্ববর্তী উত্তরের উন্নতি করে?

— গিলস গাউয়েলার্ডেট

দুর্দান্ত উত্তরের জন্য ধন্যবাদ। তবে "123" অর্থাৎ 123 স্থানের সাথে বৈধ পূর্ণসংখ্যা হিসাবে বিবেচিত হবে।

— সৈকৃষ্ণ রাধারাপু

সাইকৃষ্ণরদারাপু তারা এগুলি ব্যবহার করে trim()যাতে এটি স্পষ্টভাবে ইচ্ছাকৃত ডিজাইনের পছন্দ।

— গিলডেনস্টন

Answer 18

আপনি অ্যাপাচি ব্যবহারের চেষ্টা করতে পারেন

NumberUtils.isCreatable(myText)

জাভাডোকটি এখানে দেখুন

Comments

দেখে মনে হয় যে এই পদ্ধতিটি সর্বশেষতম প্রকাশের লিঙ্কে অবচয় করা হয়েছে )। স্পষ্টতই এর isCreateable(String)পরিবর্তে আপনার ব্যবহার করা উচিত ।

— গিলডেনস্টন

আপডেট করা হয়েছে। ধন্যবাদ @ গিল্ডেনস্টেন

— বরজব

Answer 19

আপনার ব্যবহারের ক্ষেত্রে সম্ভবত অ্যাকাউন্টটি নেওয়া দরকার:

যদি আপনি বেশিরভাগ সময় সংখ্যাগুলি বৈধ হওয়ার প্রত্যাশা করেন, তবে ব্যতিক্রমটি ধরা কেবলমাত্র অবৈধ সংখ্যাগুলিতে রূপান্তর করার চেষ্টা করার সময় ওভারহেডের কার্যকারিতা তৈরি করে। যেখানে কিছু কলিং isInteger()পদ্ধতি এবং তারপর ব্যবহার রূপান্তর Integer.parseInt()হবে সবসময় স্ট্রিং দুবার পার্স করা হয় একবার চেকের মাধ্যমে এবং রূপান্তর একবার - বৈধ সংখ্যার জন্য একটি কার্যকারিতা ওভারহেড কারণ।

Answer 20

এটি জোনাসের কোডের একটি সংশোধন যা স্ট্রিংটি একটি পূর্ণসংখ্যার মধ্যে কাস্ট করার জন্য সীমার মধ্যে রয়েছে কিনা তা পরীক্ষা করে।

public static boolean isInteger(String str) {
    if (str == null) {
        return false;
    }
    int length = str.length();
    int i = 0;

    // set the length and value for highest positive int or lowest negative int
    int maxlength = 10;
    String maxnum = String.valueOf(Integer.MAX_VALUE);
    if (str.charAt(0) == '-') { 
        maxlength = 11;
        i = 1;
        maxnum = String.valueOf(Integer.MIN_VALUE);
    }  

    // verify digit length does not exceed int range
    if (length > maxlength) { 
        return false; 
    }

    // verify that all characters are numbers
    if (maxlength == 11 && length == 1) {
        return false;
    }
    for (int num = i; num < length; num++) {
        char c = str.charAt(num);
        if (c < '0' || c > '9') {
            return false;
        }
    }

    // verify that number value is within int range
    if (length == maxlength) {
        for (; i < length; i++) {
            if (str.charAt(i) < maxnum.charAt(i)) {
                return true;
            }
            else if (str.charAt(i) > maxnum.charAt(i)) {
                return false;
            }
        }
    }
    return true;
}

Comments

দেখতে দেখতে দুর্দান্ত, তবে শেষের জন্য লুপটি আমার শূন্যে পুনরায় সেট করতে হবে (বা 1 যদি negativeণাত্মক সংখ্যা হয়) কারণ লুপ যা প্রতিটি অঙ্কের একটি সংখ্যা কিনা তা পরীক্ষা করে লুপটির ফলে আমি স্ট্রিং দৈর্ঘ্য হয়ে যাব, অতএব শেষ লুপটির জন্য কখনও চালানো হবে না। আমি যাদু সংখ্যার পরিবর্তে জাভা কনস্ট্যান্টগুলি পূর্ণসংখ্যার জন্য ব্যবহার করব MA MAX_VALUE এবং পূর্ণসংখ্যা M MIN_VALUE।

— টিম দ্য এনচ্যান্টার

@ টিমথেনচ্যান্টার পরামর্শগুলির জন্য আপনাকে ধন্যবাদ, আমি সেগুলি সম্পূর্ণ উপেক্ষা করেছি। এগুলিকে অন্তর্ভুক্ত করার জন্য আমার সম্পাদনায় আমি প্রথমে লুপের জন্য একটি নতুন ভেরিয়েবল ব্যবহার করেছি যদি বিবৃতিটি অতিরিক্ত হয় তা এড়াতে।

— ওয়েইন

Answer 21

আপনি যদি অ্যান্ড্রয়েড এপিআই ব্যবহার করেন তবে আপনি এটি ব্যবহার করতে পারেন:

TextUtils.isDigitsOnly(str);

Answer 22

অন্য বিকল্প:

private boolean isNumber(String s) {
    boolean isNumber = true;
    for (char c : s.toCharArray()) {
        isNumber = isNumber && Character.isDigit(c);
    }
    return isNumber;
}

Answer 23

is_number = true;
try {
  Integer.parseInt(mystr)
} catch (NumberFormatException  e) {
  is_number = false;
}

Comments

এটি পোস্টারটি জিজ্ঞাসা করছে ঠিক একই জিনিস করছে।

— মার্টিন কার্নে

Answer 24

আপনি কি কাজ করেছেন তবে আপনার সম্ভবত সর্বদা সেভাবে চেক করা উচিত নয়। নিক্ষেপ ব্যতিক্রমগুলি "ব্যতিক্রমী" পরিস্থিতিতে (সম্ভবত এটি আপনার ক্ষেত্রে ফিট করে), এবং পারফরম্যান্সের ক্ষেত্রে অত্যন্ত ব্যয়বহুল for

Comments

যদি তারা ফেলে দেওয়া হয় তবে সেগুলি ব্যয়বহুল।

— বিল

Answer 25

Number number;
try {
    number = NumberFormat.getInstance().parse("123");
} catch (ParseException e) {
    //not a number - do recovery.
    e.printStackTrace();
}
//use number

Answer 26

এটি কেবল ইতিবাচক পূর্ণসংখ্যার জন্য কাজ করবে।

public static boolean isInt(String str) {
    if (str != null && str.length() != 0) {
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) return false;
        }
    }
    return true;        
}

Comments

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

— লেইহ

Answer 27

এটি আমার পক্ষে কাজ করে। কেবল একটি স্ট্রিং আদিম বা সংখ্যা কিনা তা সনাক্ত করার জন্য।

private boolean isPrimitive(String value){
        boolean status=true;
        if(value.length()<1)
            return false;
        for(int i = 0;i<value.length();i++){
            char c=value.charAt(i);
            if(Character.isDigit(c) || c=='.'){

            }else{
                status=false;
                break;
            }
        }
        return status;
    }

Answer 28

সমস্ত অন্তর্ বর্ণের জন্য পরীক্ষা করতে, আপনি কেবল একটি ডাবল নেতিবাচক ব্যবহার করতে পারেন।

যদি (! সার্চ স্ট্রিং.ম্যাচস ("[^ 0-9] + $")) ...

[^ 0-9] + inte এমন কোনও অক্ষর রয়েছে যা পূর্ণসংখ্য নয় কিনা তা যাচাই করে, তাই পরীক্ষাটি যদি এটি সত্য হয় তবে ব্যর্থ হয়। ঠিক তা নয় এবং আপনি সাফল্যে সত্য হন।

Comments

না, আপনি পরিষ্কারভাবে এটি পরীক্ষা করেন নি। স্ট্রিংয়ের কোথাও কোনও অঙ্ক থাকলে তা কেবল সত্যটি প্রত্যাবর্তন করে, স্ট্রিংটি কেবলমাত্র অংক নয়। matchesপদ্ধতি সমগ্র স্ট্রিং, এটি শুধু একটি অংশ বিরুদ্ধে মেলে।

— দাউদ ইবনে করিম

আপনি দ্বিগুণ নেতিবাচক অংশ পাবেন না।

— রজার এফ। গে

ভাল, আমি ডাবল নেতিবাচক পেতে পারি না। এটি কেবল কাজ করে না। আপনার যদি অঙ্ক এবং বর্ণগুলির মিশ্রণ থাকে তবে এটি ifব্লকে যায় । এটা করা উচিত নয়।

— দাউদ ইবনে কেরেম

Answer 29

এটি সহায়ক হতে পারে:

public static boolean isInteger(String self) {
    try {
        Integer.valueOf(self.trim());
        return true;
    } catch (NumberFormatException nfe) {
        return false;
    }
}

Answer 30

আমি বিশ্বাস করি যে ব্যতিক্রম শূন্যের ঝুঁকি রয়েছে, কারণ নীচে আপনি সর্বদা নিরাপদে পার্স intকরতে পারেন Stringএবং অন্য উপায়ে নয়।

তাই:

1. আপনার স্ট্রিংয়ের প্রতিটি অক্ষরের অক্ষর কমপক্ষে একটির সাথে মিলছে কিনা তা আপনি পরীক্ষা করে দেখুন {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"} ।

   if(aString.substring(j, j+1).equals(String.valueOf(i)))

2. আপনি যোগফল সব সময় যে আপনার স্লট উপরে অক্ষর সম্মুখীন হয়েছে।

   digits++;

3. এবং পরিশেষে আপনি পরীক্ষা করে দেখেন যে আপনি যখন অক্ষর হিসাবে পূর্ণসংখ্যার মুখোমুখি হয়েছিলেন তা প্রদত্ত স্ট্রিংয়ের দৈর্ঘ্যের সমান হয়।

   if(digits == aString.length())

এবং বাস্তবে আমাদের রয়েছে:

    String aString = "1234224245";
    int digits = 0;//count how many digits you encountered
    for(int j=0;j<aString.length();j++){
        for(int i=0;i<=9;i++){
            if(aString.substring(j, j+1).equals(String.valueOf(i)))
                    digits++;
        }
    }
    if(digits == aString.length()){
        System.out.println("It's an integer!!");
        }
    else{
        System.out.println("It's not an integer!!");
    }
    
    String anotherString = "1234f22a4245";
    int anotherDigits = 0;//count how many digits you encountered
    for(int j=0;j<anotherString.length();j++){
        for(int i=0;i<=9;i++){
            if(anotherString.substring(j, j+1).equals(String.valueOf(i)))
                    anotherDigits++;
        }
    }
    if(anotherDigits == anotherString.length()){
        System.out.println("It's an integer!!");
        }
    else{
        System.out.println("It's not an integer!!");
    }

এবং ফলাফলগুলি হ'ল:

এটি একটি পূর্ণসংখ্যা !!

এটি কোনও পূর্ণসংখ্যা নয় !!

একইভাবে, আপনি যদি একটি যাচাই করতে পারেন Stringএকটি হল floatবা doubleকিন্তু যারা ক্ষেত্রে আপনি সম্মুখীন আছে কেবল এক। (ডট) স্ট্রিংয়ে এবং অবশ্যই কিনা তা পরীক্ষা করে দেখুন digits == (aString.length()-1)

আবার এখানে শূন্যতার ঝুঁকির বিশ্লেষণ ব্যতিক্রম এখানে চলেছে, তবে আপনি যদি কোনও স্ট্রিং পার্সিংয়ের পরিকল্পনা করেন তবে এটি একটি সংখ্যা রয়েছে বলে জানা যায় (আসুন ইনট ডেটা টাইপ বলি ) আপনাকে অবশ্যই এটি পরীক্ষা করা উচিত যে এটি ডেটা টাইপের সাথে খাপ খায়? অন্যথায় আপনি এটি নিক্ষেপ করা আবশ্যক।

আমি আশা করি আমি সাহায্য করেছি