क्या जावा में सूचियों को संभालने का कोई और शानदार तरीका है? (पायथन वीएस जावा)

Question

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

def permutation_recursion(numbers,sol): 
    if not numbers: 
     print "this is a permutation", sol 
    for i in range(len(numbers)): 
     permutation_recursion(numbers[:i] + numbers[i+1:], sol + [numbers[i]]) 

def get_permutations(numbers): 
    permutation_recursion(numbers,list()) 

if __name__ == "__main__": 
    get_permutations([1,2,3]) 

मैं जिस तरह से पसंद करते हैं मैं कर सकते हैं सरल numbers[:i] + numbers[i+1:] या sol + [numbers[i]] तरह बातें कर रही द्वारा संशोधित सूचियों के नए उदाहरणों मिल

import java.util.ArrayList; 
import java.util.Arrays; 

class rec { 
    static void permutation_recursion(ArrayList<Integer> numbers, ArrayList<Integer> sol) { 
     if (numbers.size() == 0) 
      System.out.println("permutation="+Arrays.toString(sol.toArray())); 
     for(int i=0;i<numbers.size();i++) { 
      int n = numbers.get(i); 

      ArrayList<Integer> remaining = new ArrayList<Integer>(numbers); 
      remaining.remove(i); 

      ArrayList<Integer> sol_rec = new ArrayList<Integer>(sol); 
      sol_rec.add(n); 

      permutation_recursion(remaining,sol_rec); 
     } 
    } 
    static void get_permutation(ArrayList<Integer> numbers) { 
     permutation_recursion(numbers,new ArrayList<Integer>()); 
    } 
    public static void main(String args[]) { 
     Integer[] numbers = {1,2,3}; 
     get_permutation(new ArrayList<Integer>(Arrays.asList(numbers))); 
    } 
} 

ही प्रत्यावर्तन मैं क्या करने की जरूरत बनाने के लिए::

अगर मैं वास्तव में जावा में एक ही कोड करने के लिए प्रयास करते हैं, यह कैसा दिखता

ArrayList<Integer> remaining = new ArrayList<Integer>(numbers); 
remaining.remove(i); 

ArrayList<Integer> sol_rec = new ArrayList<Integer>(sol); 
sol_rec.add(n); 

जो काफी बदसूरत है और यह अधिक जटिल समाधानों के लिए और भी बदतर हो जाता है। this example

तो मेरा सवाल है ... क्या जावा एपीआई में कोई भी खरीदार ऑपरेटर या सहायक कार्य है जो इस समाधान को और अधिक "पायथनिक" बना देगा?

Answer 1

सं

लेकिन यह क्यों मार्टिन ओडर्स्की Scala बनाई गई है। उन्होंने यह भी कहा है कि स्कैला के लिए उनके लक्ष्यों में से एक यह है कि यह जावा दुनिया का पाइथन है। स्कैला जावा बाइटकोड में संकलित करता है और आसानी से जावा संकलित कक्षाओं के साथ interops।

यदि यह कोई विकल्प नहीं है, तो आप Commons Collection Library पर एक नज़र डाल सकते हैं।

Answer 2

आप उनकी उथली प्रति प्राप्त करने के लिए सूचियों पर clone() फ़ंक्शन का उपयोग कर सकते हैं। इस तरह आपको खुद को एक नया ऑब्जेक्ट तुरंत चालू नहीं करना पड़ेगा लेकिन कॉपी का उपयोग कर सकते हैं।

ArrayList<Integer> remaining = remaining.clone().remove(i); 

इसके अलावा, जावा के पास सूची के लिए ऐसे ऑपरेटर नहीं हैं।

Answer 3

हाय 1 आप ढेर का उपयोग कर सकते हैं, जो अधिक आसान होगा।

2 पाश के लिए इस तरह लिखा जा सकता है: (संख्या n: नंबर) के लिए

Answer 4

अपाचे कॉमन्स इस प्रकार की समस्याएं का एक बहुत हल करती है। स्लाइसिंग करने के लिए ArrayUtils पर एक नज़र डालें। जावा में कई कारणों से स्क्रिप्टिंग भाषाएं जैसी सिंटैक्टिक चीनी नहीं होती है।

Answer 5

विभिन्न भाषाओं को विभिन्न शैलियों की आवश्यकता होती है। जावा में mylist[:i] + mylist[i+1:] को पूरा करने का प्रयास करना एक स्क्रू के साथ हथौड़ा का उपयोग करना है। हाँ, आप इसे कर सकते हैं, लेकिन यह बहुत साफ नहीं है। मेरा मानना ​​है कि समकक्ष ArrayList temp = new ArrayList(list); temp.remove(index);

मेरा मानना ​​है कि निम्नलिखित एक ही कार्य पूरा करते हैं, लेकिन यह थोड़ा अलग फैशन में करता है, लेकिन पठनीयता समस्याओं को पीड़ित नहीं करता है। एक नई सूची बनाने के बजाय, यह सूची को संशोधित करता है, इसे पास करता है, और जब रिकर्सिव कॉल रिटर्न देता है तो सूची को पिछले राज्य में वापस कर देता है।

import java.util.Arrays; 
import java.util.List; 
import java.util.ArrayList; 

public class Permutation { 

    public static void main(String[] args) { 

     List<List<Integer>> result = permutations(
             Arrays.asList( 
              new Integer[] {1,2,3})); 

     for (List<Integer> permutation : result) { 
     System.out.println(permutation); 
     } 
    } 


    public static <T> List<List<T>> permutations(List<T> input) { 
     List<List<T>> out = new ArrayList<List<T>>(); 
     permutationsSlave(input, new ArrayList<T>(), out); 
     return out; 
    } 

    public static <T> void permutationsSlave(List<T> input, 
      ArrayList<T> permutation, List<List<T>> result) { 

     if (input.size() == chosen.size()) { 
     result.add(new ArrayList<T>(permutation)); 
     return; 
     } 

     for (T obj : input) { 
     if (!permutation.contains(obj)) { 
      permutation.add(obj); 
      permutationsSlave(input, permutation, result); 
      permutation.remove(permutation.size()-1); 
     } 
     } 

    } 
} 

अजगर रास्ता आसान और क्लीनर लग सकते हैं, लेकिन साफ ​​देखने के लिए क्षमता अक्सर तथ्य यह है कि समाधान बहुत अक्षम है (प्रत्यावर्तन के प्रत्येक स्तर के लिए यह 5 नई सूचियों बनाता है) छुपाता है।

लेकिन फिर मेरा स्वयं का समाधान या तो बहुत कुशल नहीं है - कई नई वस्तुओं को बनाने के बजाय यह अनावश्यक तुलना करता है (हालांकि इनमें से कुछ को जमाकर्ताओं के उपयोग से कम किया जा सकता है)।