प्राचीन प्रकार के साथ काम करते समय पुनरावृत्ति से कैसे बचें?

Question

मुझे विभिन्न आदिम प्रकारों पर एल्गोरिदम करने की आवश्यकता है; एल्गोरिदम अनिवार्य रूप से वही है जो चर के प्रकार के अपवाद के साथ समान है। तो उदाहरण के लिए,

/** 
* Determine if <code>value</code> is the bitwise OR of elements of <code>validValues</code> array. 
* For instance, our valid choices are 0001, 0010, and 1000. 
* We are given a value of 1001. This is valid because it can be made from 
* ORing together 0001 and 1000. 
* On the other hand, if we are given a value of 1111, this is invalid because 
* you cannot turn on the second bit from left by ORing together those 3 
* valid values. 
*/ 
public static boolean isValid(long value, long[] validValues) { 
    for (long validOption : validValues) { 
     value &= ~validOption; 
    } 
    return value == 0; 
} 

public static boolean isValid(int value, int[] validValues) { 
    for (int validOption : validValues) { 
     value &= ~validOption; 
    } 
    return value == 0; 
} 

मैं इस पुनरावृत्ति से कैसे बच सकता हूं? मुझे पता है कि आदिम सरणी उत्पन्न करने का कोई तरीका नहीं है, इसलिए मेरे हाथ बंधे हुए लगते हैं। मेरे पास आदिम सरणी के उदाहरण हैं और नंबर ऑब्जेक्ट्स के बॉक्स किए गए सरणी नहीं हैं, इसलिए मैं उस मार्ग को भी नहीं जाना चाहता हूं।

मुझे पता है कि एरे, ऑटोबॉक्सिंग इत्यादि के संबंध में प्राइमेटिव के बारे में बहुत सारे प्रश्न हैं, लेकिन मैंने इसे इस तरह से तैयार नहीं देखा है, और मैंने बातचीत करने के तरीके पर निर्णायक उत्तर नहीं देखा है इन सरणी के साथ।

मैं मैं की तरह कुछ कर सकता है लगता है:

public static<E extends Number> boolean isValid(E value, List<E> numbers) { 
    long theValue = value.longValue(); 
    for (Number validOption : numbers) { 
     theValue &= ~validOption.longValue(); 
    } 
    return theValue == 0; 
} 

और फिर

public static boolean isValid(long value, long[] validValues) { 
    return isValid(value, Arrays.asList(ArrayUtils.toObject(validValues))); 
} 

public static boolean isValid(int value, int[] validValues) { 
    return isValid(value, Arrays.asList(ArrayUtils.toObject(validValues))); 
} 

कि हालांकि वास्तव में काफी बेहतर है? इस तरह मूल कार्यान्वयन की तुलना में बहुत अधिक वस्तुएं पैदा होंगी, हालांकि यह स्रोत कोड को डीआरवाई करता है। इस मामले में किसी भी विचार की सराहना की जाएगी।

Answer 1

मैंने पहले (Managing highly repetitive code and documentation in Java) एक समान प्रश्न पूछा, और कहा कि java.util.Arrays के लिए स्रोत कोड आदिम सरणी प्रकार से निपटने के लिए अत्यधिक अपने एल्गोरिदम में दोहराव है।

सात आदिम प्रकार से प्रत्येक के लिए कोड काफी हद तक समान होता है:

वास्तव में, स्रोत कोड इस टिप्पणी में शामिल है। C'est ला vie।

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

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

import java.lang.reflect.Array; 

static long maskFor(Class<?> c) { 
    return (
     c.equals(int.class) ? 1L << Integer.SIZE : 
     c.equals(short.class) ? 1L << Short.SIZE : 
     c.equals(byte.class) ? 1L << Byte.SIZE : 
     0 
    ) - 1; 
} 
public static void reflectPrimitiveNumericArray(Object arr) throws Exception { 
    int length = Array.getLength(arr); 
    Class<?> componentType = arr.getClass().getComponentType(); 
    long mask = maskFor(componentType); 
    System.out.format("%s[%d] = { ", componentType, length); 
    for (int i = 0; i < length; i++) { 
     long el = Array.getLong(arr, i) & mask; 
     System.out.print(Long.toBinaryString(el) + " "); 
    } 
    System.out.println("}"); 
} 

आप arr के लिए एक int[], साथ ही अन्य आदिम सरणी प्रकार पारित कर सकते हैं। साइन एक्सटेंशन को संबोधित करने के लिए बिट-मास्किंग के साथ, सब कुछ long में डाला गया है।

reflectPrimitiveNumericArray(new byte[] { (byte) 0xF0 }); 
// byte[1] = { 11110000 } 
reflectPrimitiveNumericArray(new int[] { 0xF0F0F0F0 }); 
// int[1] = { 11110000111100001111000011110000 } 
reflectPrimitiveNumericArray(new long[] { 0xF0F0F0F0F0F0F0F0L }); 
// long[1] = { 1111000011110000111100001111000011110000111100001111000011110000 } 

Answer 2

मुझे लगता है कि आप भाग्य से बाहर हैं मुझे डर है - प्राचीन प्रकार से दूर जाने के बिना।

Answer 3

आप java.util.Arrays में देखो, तो आप यह है कि वे एक आदिम प्रकार के लिए अपने सभी एल्गोरिदम (binarySearch, equals, आदि) के विशेषज्ञ करना पड़ा दिखाई देगी।

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

Answer 4

पिछले जीवन में, हम (बेडौल सरणियों और इस तरह का उपयोग कर, स्मृति में आदेश के लाखों लोगों) कुछ आदिम टाइप संग्रह है कि वित्तीय डेटा के लिए अनुकूलित किया गया था। हमारा समाधान कुछ स्टब फाइलों के साथ ट्रोव की तरह था। 'मूल' स्रोत फ़ाइल कहां होगी ... उदाहरण के लिए हैशसेट_की। कुंजी और मूल्य के लिए कुछ ठूंठ वर्गों के साथ, हम एक HashSetInt, HashSetLong, आदि उत्पन्न करने के लिए चींटी कार्य का उपयोग करने का निधि के मॉडल ...

मैं हमेशा सोचा कि यह था एक 'janky' विधि का पालन, लेकिन यह काम किया । मुझे उत्सुकता है कि किसी ने कभी भी वेग, या संभवतः एफएमपीपी की कोशिश की है, और कुछ हल्के क्लीनर परिणाम हैं? चींटी समाधान के साथ मेरी मुख्य समस्या यह है कि सभी कोड एक साथ बहुत करीब रहते हैं, जबकि बहुत से स्रोत कोड पीढ़ी में आप टेम्पलेट फ़ाइलों को बेहतर तरीके से अलग करने में सक्षम हो सकते हैं।