जावा में ऐरेलिस्ट और

Question

इनपुट करने के लिए मुझे पाइथन के लिए उपयोग किया जाता है, इसलिए यह मेरे लिए थोड़ा उलझन में है। मैं इनपुट, लाइन-बाय-लाइन में लेने की कोशिश कर रहा हूं, जब तक कोई उपयोगकर्ता एक निश्चित संख्या इनपुट नहीं करता। संख्याएं उन्हें कुछ सांख्यिकीय गणित लागू करने के लिए सरणी में संग्रहीत की जाएंगी। वर्तमान में, मेरे पास एक मुख्य वर्ग, आंकड़े कक्षाएं, और एक "पढ़ने" वर्ग है।

दो सवाल:

1. मैं, बाहर काम करने के इनपुट पाश पाने के लिए नहीं कर पा रहे ऐसा करने के लिए सबसे अच्छा अभ्यास क्या।

2. रीडिंग विधि के लिए ऑब्जेक्ट-प्रकार क्या होगा? एक डबल [], या एक ArrayList?

   1. मैं विधि-प्रकार को सरणीसूची के रूप में कैसे घोषित करूं?

   2. मैं सरणी को 1000 से अधिक मूल्यों को संग्रहीत करने से कैसे रोकूं?

मुझे दिखाओ क्या मैं अब तक करते हैं:

public static java.util.ArrayList readRange(double end_signal){ 
    //read in the range and stop at end_signal 

    ArrayList input = new ArrayList(); 
    Scanner kbd = new Scanner(System.in); 
    int count = 0; 
    do{ 
     input.add(kbd.nextDouble()); 
     System.out.println(input); //debugging 
     ++count; 
    } while(input(--count) != end_signal); 
    return input; 
} 

किसी भी मदद की सराहना की जाएगी, मेरी newbieness क्षमा ...

Answer 1

उत्तर:

> 1। मुझे इनपुट लूप को काम करने के लिए प्रतीत नहीं होता है, ऐसा करने के लिए सबसे अच्छा अभ्यास क्या है।

मैं नहीं बल्कि ... जबकि एक करते हैं {} जबकि के बजाय पाश एक सरल है और थोड़ी देर में हालत रखेंगे ... मेरे उदाहरण में इसे पढ़ा:

जबकि पढ़ने संख्या नहीं है अंत संकेत और गिनती सीमा से कम है: करते हैं।

> 2। रीडिंग विधि के लिए ऑब्जेक्ट-टाइप क्या होगा? एक डबल [], या एक ArrayList?

एक ऐरेलिस्ट, हालांकि मैं आपको सूची (java.util.List) इंटरफ़ेस का उपयोग करने की दृढ़ता से अनुशंसा करता हूं। कार्यान्वयन के बजाय इंटरफ़ेस में प्रोग्राम करने के लिए यह एक अच्छा ओओ अभ्यास है।

> 2.1 मैं विधि-प्रकार को सरणीसूची के रूप में कैसे घोषित करूं?

नीचे कोड देखें।

> 2.2। मैं सरणी को 1000 से अधिक मूल्यों को संग्रहीत करने से कैसे रोकूं?

इस शर्त को थोड़ी देर में जोड़कर।

import java.util.Scanner; 
import java.util.List; 
import java.util.ArrayList; 

public class InputTest{ 

    private int INPUT_LIMIT = 10000; 

    public static void main(String [] args) { 
     InputTest test = new InputTest(); 
     System.out.println("Start typing numbers..."); 
     List list = test.readRange(2.0); 
     System.out.println("The input was " + list); 
    } 

    /** 
    * Read from the standar input until endSignal number is typed. 
    * Also limits the amount of entered numbers to 10000; 
    * @return a list with the numbers. 
    */ 
    public List readRange(double endSignal) { 
     List<Double> input = new ArrayList<Double>(); 
     Scanner kdb = new Scanner(System.in); 
     int count = 0; 
     double number = 0; 
     while((number = kdb.nextDouble()) != endSignal && count < INPUT_LIMIT){ 
      System.out.println(number); 
      input.add(number); 
     } 
     return input; 
    } 
} 

अंतिम टिप्पणी:

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

जावा कोड में एक उदाहरण बनाया है शैली चर नाम की तरह "endSignal" के बजाय "end_signal" cammel मामले में जाना चाहिए

Answer 2

क्या आप अपने पाश में की जरूरत है शर्त है :

while (input.get(input.size()-1) != end_signal); 

आप जो कर रहे हैं वह कम है काउंटर वैरिएबल में प्रवेश करना।

इसके अलावा, आप ArrayList तो तरह की घोषणा करना चाहिए:

ArrayList<Double> list = new ArrayList<Double>(); 

इस सूची में विशेष प्रकार के बनाता है और के रूप में दिया हालत अनुमति देता है। अन्यथा अतिरिक्त कास्टिंग है।

Answer 3

**

public static java.util.ArrayList readRange(double end_signal) { 

    //read in the range and stop at end_signal 

    ArrayList input = new ArrayList(); 

    Scanner kbd = new Scanner(System. in); 
    int count = 0; 

    do { 
     input.add(Double.valueOf(kbd.next())); 
     System.out.println(input); //debugging 
     ++count; 
    } while (input(--count) != end_signal); 
    return input; 
} 

**

Answer 4

मैं तुम्हें बुरा नहीं बाहर शुरू कर दिया लगता है, लेकिन यहाँ मेरा सुझाव है। मैं कोड के नीचे महत्वपूर्ण मतभेदों और बिंदुओं को हाइलाइट करूंगा:

पैकेज कंसोल;

आयात java.util। ; आयात java.util.regex आयात करें।;

सार्वजनिक वर्ग ArrayListInput {

public ArrayListInput() { 
    // as list 
    List<Double> readRange = readRange(1.5); 

    System.out.println(readRange); 
    // converted to an array 
    Double[] asArray = readRange.toArray(new Double[] {}); 
    System.out.println(Arrays.toString(asArray)); 
} 

public static List<Double> readRange(double endWith) { 
    String endSignal = String.valueOf(endWith); 
    List<Double> result = new ArrayList<Double>(); 
    Scanner input = new Scanner(System.in); 
    String next; 
    while (!(next = input.next().trim()).equals(endSignal)) { 
     if (isDouble(next)) { 
      Double doubleValue = Double.valueOf(next); 
      result.add(doubleValue); 
      System.out.println("> Input valid: " + doubleValue); 
     } else { 
      System.err.println("> Input invalid! Try again"); 
     } 
    } 
    // result.add(endWith); // uncomment, if last input should be in the result 
    return result; 
} 

public static boolean isDouble(String in) { 
    return Pattern.matches(fpRegex, in); 
} 

public static void main(String[] args) { 
    new ArrayListInput(); 
} 

private static final String Digits = "(\\p{Digit}+)"; 
private static final String HexDigits = "(\\p{XDigit}+)"; 
// an exponent is 'e' or 'E' followed by an optionally 
// signed decimal integer. 
private static final String Exp = "[eE][+-]?" + Digits; 
private static final String fpRegex = ("[\\x00-\\x20]*" + // Optional leading "whitespace" 
     "[+-]?(" + // Optional sign character 
     "NaN|" + // "NaN" string 
     "Infinity|" + // "Infinity" string 

     // A decimal floating-point string representing a finite positive 
     // number without a leading sign has at most five basic pieces: 
     // Digits . Digits ExponentPart FloatTypeSuffix 
     // 
     // Since this method allows integer-only strings as input 
     // in addition to strings of floating-point literals, the 
     // two sub-patterns below are simplifications of the grammar 
     // productions from the Java Language Specification, 2nd 
     // edition, section 3.10.2. 

     // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt 
     "(((" + Digits + "(\\.)?(" + Digits + "?)(" + Exp + ")?)|" + 

     // . Digits ExponentPart_opt FloatTypeSuffix_opt 
     "(\\.(" + Digits + ")(" + Exp + ")?)|" + 

     // Hexadecimal strings 
     "((" + 
     // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt 
     "(0[xX]" + HexDigits + "(\\.)?)|" + 

     // 0[xX] HexDigits_opt . HexDigits BinaryExponent 
     // FloatTypeSuffix_opt 
     "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" + 

     ")[pP][+-]?" + Digits + "))" + "[fFdD]?))" + "[\\x00-\\x20]*");// Optional 
                     // trailing 
                     // "whitespace" 

}

1. जावा में यह जेनरिक उपयोग करने के लिए एक अच्छी बात है। इस तरह आप संकलक और वर्चुअल मशीन को उन प्रकारों के बारे में संकेत देते हैं जिनका आप उपयोग करने जा रहे हैं। अपने डबल इस मामले में और जिसके परिणामस्वरूप सूची घोषित करने, डबल मूल्यों को नियंत्रित करने के आप कास्टिंग/प्रकार रूपांतरण के बिना मूल्यों का उपयोग करने में सक्षम हैं द्वारा:

   if (!readRange.isEmpty()) { 
       double last = readRange.get(readRange.size() - 1); 
   } 
   

2. यह जब जावा संग्रह के साथ काम कर रहे इंटरफेस वापस जाने के लिए बेहतर है, के रूप में वहाँ विशिष्ट सूची के कई प्रयोगों हैं (LinkedList, SynchronizedLists, ...)। तो अगर आप बाद में सूची की एक अन्य प्रकार की जरूरत है, आप के लिए आसान विधि के अंदर ठोस कार्यान्वयन को बदल सकते हैं और आपके पास कोई और कोड बदलने की जरूरत नहीं है।

3. आप सोच रहे होंगे क्यों, जबकि नियंत्रण बयान से काम करता है, लेकिन जैसा कि आप देख, वहाँ कोष्ठक हैं चारों ओर अगले = input.next()। ट्रिम()। इस तरह परिवर्तनीय असाइनमेंट सशर्त परीक्षण से ठीक पहले होता है। इसके अलावा एक ट्रिम whitespacing मुद्दों

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

5. यह सुनिश्चित हो, एक उपयोगकर्ता वास्तव में, एक डबल inputed मैं Double.valueOf() विधि के JavaDoc से एक रेगुलर एक्सप्रेशन का इस्तेमाल किया।यदि यह अभिव्यक्ति मेल खाती है, तो मान परिवर्तित हो जाता है, अगर कोई त्रुटि संदेश मुद्रित नहीं किया जाएगा।

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

7. आप एक सरणी के साथ पर काम करना चाहते हैं, तो निर्माता के दूसरे भाग बाहर से पता चलता है कि यह कैसे कन्वर्ट करने के लिए।

8. मुझे आशा है कि आप डबल और डबल ऊपर Mixin मेरे द्वारा भ्रमित नहीं कर रहे हैं, लेकिन जावा 1.5 सुविधा स्वत: मुक्केबाजी के लिए धन्यवाद यह कोई समस्या नहीं है। और Scanner.next के रूप में() वापस कभी नहीं होगा अशक्त (AFAIK), इस सब पर एक समस्या हो should't।

9. आप सरणी के आकार को सीमित करना चाहते हैं,

ठीक है का उपयोग करें, मुझे आशा है कि तुम मेरे समाधान पता लगा रहे हैं और स्पष्टीकरण उपयोगी, result.size() का उपयोग सूचक और के रूप में कीवर्ड नियंत्रण ब्रेक को नियंत्रण नियंत्रण कथन छोड़ने के लिए।

ग्रीटज़, जीएचएड