स्कैनर वर्ग से अगले () और नेक्स्टलाइन () तरीकों में क्या अंतर है?

Question 1

मुख्य अंतर क्या है next()और nextLine()?
मेरा मुख्य लक्ष्य सभी पाठ को पढ़ना है, Scannerजो किसी भी स्रोत से "जुड़ा" हो सकता है (उदाहरण के लिए फ़ाइल)।

मुझे कौन सा चुनना चाहिए और क्यों?

Question 2

मैं हमेशा इनपुट का उपयोग करके पढ़ना पसंद करता हूं nextLine()और फिर स्ट्रिंग को पार्स करता हूं ।

उपयोग करने next()से केवल वही वापस आएगा जो परिसीमन से पहले आता है (व्हॉट्सएप पर चूक)। nextLine()वर्तमान लाइन को वापस करने के बाद स्‍कैनर को स्‍वत: नीचे ले जाता है।

से डेटा पार्स करने के लिए एक उपयोगी उपकरण nextLine()होगा str.split("\\s+")।

String data = scanner.nextLine();
String[] pieces = data.split("\\s+");
// Parse the pieces

स्कैनर वर्ग या स्ट्रिंग वर्ग के संबंध में अधिक जानकारी के लिए निम्न लिंक देखें।

स्कैनर: http://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html

स्ट्रिंग: http://docs.oracle.com/javase/7/docs/api/java/lang/String.html

Question 3

next()केवल अंतरिक्ष तक इनपुट पढ़ सकते हैं। यह एक स्थान से अलग दो शब्दों को नहीं पढ़ सकता है। इसके अलावा, next()इनपुट पढ़ने के बाद कर्सर को उसी लाइन में रखें।

nextLine()शब्दों के बीच अंतरिक्ष सहित इनपुट पढ़ता है (अर्थात, यह पंक्ति के अंत तक पढ़ता है \n)। इनपुट पढ़ने के बाद, nextLine()कर्सर को अगली पंक्ति में रखें।

पूरी लाइन पढ़ने के लिए आप इसका उपयोग कर सकते हैं nextLine()।

Question 4

JavaDoc से:

एक Scannerसीमांकक पैटर्न का उपयोग करके अपने इनपुट को टोकन में तोड़ देता है, जो डिफ़ॉल्ट रूप से व्हाट्सएप से मेल खाता है।

next(): इस स्कैनर से अगले पूर्ण टोकन को ढूँढता है और लौटाता है।

nextLine(): इस स्कैनर को वर्तमान लाइन से आगे बढ़ाता है और उस इनपुट को वापस करता है जिसे छोड़ दिया गया था।

इसलिए "small example<eol>text" next()"छोटे" पर nextLine()लौटना चाहिए और "छोटे उदाहरण" को वापस करना चाहिए

Question 5

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

public class ScannerTest {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int cases = sc.nextInt();
        String []str = new String[cases];
        for(int i=0;i<cases;i++){
            str[i]=sc.next();
        }
     }

}

लूप के लिए अगले () और नेक्स्टलाइन () को बदलकर इस प्रोग्राम को आज़माएं, बिना किसी इनपुट के एंटर करने वाली '\ n' को दबाएं, आप पा सकते हैं कि नेक्स्टलाइन () मेथड के इस्तेमाल से यह दी गई संख्या के मामलों को दबाने के बाद समाप्त हो जाती है। अगले के रूप में () आपको दिए गए मामलों की संख्या के लिए आपके द्वारा प्रदान किए गए और इनपुट को समाप्त नहीं करता है ।

Question 6

कुंजी बिंदु यह है कि जहां विधि बंद हो जाएगी और जहां तरीकों को कॉल करने के बाद कर्सर होगा।

सभी विधियाँ उन सूचनाओं को पढ़ेगी जिनमें कर्सर स्थिति और अगले डिफ़ॉल्ट सीमांकक (व्हाट्सएप, टैब, \ n - एंटर दबाकर बनाया गया) के बीच व्हाट्सएप शामिल नहीं है। कर्सर सिवाय सीमांकक के पहले रुक जाता है nextLine(), जो कर्सर स्थिति और \ n के बीच सूचना (व्हिटस्पेस द्वारा बनाए गए व्हाट्सएप सहित) पढ़ता है, और कर्सर \ n के पीछे रुक जाता है।

उदाहरण के लिए, निम्नलिखित दृष्टांत पर विचार करें:

|23_24_25_26_27\n

| -> वर्तमान कर्सर स्थिति

_ -> व्हाट्सएप

स्ट्रीम -> बोल्ड (कॉलिंग विधि द्वारा मिली जानकारी)

देखें कि क्या होता है जब आप इन विधियों को कहते हैं:

nextInt()

पढ़े 23 | _24_25_26_27 \ n

nextDouble()

23_ 24 पढ़ें । _25_26_27 \ n

next()

पढ़े 23_24_ 25 | _26_27 \ n

nextLine()

पढ़े 23_24_25 _26_27 \ n |

इसके बाद, आपकी आवश्यकता के आधार पर विधि को बुलाया जाना चाहिए।

Question 7

संक्षेप में: यदि आप लंबाई टी का एक स्ट्रिंग सरणी इनपुट कर रहे हैं, तो स्कैनर # अगली लाइन () टी लाइनों की अपेक्षा करता है, स्ट्रिंग सरणी में प्रत्येक प्रविष्टि को कुंजी दर्ज करके दूसरे से अलग किया जाता है। और # स्कैनर # अगला () तक जारी रहेगा। आप ऐरे के अंदर स्ट्रो (शब्द) स्टोर करते हैं, जिसे व्हाट्सएप द्वारा अलग किया जाता है।

कोड के स्निपेट का अनुसरण करने पर एक नज़र डालते हैं

    Scanner in = new Scanner(System.in);
    int t = in.nextInt();
    String[] s = new String[t];

    for (int i = 0; i < t; i++) {
        s[i] = in.next();
    }

जब मैं अपने IDE में कोड के स्निपेट से ऊपर चला जाता हूं (स्ट्रिंग की लंबाई 2 के लिए कहने देता हूं), इससे कोई फर्क नहीं पड़ता कि मैं अपना स्ट्रिंग दर्ज करता हूं

इनपुट के रूप में: - abcd abcd या

इनपुट के रूप में: -

ऐ बी सी डी

आउटपुट abcd की तरह होगा

ऐ बी सी डी

लेकिन अगर उसी कोड में हम नेक्स्ट () मेथड बाई नेक्स्टलाइन ()

    Scanner in = new Scanner(System.in);
    int t = in.nextInt();
    String[] s = new String[t];

    for (int i = 0; i < t; i++) {
        s[i] = in.nextLine();
    }

फिर यदि आप प्रॉम्प्ट पर इनपुट दर्ज करते हैं जैसे - एबीसी एलसीडी

आउटपुट है: -

एबीसीडी ABCD

और यदि आप प्रॉम्प्ट पर abcd के रूप में इनपुट दर्ज करते हैं (और यदि आप दूसरी लाइन में अगली abcd दर्ज करने के लिए एंटर दबाते हैं, तो इनपुट प्रॉम्प्ट बस बाहर निकल जाएगा और आपको आउटपुट मिल जाएगा)

आउटपुट है: -

ऐ बी सी डी

Question 8

से javadocs

यदि यह निर्दिष्ट स्ट्रिंग से निर्मित पैटर्न से मेल खाता है तो अगला () अगला टोकन लौटाता है। अगली लाइन () इस स्कैनर को वर्तमान लाइन से आगे बढ़ाती है और उस इनपुट को वापस करती है जिसे छोड़ दिया गया था।

आप कौन सा चुनते हैं यह निर्भर करता है कि आपकी आवश्यकताओं के अनुसार कौन सा सूट करता है। अगर यह मुझे एक पूरी फ़ाइल पढ़ रहा था तो मैं अगली फ़ाइल के लिए तब तक जाऊँगा जब तक मेरे पास सारी फ़ाइल नहीं थी।

Question 9

स्कैनर के लिए प्रलेखन से :

एक स्कैनर एक सीमांकक पैटर्न का उपयोग करके अपने इनपुट को टोकन में तोड़ देता है, जो डिफ़ॉल्ट रूप से व्हाट्सएप से मेल खाता है।

अगले के लिए प्रलेखन से () :

एक पूर्ण टोकन पूर्ववर्ती है और उसके बाद इनपुट जो कि सीमांकक पैटर्न से मेल खाता है।

Question 10

अगला () और नेक्स्टलाइन () तरीके स्कैनर के साथ जुड़े हुए हैं और इसका उपयोग स्ट्रिंग इनपुट प्राप्त करने के लिए किया जाता है। उनके मतभेद हैं ...

अगला () केवल अंतरिक्ष तक इनपुट पढ़ सकता है। यह अंतरिक्ष द्वारा अलग किए गए दो शब्दों को नहीं पढ़ सकता है। इसके अलावा, अगला () इनपुट पढ़ने के बाद कर्सर को उसी पंक्ति में रखता है।

नेक्स्टलाइन () शब्दों के बीच स्पेस सहित इनपुट को पढ़ता है (अर्थात, यह लाइन के अंत तक पढ़ता है \ n)। इनपुट पढ़े जाने के बाद, अगली लाइन में (अगली पंक्ति) कर्सर को रखता है।

import java.util.Scanner;

public class temp
{
    public static void main(String arg[])
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("enter string for c");
        String c=sc.next();
        System.out.println("c is "+c);
        System.out.println("enter string for d");
        String d=sc.next();
        System.out.println("d is "+d);
    }
}

आउटपुट:

c abc def
c के लिए स्ट्रिंग दर्ज करें

d के लिए स्ट्रिंग दर्ज करें

डी है डीईएफ़

यदि आप अगले () के बजाय अगली लाइन () का उपयोग करते हैं

आउटपुट:

c के लिए स्ट्रिंग दर्ज करें

एबीसी डीईएफ
सी, एबीसी डीईएफ
डी के लिए स्ट्रिंग दर्ज करें

GHI
d GHI है

Question 11

Scanner.next () और nextLine () के दूसरे उदाहरण के लिए बस यह है कि नीचे की तरह: nextLine () उपयोगकर्ता के प्रकार को आगे नहीं जाने देता (अगले) स्कैनर इंतजार करता है और इनपुट पढ़ता है।
```
 Scanner sc = new Scanner(System.in);

 do {
    System.out.println("The values on dice are :");
    for(int i = 0; i < n; i++) {
        System.out.println(ran.nextInt(6) + 1);
    }
    System.out.println("Continue : yes or no");
 } while(sc.next().equals("yes"));
// while(sc.nextLine().equals("yes"));
```

Question 12

एक स्कैनर एक सीमांकक पैटर्न का उपयोग करके अपने इनपुट को टोकन में तोड़ देता है, जो कि व्हाट्सएप ज्ञात डिफ़ॉल्ट रूप से होता है ।

अगला () एकल शब्द पढ़ने के लिए उपयोग करता है और जब इसे एक सफेद स्थान मिलता है, तो यह पढ़ना बंद कर देता है और कर्सर वापस अपनी मूल स्थिति में आ जाता है। नेक्स्टलाइन () जबकि यह एक पूरा शब्द पढ़ता है तब भी जब यह व्हॉट्सएप से मिलता है। यह कर्सर तब खत्म हो जाता है जब यह पढ़ना समाप्त हो जाता है और कर्सर लाइन के अंत में वापस आ जाता है। तो यू एक का उपयोग करने की जरूरत नहीं delimeter जब आप एक sentence.you सिर्फ NextLine उपयोग करने की आवश्यकता के रूप में एक पूर्ण शब्द पढ़ना चाहते हैं ()।

 public static void main(String[] args) {
            // TODO code application logic here
           String str;
            Scanner input = new Scanner( System.in );
            str=input.nextLine();
            System.out.println(str);
       }

Question 13

दोनों फ़ंक्शन का उपयोग अगले स्कैनर टोकन पर जाने के लिए किया जाता है।

अंतर यह है कि स्कैनर टोकन कैसे उत्पन्न होता है

अगला () व्हाइट स्पेस के रूप में सीमांकक का उपयोग करके स्कैनर टोकन उत्पन्न करता है

अगली लाइन () iter \ n ’के रूप में सीमांकक का उपयोग करके स्कैनर टोकन उत्पन्न करता है (यानी कुंजी दबाएं)

Question 14

मुझे एक सीमांकक के विषय में भी समस्या हुई। सवाल सभी के इनपुट के बारे में था

अपना नाम दर्ज करें।
अपनी आयु दर्ज करें।
अपना ईमेल दर्ज करें।
अपना पता दर्ज करें।

समस्या

मैंने नाम, आयु और ईमेल के साथ सफलतापूर्वक समापन किया।
जब मैं एक होने दो शब्दों से पता के साथ आया था खाली स्थान के (Harnet सड़क) मैं सिर्फ पहले एक "harnet" मिला है।

समाधान

मैंने अपने स्कैनर के लिए सीमांकक का इस्तेमाल किया और सफल रहा।

उदाहरण

 public static void main (String args[]){
     //Initialize the Scanner this way so that it delimits input using a new line character.
    Scanner s = new Scanner(System.in).useDelimiter("\n");
    System.out.println("Enter Your Name: ");
    String name = s.next();
    System.out.println("Enter Your Age: ");
    int age = s.nextInt();
    System.out.println("Enter Your E-mail: ");
    String email = s.next();
    System.out.println("Enter Your Address: ");
    String address = s.next();

    System.out.println("Name: "+name);
    System.out.println("Age: "+age);
    System.out.println("E-mail: "+email);
    System.out.println("Address: "+address);
}

Question 15

मूल अंतर अगले है () का उपयोग तब तक इनपुट प्राप्त करने के लिए किया जाता है जब तक कि सीमांकक का सामना नहीं किया जाता है (डिफ़ॉल्ट रूप से यह व्हाट्सएप है, लेकिन आप इसे बदल भी सकते हैं) और उस टोकन को वापस लौटाएं जो आपने दर्ज किया है। कर्सर तब सेम लाइन पर रहता है। जबकि अगली लाइन में () यह इनपुट को तब तक स्कैन करता है जब तक हम एंटर बटन को हिट नहीं करते हैं और पूरी चीज़ को वापस करते हैं और कर्सर को अगली पंक्ति में रखते हैं। **

        Scanner sc=new Scanner(System.in);
        String s[]=new String[2];
        for(int i=0;i<2;i++){
            s[i]=sc.next();
        }
        for(int j=0;j<2;j++)
        {
            System.out.println("The string at position "+j+ " is "+s[j]);
        }

**

"हैलो वर्ल्ड" के रूप में इनपुट देकर इस कोड को चलाने का प्रयास करें। स्कैनर 'ओ' तक इनपुट पढ़ता है और फिर एक सीमांकक होता है। इसके अलावा [0] "हैलो" होगा और कर्सर सीमांकक के बाद अगली स्थिति की ओर इशारा करेगा ( हमारे मामले में यह 'डब्ल्यू' है, और जब s [1] पढ़ा जाता है तो यह "वर्ल्ड" को स्कैन करता है और इसे अगले पूर्ण टोकन (स्कैनर की परिभाषा द्वारा) के रूप में s [1] पर लौटाता है। यदि हम नेक्स्टलाइन () का उपयोग करते हैं। इसके बजाय, यह "हैलो वर्ल्ड" को पूरी तरह से पढ़ेगा और इससे भी अधिक जब तक हम एंटर बटन को हिट नहीं करते हैं और इसे s [0] में स्टोर करते हैं। हम अगली लाइन () का उपयोग करके एक और स्ट्रिंग भी दे सकते हैं। मैं आपको इस उदाहरण का उपयोग करने का प्रयास करने की सलाह देता हूं और अधिक से अधिक स्पष्टीकरण मांगता हूं।