स्कैनर अगले () या अगलेफू () का उपयोग करने के बाद अगली लाइन को छोड़ रहा है?

Question

मैं Scannerतरीकों का उपयोग कर रहा हूं nextInt()और nextLine()इनपुट पढ़ने के लिए।

यह इस तरह दिख रहा है:

System.out.println("Enter numerical value");    
int option;
option = input.nextInt(); // Read numerical value from input
System.out.println("Enter 1st string"); 
String string1 = input.nextLine(); // Read 1st string (this is skipped)
System.out.println("Enter 2nd string");
String string2 = input.nextLine(); // Read 2nd string (this appears right after reading numerical value)

समस्या यह है कि संख्यात्मक मान दर्ज करने के बाद, पहला input.nextLine()छोड़ दिया जाता है और दूसरे input.nextLine()को निष्पादित किया जाता है, ताकि मेरा आउटपुट इस तरह दिखे:

Enter numerical value
3   // This is my input
Enter 1st string    // The program is supposed to stop here and wait for my input, but is skipped
Enter 2nd string    // ...and this line is executed and waits for my input

मैंने अपने आवेदन का परीक्षण किया और ऐसा लगता है कि समस्या का उपयोग करने में समस्या है input.nextInt()। अगर मैं इसे हटा, तो दोनों string1 = input.nextLine()और string2 = input.nextLine()मार डाला के रूप में मैं उन्हें रखना चाहते हैं कर रहे हैं।

Comments

या आप मेरी तरह हो सकते हैं और बफ़रडेयर का उपयोग कर सकते हैं :) मुझे परवाह नहीं है कि यह पुराना स्कूल है, इसने हमेशा काम किया है और हमेशा मेरे लिए काम करेगा। इसके अलावा, बफ़रड्रेडर के ज्ञान का कहीं और अनुप्रयोग है। मुझे बस स्कैनर पसंद नहीं है।

— क्रंचर

Answer 1

ऐसा इसलिए है क्योंकि यह Scanner.nextIntविधि "एन्टर" मारकर बनाए गए आपके इनपुट में न्यूलाइन कैरेक्टर को नहीं पढ़ती है , और इसलिए Scanner.nextLineउस न्यूलाइन को पढ़ने के बाद कॉल करने की आवश्यकता होती है ।

आप उसी तरह के व्यवहार का सामना करेंगे जब आप किसी भी विधि के Scanner.nextLineबाद ( स्वयं को छोड़कर ) का उपयोग करेंगे।Scanner.next()Scanner.nextFoonextLine

युक्ति:

• या तो Scanner.nextLineप्रत्येक के बाद एक कॉल लगाएं Scanner.nextIntया न्यूलाइनScanner.nextFoo सहित उस लाइन के बाकी हिस्सों का उपभोग करें

  int option = input.nextInt();
  input.nextLine();  // Consume newline left-over
  String str1 = input.nextLine();
  

• या, और भी बेहतर, इनपुट को पढ़ें Scanner.nextLineऔर अपने इनपुट को उस उचित प्रारूप में परिवर्तित करें जिसकी आपको आवश्यकता है। उदाहरण के लिए, आप Integer.parseInt(String)विधि का उपयोग करके पूर्णांक में परिवर्तित कर सकते हैं ।

  int option = 0;
  try {
      option = Integer.parseInt(input.nextLine());
  } catch (NumberFormatException e) {
      e.printStackTrace();
  }
  String str1 = input.nextLine();
  

Comments

@blekione। आपको उपयोग करना होगा try-catch, क्योंकि एक अमान्य तर्क को पारित होने पर Integer.parseIntफेंकता NumberFormatExceptionहै। आप अपवाद के बारे में बाद में सीखेंगे। ईजी के लिए: - Integer.parseInt("abc")। आप "एबीसी" नहीं चाहते हैं कि इंट सही में परिवर्तित हो?

— रोहित जैन 18

@blekione। तो, उपरोक्त मामले में, आपका कोड उस बिंदु पर रुक जाएगा, और आप निष्पादन को जारी रखने में सक्षम नहीं होंगे। अपवाद हैंडलिंग के साथ, आप इस तरह की स्थितियों को संभाल सकते हैं।

— रोहित जैन 18

बाद वाला किस हद तक बेहतर है? AFAIK स्कैनर # nextInt () सही तरीका है, जो समूह कॉमा और लोकेल उपसर्ग और प्रत्यय की अनुमति देकर सही चींटियों को खोजने में अधिक उदार है। पूर्णांक # parseInt () अंक और दशमलव बिंदु को केवल एक वैकल्पिक संकेत देता है।

— मोर्देखाई

मैं व्यक्तिगत रूप Scanner#hasNextFooसे एक कोशिश-पकड़ने के बजाय पहले से एक चेक पसंद करता हूं , लेकिन वह भी काम करता है।

— MildlyMilquetoast

ParseDouble का उपयोग एक नई समस्या है, कि अगली बार दशमलव के क्षेत्रीय विन्यास (या;) का उपयोग करें, लेकिन पार्सड डबल हमेशा यूएस दशमलव (।) प्राप्त करते हैं।

— 21

Answer 2

समस्या input.nextInt () विधि के साथ है - यह केवल int मान को पढ़ता है। इसलिए जब आप input.nextLine () के साथ पढ़ना जारी रखते हैं तो आपको "\ n" कुंजी प्राप्त होती है। तो इसे छोड़ने के लिए आपको input.nextLine () को जोड़ना होगा । उम्मीद है कि यह अब स्पष्ट होना चाहिए।

इसे इस तरह आज़माएं:

System.out.print("Insert a number: ");
int number = input.nextInt();
input.nextLine(); // This line you have to add (It consumes the \n character)
System.out.print("Text1: ");
String text1 = input.nextLine();
System.out.print("Text2: ");
String text2 = input.nextLine();

Comments

umm एक समाधान लगता है, जिससे स्किप की गई रेखा को गैर-उपयोग किया जाता है nextLine, लेकिन मुझे अभी भी इस व्यवहार की व्याख्या की आवश्यकता है

— Eng.Fouad

FYI करें: stackoverflow.com/questions/7056749/…

— Shog9

प्रश्न: 16:37 पर 27 अक्टूबर को पूछा गया। 14 अगस्त को 12:24 पर उत्तर दिया। यह कैसे भी संभव है?

— अपूर्व पटने

Answer 3

ऐसा इसलिए है क्योंकि जब आप एक संख्या दर्ज करते हैं, तो दबाएं Enter, input.nextInt()केवल संख्या का उपभोग करता है, न कि "पंक्ति का अंत"। जब input.nextLine()निष्पादित होता है, तो यह पहले इनपुट से बफर में "लाइन के अंत" का उपभोग करता है।

इसके बजाय, input.nextLine()तुरंत बाद का उपयोग करेंinput.nextInt()

Comments

@ विक्टर यह बग नहीं है। यह निर्दिष्ट के रूप में काम कर रहा है। हालांकि आप तर्क दे सकते हैं कि लक्ष्य इनपुट के बाद किसी भी व्हाट्सएप का उपभोग करने के लिए एपी को बताने का एक आसान तरीका होना चाहिए।

— बोहेमियन

समझा। धन्यवाद @ बोहेमियन, कि वास्तव में मैं क्या बहस कर रहा हूं। मुझे लगता है कि इसे बदल दिया जाना चाहिए, शायद आप मुझे इंगित कर सकते हैं कि अगले जेसीपी में इस "मुद्दे" का सुझाव कहां दिया जाए।

— विक्टर

@victor आप रिपोर्ट बग या रिक्वेस्ट फ़ीचर पेज के माध्यम से एक सुविधा का अनुरोध कर सकते हैं (और कोड का योगदान कैसे करें) पता कर सकते हैं ।

— बोहेमियन

FYI करें: stackoverflow.com/questions/7056749/…

— Shog9

Answer 4

इस मुद्दे को लेकर कई सवाल उठ रहे हैं java.util.Scanner। मुझे लगता है कि कॉल scanner.skip("[\r\n]+")करने के बाद किसी भी नए वर्ण को छोड़ने के लिए कॉल करने के लिए एक अधिक पठनीय / मुहावरेदार समाधान होगा nextInt()।

EDIT: जैसा कि @PatrickParker ने नीचे उल्लेख किया है, यह एक अनंत लूप का कारण होगा यदि उपयोगकर्ता संख्या के बाद किसी भी व्हाट्सएप को इनपुट करता है। स्किप के साथ उपयोग करने के लिए एक बेहतर पैटर्न के लिए उनका जवाब देखें: https://stackoverflow.com/a/42471816/143585

Comments

FYI करें: stackoverflow.com/questions/7056749/…

— Shog9

मुझे पता है कि हम बफर में डेटा को हटाने के लिए क्या करते हैं, लेकिन इस मामले में, कृपया मेरी मदद करें: stackoverflow.com/questions/33585314/having-issues-with-scanner

— Khuong

FYI करें, यह एक अनंत लूप का कारण होगा जो संख्यात्मक इनपुट के बाद उपयोगकर्ता के किसी भी टैब या रिक्त स्थान को टाइप करता है। एक बेहतर छोड़ें के लिए मेरा जवाब यहाँ देखें: stackoverflow.com/a/42471816/7098259

— पैट्रिक पार्कर

@PatrickParker: यह वास्तव में एक अनंत लूप का कारण बनता है! धन्यवाद, लिंक को आपके लिंक करने के लिए संपादित किया गया।

— डेनिस तुलस्किए

Answer 5

ऐसा इसलिए input.nextInt();है क्योंकि न्यूलाइन पर कब्जा नहीं है। आप एक input.nextLine();नीचे जोड़कर प्रस्तावित अन्य की तरह कर सकते हैं ।
वैकल्पिक रूप से आप इसे C # स्टाइल कर सकते हैं और अगली बार किसी पूर्णांक की तरह पार्स कर सकते हैं:

int number = Integer.parseInt(input.nextLine()); 

ऐसा करने से ही काम होता है, और यह आपको कोड की एक पंक्ति बचाता है।

Comments

FYI करें: stackoverflow.com/questions/7056749/…

— Shog9

आपको यहाँ पकड़ने की कोशिश का उपयोग करना होगा। यदि इनपुट एक नंबर नहीं है तो क्या होगा। NumberFormatException को यहां संभालने की आवश्यकता है।

— अरुणदेव

यह मानता है कि आपके द्वारा इसके लिए प्रयास की जाने वाली प्रत्येक पंक्ति पर केवल एक इंट टोकन है।

— cellepo

Answer 6

टीएल; डीआर scanner.skip("\\R")प्रत्येक scanner.newLine()कॉल से पहले उपयोग करें, जिसे बाद में निष्पादित किया जाता है:

• scanner.next()
• scanner.next*TYPE*() तरीका।

आपको जिन चीजों की जानकारी होनी चाहिए:

• पाठ जो कुछ पंक्तियों का प्रतिनिधित्व करता है, उनमें भी लाइनों के बीच गैर-मुद्रण योग्य वर्ण होते हैं (जैसे हम उन्हें लाइन विभाजक कहते हैं)

  • गाड़ी वापसी (सीआर - स्ट्रिंग शाब्दिक के रूप में प्रतिनिधित्व "\r")
  • लाइन फ़ीड (LF - स्ट्रिंग शाब्दिक में प्रतिनिधित्व किया "\n")

• जब आप कंसोल से डेटा पढ़ रहे होते हैं, तो यह उपयोगकर्ता को अपनी प्रतिक्रिया टाइप करने की अनुमति देता है और जब वह किया जाता है तो उसे किसी भी तरह से इस तथ्य की पुष्टि करने की आवश्यकता होती है। ऐसा करने के लिए, उपयोगकर्ता को कीबोर्ड पर "एन्टर" / "रिटर्न" कुंजी दबाने की आवश्यकता होती है।

  यह महत्वपूर्ण है कि उपयोगकर्ता कुंजी को मानक इनपुट ( System.inजिसके द्वारा पढ़ा जाता है Scanner) का डेटा रखना सुनिश्चित करने के साथ-साथ \r\nउसके बाद ओएस निर्भर लाइन विभाजक (जैसे विंडोज के लिए) भी भेजता है।

  इसलिए जब आप उपयोगकर्ता से मान पूछ रहे हैं age, और उपयोगकर्ता प्रकार 42 और प्रेस दर्ज करते हैं, तो मानक इनपुट समाहित होगा "42\r\n"।

मुसीबत

Scanner#nextInt(और अन्य विधियाँ) स्कैनर को इन लाइन विभाजकों का उपभोग करने की अनुमति नहीं देता है । यह उनसे पढ़ेगा (कैसे अन्य स्कैनर को पता होगा कि उपयोगकर्ता से अधिक अंक नहीं हैं जो कि व्हाट्सएप का सामना करने की तुलना में मूल्य का प्रतिनिधित्व करते हैं ?) जो उन्हें मानक इनपुट से हटा देगा, लेकिन यह उन लाइन विभाजकों को आंतरिक रूप से कैश भी करेगा । हमें जो याद रखने की आवश्यकता है, वह यह है कि सभी स्कैनर विधियाँ हमेशा कैश्ड पाठ से शुरू होती हैं। Scanner#nextTypeSystem.inage

अब Scanner#nextLine()बस सभी वर्णों को इकट्ठा करता है और तब तक लौटाता है जब तक कि उसे लाइन सेपरेटर (या स्ट्रीम का अंत) नहीं मिल जाता है। लेकिन चूंकि कंसोल से संख्या को पढ़ने के बाद लाइन विभाजक स्कैनर के कैश में तुरंत पाए जाते हैं, यह खाली स्ट्रिंग लौटता है, जिसका अर्थ है कि स्कैनर उन रेखा विभाजकों (या धारा के अंत) से पहले किसी भी चरित्र को खोजने में सक्षम नहीं था।
BTW nextLineभी उन लाइन विभाजकों की खपत करता है ।

समाधान

इसलिए जब आप उस खाली स्ट्रिंग से बचने के लिए नंबर मांगना चाहते हैं, तो पूरी लाइन के लिए nextLineया तो

• द्वारा nextIntस्कैनर्स कैश से बचे लाइन सेपरेटर का उपभोग करें
  • कॉलिंग nextLine,
  • या IMO अधिक पठनीय तरीका होगा कॉल करके skip("\\R")या skip("\r\n|\r|\n")स्कैनर को लाइन विभाजक द्वारा भाग छोड़ दें (के बारे में अधिक जानकारी \R: https://stackoverflow.com/a/31060125 )
• nextInt(और न ही nextकिसी भी nextTYPEतरीके) का उपयोग न करें । इसके बजाय nextLineप्रत्येक लाइन से संख्याओं और पार्स संख्याओं का उपयोग करके संपूर्ण डेटा लाइन-बाय-लाइन पढ़ें (मान लें कि एक पंक्ति में केवल एक ही संख्या होती है) उचित प्रकार intसे Integer.parseInt।

---

BTW : विधियाँ स्कैनर द्वारा कैश्ड सहित परिसीमाकों (डिफ़ॉल्ट रूप से सभी व्हाट्सएप, लाइन सेपरेटर जैसे) को छोड़ सकती हैं , जब तक कि उन्हें अगला गैर-सीमांकक मान (टोकन) नहीं मिलेगा। कोड जैसे इनपुट के लिए धन्यवादScanner#nextType"42\r\n\r\n321\r\n\r\n\r\nfoobar"

int num1 = sc.nextInt();
int num2 = sc.nextInt();
String name = sc.next();

ठीक से असाइन करने में सक्षम होगा num1=42 num2=321 name=foobar।

Answer 7

input.nextLine()उपयोग के बजाय input.next(), इस समस्या को हल करना चाहिए।

संशोधित कोड:

public static Scanner input = new Scanner(System.in);

public static void main(String[] args)
{
    System.out.print("Insert a number: ");
    int number = input.nextInt();
    System.out.print("Text1: ");
    String text1 = input.next();
    System.out.print("Text2: ");
    String text2 = input.next();
}

Comments

FYI करें: stackoverflow.com/questions/7056749/…

— Shog9

Answer 8

यदि आप स्ट्रिंग्स और इनट दोनों को पढ़ना चाहते हैं, तो एक समाधान दो स्कैनर्स का उपयोग करना है:

Scanner stringScanner = new Scanner(System.in);
Scanner intScanner = new Scanner(System.in);

intScanner.nextInt();
String s = stringScanner.nextLine(); // unaffected by previous nextInt()
System.out.println(s);

intScanner.close();
stringScanner.close();

Comments

यह वही है जो मैं देख रहा था, कुछ समय के लिए। चतुर चाल!

— लियाम विल्सन

@ बल्डलाइनर scanner.nextLine()को काम करना चाहिए।

— आंद्रे वैलेंटी

Answer 9

यदि आप स्कैनर क्लास नेक्स्टलाइन () विधि में भ्रमित हुए बिना इनपुट फास्ट स्कैन करना चाहते हैं, तो इसके लिए कस्टम इनपुट स्कैनर का उपयोग करें।

कोड:

class ScanReader {
/**
* @author Nikunj Khokhar
*/
    private byte[] buf = new byte[4 * 1024];
    private int index;
    private BufferedInputStream in;
    private int total;

    public ScanReader(InputStream inputStream) {
        in = new BufferedInputStream(inputStream);
    }

    private int scan() throws IOException {
        if (index >= total) {
            index = 0;
            total = in.read(buf);
            if (total <= 0) return -1;
        }
        return buf[index++];
    }
    public char scanChar(){
        int c=scan();
        while (isWhiteSpace(c))c=scan();
        return (char)c;
    }


    public int scanInt() throws IOException {
        int integer = 0;
        int n = scan();
        while (isWhiteSpace(n)) n = scan();
        int neg = 1;
        if (n == '-') {
            neg = -1;
            n = scan();
        }
        while (!isWhiteSpace(n)) {
            if (n >= '0' && n <= '9') {
                integer *= 10;
                integer += n - '0';
                n = scan();
            }
        }
        return neg * integer;
    }

    public String scanString() throws IOException {
        int c = scan();
        while (isWhiteSpace(c)) c = scan();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = scan();
        } while (!isWhiteSpace(c));
        return res.toString();
    }

    private boolean isWhiteSpace(int n) {
        if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
        else return false;
    }

    public long scanLong() throws IOException {
        long integer = 0;
        int n = scan();
        while (isWhiteSpace(n)) n = scan();
        int neg = 1;
        if (n == '-') {
            neg = -1;
            n = scan();
        }
        while (!isWhiteSpace(n)) {
            if (n >= '0' && n <= '9') {
                integer *= 10;
                integer += n - '0';
                n = scan();
            }
        }
        return neg * integer;
    }

    public void scanLong(long[] A) throws IOException {
        for (int i = 0; i < A.length; i++) A[i] = scanLong();
    }

    public void scanInt(int[] A) throws IOException {
        for (int i = 0; i < A.length; i++) A[i] = scanInt();
    }

    public double scanDouble() throws IOException {
        int c = scan();
        while (isWhiteSpace(c)) c = scan();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = scan();
        }
        double res = 0;
        while (!isWhiteSpace(c) && c != '.') {
            if (c == 'e' || c == 'E') {
                return res * Math.pow(10, scanInt());
            }
            res *= 10;
            res += c - '0';
            c = scan();
        }
        if (c == '.') {
            c = scan();
            double m = 1;
            while (!isWhiteSpace(c)) {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, scanInt());
                }
                m /= 10;
                res += (c - '0') * m;
                c = scan();
            }
        }
        return res * sgn;
    }

}

लाभ:

• बफर इनपुट बफ़ररीडर की तुलना में तेज़ है
• समय की जटिलता को कम करता है
• हर अगले इनपुट के लिए बफर फ्लश करता है

तरीके:

• ScanChar () - सिंगल कैरेक्टर को स्कैन करें
• scanInt () - स्कैन इंटीगर वैल्यू
• स्कैनलॉन्ग () - लॉन्ग वैल्यू को स्कैन करें
• scanString () - स्कैन स्ट्रिंग मान
• ScanDouble () - डबल मान स्कैन करें
• scanInt (int [] array) - स्कैन पूरा ऐरे (पूर्णांक)
• स्कैनलॉन्ग (लंबी [] सरणी) - स्कैन पूरा ऐरे (लंबा)

उपयोग:

1. अपने जावा कोड के नीचे दिए गए कोड को कॉपी करें।
2. प्रारंभिक कक्षा के लिए प्रारंभिक वस्तु

ScanReader sc = new ScanReader(System.in); 3. आवश्यक कक्षाएं आयात करें:

import java.io.BufferedInputStream; import java.io.IOException; import java.io.InputStream; 4. अपवाद को संभालने के लिए अपने मुख्य विधि से IOException को फेंक दें। प्रदान किए गए तरीकों का उपयोग करें। 6. आनंद लें

उदाहरण :

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
class Main{
    public static void main(String... as) throws IOException{
        ScanReader sc = new ScanReader(System.in);
        int a=sc.scanInt();
        System.out.println(a);
    }
}
class ScanReader....

Answer 10

समस्या से बचने के लिए, बफ़र को साफ़ करने में मदद करने के nextLine();तुरंत बाद उपयोग करें nextInt();। जब आप प्रेस नई लाइन पर कब्जा नहीं है और इसलिए, छोड़ देता है तो कोड बाद में।ENTERnextInt();Scanner

Scanner scanner =  new Scanner(System.in);
int option = scanner.nextInt();
scanner.nextLine(); //clearing the buffer

Answer 11

sc.nextLine()इनपुट पार्स करने की तुलना में बेहतर है। क्योंकि प्रदर्शन के लिहाज से यह अच्छा रहेगा।

Answer 12

मुझे लगता है मैं पार्टी के लिए बहुत देर हो चुकी हूँ ..

जैसा कि पहले कहा गया था, input.nextLine()आपके इंट वैल्यू मिलने के बाद कॉल करने से आपकी समस्या दूर हो जाएगी। आपके कोड के काम न करने का कारण यह था कि आपके इनपुट (जहाँ आपने int इनपुट किया था) से स्टोर करने के लिए और कुछ नहीं था string1। मैं अभी पूरे विषय पर थोड़ा और प्रकाश डालूँगा।

पर विचार करें nextLine () के बीच अजीब एक बाहर के रूप में nextFoo () स्कैनर कक्षा में तरीकों। आइए एक त्वरित उदाहरण लेते हैं .. मान लेते हैं कि हमारे पास कोड की दो पंक्तियाँ हैं जैसे नीचे दी गई हैं:

int firstNumber = input.nextInt();
int secondNumber = input.nextInt();

यदि हम नीचे दिए गए इनपुट का इनपुट करते हैं (इनपुट की एक पंक्ति के रूप में)

५४ २३४

हमारे firstNumberऔर secondNumberचर का मान क्रमशः 54 और 234 हो जाता है। इस तरह से काम करने का कारण यह है क्योंकि एक नई लाइन फीड ( यानी \ n ) ISI नहीं है जब स्वचालित रूप से उत्पन्न होता है जब मानों में अगला () विधि लेता है। यह बस "अगला इंट" लेता है और आगे बढ़ता है। यह नेक्स्टफीन () को छोड़कर बाकी के फफू () तरीकों के लिए भी ऐसा ही है।

अगलालाइन () मान लेने के तुरंत बाद एक नई लाइन फ़ीड उत्पन्न करता है; यह वही है जो @RohitJain का अर्थ है कि नई लाइन फ़ीड "भस्म" है।

अंत में, अगली () विधि बस एक नई लाइन उत्पन्न किए बिना निकटतम स्ट्रिंग लेती है ; यह एक ही लाइन के भीतर अलग स्ट्रिंग्स लेने के लिए तरजीही विधि बनाता है।

मुझे आशा है कि यह मदद करता है .. मेरी कोडिंग!

Comments

"नई लाइन फ़ीड" क्या है?

— आर्चर

@ एलसीडी एक नई लाइन फीड का मूल अर्थ है 'नई लाइन से शुरू होना'।

— तस्लीम ओसेनी

यह "54 234" उदाहरण वास्तव में चीजों को स्पष्ट करता है।

— अलोंसो डेल एर्ट

Answer 13

एक के बजाय 2 स्कैनर ऑब्जेक्ट का उपयोग करें

Scanner input = new Scanner(System.in);
System.out.println("Enter numerical value");    
int option;
Scanner input2 = new Scanner(System.in);
option = input2.nextInt();

Answer 14

public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int i = scan.nextInt();
        scan.nextLine();
        double d = scan.nextDouble();
        scan.nextLine();
        String s = scan.nextLine();

        System.out.println("String: " + s);
        System.out.println("Double: " + d);
        System.out.println("Int: " + i);
    }

Comments

यदि आप अगली लाइन () मेथड के तुरंत बाद अगली () विधि का उपयोग करते हैं, तो याद रखें कि अगला () पूर्णांक टोकन पढ़ता है; इस वजह से, पूर्णांक इनपुट की उस पंक्ति के लिए अंतिम न्यूलाइन वर्ण अभी भी इनपुट बफ़र में पंक्तिबद्ध है और अगली नेक्स्टलाइन () पूर्णांक रेखा के शेष भाग (जो रिक्त है) को पढ़ रही होगी।

— नीरज गहलावत

Answer 15

अगर मुझे गैर-रिक्त इनपुट की उम्मीद है

public static Function<Scanner,String> scanLine = (scan -> {
    String s = scan.nextLine();
    return( s.length() == 0 ? scan.nextLine() : s );
  });

उपरोक्त उदाहरण में उपयोग किया जाता है:

System.out.println("Enter numerical value");    
int option = input.nextInt(); // read numerical value from input

System.out.println("Enter 1st string"); 
String string1 = scanLine.apply( input ); // read 1st string
System.out.println("Enter 2nd string");
String string2 = scanLine.apply( input ); // read 2nd string

Answer 16

मेरे एक usecase में, मुझे पूर्णांक मानों के एक जोड़े से पहले एक स्ट्रिंग मान को पढ़ने का परिदृश्य मिला । मुझे मूल्यों को पढ़ने के लिए " फॉर / लूप " का उपयोग करना था । और इस मामले में उपरोक्त सुझावों में से किसी ने भी काम नहीं किया।

तय मुद्दे के input.next()बजाय उपयोग करना input.nextLine()। आशा है कि यह समान परिदृश्य से निपटने वालों के लिए मददगार हो सकता है।

Answer 17

इस कोड का उपयोग करें यह आपकी समस्या को ठीक करेगा।

System.out.println("Enter numerical value");    
int option;
option = input.nextInt(); // Read numerical value from input
input.nextLine();
System.out.println("Enter 1st string"); 
String string1 = input.nextLine(); // Read 1st string (this is skipped)
System.out.println("Enter 2nd string");
String string2 = input.nextLine(); // Read 2nd string (this appears right after reading numerical value)

Answer 18

के रूप में nextXXX()तरीकों नहीं पढ़ते newline, सिवाय nextLine()। हम नीचे के रूप में उपयोग करके newlineकिसी भी non-stringमूल्य ( intइस मामले में) को पढ़ने के बाद छोड़ सकते scanner.skip()हैं:

Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
sc.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
System.out.println(x);
double y = sc.nextDouble();
sc.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
System.out.println(y);
char z = sc.next().charAt(0);
sc.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
System.out.println(z);
String hello = sc.nextLine();
System.out.println(hello);
float tt = sc.nextFloat();
sc.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
System.out.println(tt);

Answer 19

क्यों हर पढ़ने के लिए एक नया स्कैनर का उपयोग नहीं करते? नीचे की तरह। इस दृष्टिकोण के साथ आप अपनी समस्या का सामना नहीं करेंगे।

int i = new Scanner(System.in).nextInt();

Comments

लेकिन फिर आपको Scannerमेमोरी रिसाव को रोकने के लिए बंद करना होगा। खाक फाँकना?

— कॉफ़ी कॉप

क्या GC इस बात का ध्यान नहीं रखता कि अगर स्कैनर एक विधि में लिपटा हुआ है? जैसे: स्ट्रिंग getInput () {रिटर्न न्यू स्कैनर (System.in) .nextLine ()};

— टोबियास जोहानसन

यह बिल्कुल गलत है। nextInt()चाहे वह "नया" हो Scannerया पहले से इस्तेमाल किया गया हो , चाहे वह नईलाइन का उपभोग न करे ।

— दाऊद इब्न करीम