स्प्लिट और लूप जावा में 8

Question

मैं इस समस्या को जो मैं जावा 8 में हल करना चाहते,

मैं एक स्ट्रिंग जो स्ट्रिंग में से .

A.B.C.D 

वर्णों की संख्या concatenated है अलग-अलग हो सकता है है ।

मेरे पास यह तरीका है, जो स्ट्रिंग को इनपुट के रूप में लेता है और गहरा स्तर की संख्या को ले जाना पड़ता है, मुझे उस संख्या के माध्यम से लूप करना पड़ता है जो मुझे "।" के साथ स्ट्रिंग पर एक विभाजन लागू करने के बाद मिलता है। और केवल स्तर दिया गया गहराई

private String getResponse (String str, int level) { 
// for now, simply print the entire string first and then start removing last alphabet of it one by one till the value of level 
// ex : str = A.B.C.D 
// System.out.println("Doing a call with key as = " + str); => should give me A.B.C.D 
// Apply logic of split 
// System.out.println("Doing a call with key as = " + str); => should give me A.B.C 
// Split again 
// System.out.println("Doing a call with key as = " + str); => should give me A.B 
// this should go in loop till we reach the level 
} 

क्या यह जावा 8 में किया जा सकता है?

Answer 1

यहाँ जावा-8 समाधान है:

static void getResponse(String input, int level) { 
    Stream.iterate(input, str -> { 
     int pos = str.lastIndexOf('.'); 
     return pos == -1 ? "" : str.substring(0, pos); 
    }).limit(level+1).forEach(System.out::println); 
} 

आप यह सुनिश्चित करें कि के लिए पता है स्तर डी की संख्या से अधिक नहीं है , Arrays.copyOfRange() (अंतिम अक्षर हटाने के लिए),

static void getResponseUnsafe(String input, int level) { 
    Stream.iterate(input, str -> str.substring(0, str.lastIndexOf('.'))) 
      .limit(level + 1).forEach(System.out::println); 
} 

Answer 2

नोट: जावा 8

का उपयोग कर हल करने नहीं

public class StringLoop { 

    public static void main(String[] args) { 

     getResponse("A.B.C.D", 2); 

     System.out.println(); 
     getResponse("A.B.C.D", 3); 

    } 

    // Recursive function 
    private static void getResponse (String str, int level) { 

     if(level < 0 || str.equals("")) 
      return; 

     // Prints out the current string 
     System.out.println(str); 

     int lastIndex = str.lastIndexOf("."); 
     if(lastIndex == - 1) 
      lastIndex = 0; 

     // Remove content after last connector 
     // Decrement level 
     getResponse(str.substring(0, lastIndex), level - 1); 
    } 
} 

आउटपुट:

A.B.C.D 
A.B.C 
A.B 

A.B.C.D 
A.B.C 
A.B 
A 

Answer 3

आपकी टिप्पणी split() का उपयोग कर का उल्लेख है, इसलिए यहाँ split() का उपयोग करने का एक उदाहरण है और String.Join()Arrays.copyOfRange() का परिणाम के लिए वापस एक साथ रख रहे हैं: ओ टी एस, आप चेक को छोड़ सकते हैं अगली रिकर्सिव कॉल

public static void main(String[] args) { 
    String string = "A.B.C.D"; 
    getResponse(string, 3); 
    System.out.println(); 

    getResponse(string, 2); 
    System.out.println(); 

    getResponse(string, 1); 
    System.out.println(); 
} 

private static void getResponse(String str, int level) { 
    if (level < 0 || str.isEmpty()) 
     return; 

    System.out.println(str); 

    String[] strPieces = str.split("\\."); 
    if (strPieces.length > level) { 
     getResponse(String.join(".", Arrays.copyOfRange(strPieces, 0, strPieces.length - 1)), level - 1); 
    } 
} 

परिणाम:

A.B.C.D 
A.B.C 
A.B 
A 

A.B.C.D 
A.B.C 
A.B 

A.B.C.D 
A.B.C 

Answer 4

कोई पाशन, आवश्यक है के बाद से स्ट्रिंग एक भी String.split कॉल में एक सरणी में विभाजित किया जा सकता है। (ध्यान दें कि String.split एक रेगेक्स लेता है।) "स्तर" को संभालने के लिए, बस इसे विभाजन की सरणी की लंबाई से घटाएं। इसके बजाय सरणी subrange, कॉपी करने के लिए एक सूची और उपयोग subList() में परिवर्तित:

String getResponse(String str, int level) { 
    String[] splits = str.split("\\."); 
    if (level < 0 || level > splits.length) { 
     throw new IllegalArgumentException(); 
    } 
    return String.join(".", Arrays.asList(splits).subList(0, splits.length - level)); 
} 

for (int level = 0; level < 5; level++) { 
     System.out.printf("level %d: %s%n", level, getResponse("A.B.C.D", level)); 
    } 

के उत्पादन में किया जाएगा

level 0: A.B.C.D 
level 1: A.B.C 
level 2: A.B 
level 3: A 
level 4: 

ध्यान दें कि यह जावा की आवश्यकता होती है 8 क्योंकि इसे String.join() की आवश्यकता है। (लेकिन यह धाराओं या यहाँ तक कि lambdas की आवश्यकता नहीं है!)

Answer 5

आप केवल परिणाम String में रुचि रखते हैं, वहाँ कई भागों में मध्यवर्ती String रों है और न ही बंटवारे बनाने के लिए सिर्फ उन्हें एक साथ बाद में हमले के लिए कोई जरूरत नहीं है।बस String भीतर मिलान सूचकांक से अधिक पुनरावृति और एक परिणाम String बनाएँ:

static String getResponse(String str, int level) { 
    for(int index=str.length(); index>0; index=str.lastIndexOf('.', index-1)) 
     if(level-- == 0) return str.substring(0, index); 
    if(level==0) return ""; 
    throw new IllegalArgumentException(str+" has not enough dots"); 
} 

यह किसी भी जावा 8 सुविधा का उपयोग नहीं करता है लेकिन यह भी कल्पना करने के लिए कैसे जावा 8 सुविधाओं इस सरल ऑपरेशन में सुधार हो सकता मुश्किल है ...