जावा में एक सरणी कैसे फ़िल्टर करें?

Question

मैं जावा में एक सरणी कैसे फ़िल्टर कर सकता हूं?

मैं उदाहरण के कारों के लिए वस्तुओं की एक सरणी है,:

कक्षा:

public class Car{ 
    public int doors; 
    public Car(int d){ 
     this.doors = d; 
    } 
} 

उपयोग:

Car [] cars = new Cars[4]; 
cars[0] = new Car(3); 
cars[1] = new Car(2); 
cars[2] = new Car(4); 
cars[3] = new Car(6); 

अब मैं रखते हुए, कारों की सरणी फ़िल्टर करना चाहते हैं केवल 4 दरवाजे और अधिक:

for(int i = 0; i<cars.length; i++){ 
    if(cars[i].doors > 4) 
     //add cars[i] to a new array 
    } 
} 

मुझे यह कैसे करना चाहिए?

इससे पहले कि मैं एक वेक्टर के साथ यह किया:

Vector subset = new Vector(); 
for(int i = 0; i<cars.length; i++){ 
    if(cars[i].doors > 4) 
     //add cars[i] to a new array 
     subset.addElement(cars[i]); 
    } 
} 

और फिर मैं वेक्टर के आकार के साथ एक नई सरणी होगा। तब मैं फिर से वेक्टर पर लूप लूंगा और नई सरणी भर दूंगा। मुझे पता है कि यह कुछ आसान के लिए एक बहुत बड़ी प्रक्रिया है।

मैं जे 2 एमई का उपयोग कर रहा हूं।

Answer 1

संपादित करें: ने देखा कि ArrayList J2ME में नहीं है, लेकिन दस्तावेज़ीकरण पर आधारित है, इसमें एक वेक्टर है। अगर ऐसा वेक्टर वर्ग J2SE वेक्टर (this documentation indicates के रूप में) से अलग है, तो शायद निम्नलिखित कोड काम करेगा:

Vector carList = new Vector(); 
for(int i = 0; i<cars.length; i++){ 
    if(cars[i].doors > 4) 
     carList.addElement(cars[i]); 
    } 
} 
Car[] carArray = new Car[carList.size()]; 
carList.copyInto(carArray); 

Answer 2

आप System.arrayCopy() उपयोग कर सकते हैं:

Car[] cars = ... 
int length = cars.length < 4 ? cars.length() : 4; 
Car filter = new Car[4]; 
System.arrayCopy(cars, 0, filter, 0, length); 

अद्यतन: System.arrayCopy, Vector.subList के विपरीत() Java ME API में उपलब्ध है। सुधारों के लिए धन्यवाद।

Answer 3

मुझे आपके कोड में बहुत कुछ गलत नहीं दिखाई दे रहा है। हालांकि आप पूरे समय वेक्टर के साथ रह सकते हैं।

आप Vector.copyInto (ऑब्जेक्ट []) का उपयोग करके दूसरे भाग को सरल बना सकते हैं (जहां आप मिलान करने वाली वस्तुओं को नई सरणी में कॉपी करते हैं)।

Answer 4

यदि आपको वास्तव में परिणाम के रूप में एक सादे सरणी की आवश्यकता है, तो मुझे लगता है कि आपका रास्ता जाने का तरीका है: आप फ़िल्टर करने से पहले परिणामी तत्वों की संख्या नहीं जानते हैं, और आप बिना किसी जानकारी के एक नया सरणी नहीं बना सकते तत्वों की संख्या।

हालांकि, अगर आप धागे की सुरक्षा की जरूरत नहीं है, एक Vector के बजाय ArrayList उपयोग करने पर विचार। यह कुछ हद तक तेज होना चाहिए। फिर सरणी प्राप्त करने के लिए ArrayList की toArray विधि का उपयोग करें।

Answer 5

एक सरणी से तत्व को दूर करने के लिए कोई सीधा रास्ता नहीं है; इसका आकार तय है। आप जो कुछ भी करते हैं, आपको किसी भी तरह से एक नई सरणी आवंटित करने की आवश्यकता होती है।

यदि आप Vector आवंटित करने के मामूली मेमोरी ओवरहेड से बचना चाहते हैं, तो दूसरा विकल्प आपके सरणी पर दो पास करना होगा। पहली बार, उन तत्वों की संख्या को गिनें जिन्हें आप रखना चाहते हैं। फिर आकार की एक सरणी आवंटित करें, और फिर अपनी पुरानी सरणी पर लूप करें, मिलान तत्वों को नई सरणी में कॉपी करें।

Answer 6

आपको वैसे भी एक नई सरणी बनाने की आवश्यकता होगी।

Vector vector = new Vector(array.length); 

for (int i = 0; i < array.length; i++) { 
    if (array[i].doors > 4) { 
     vector.add(array[i]); 
    } 
} 

Car[] result = new Car[vector.size()]; 
vector.copyInto(result); 

हालांकि यह काफी कुशल नहीं है।

Answer 7

यह करने के लिए सबसे कारगर तरीका है - अगर विधेय आप पर फ़िल्टर कर रहे हैं सस्ती है और आप एक ही धागे से यह तक पहुँच रहे हैं - दो बार सूची पार करने के लिए आमतौर पर है:

public Car[] getFourDoors(Car[] all_cars) { 
    int n = 0; 
    for (Car c : all_cars) if (c.doorCount()==4) n++; 
    Car[] cars_4d = new Car[n]; 
    n = 0; 
    for (Car c : all_cars) if (c.doorCount()==4) cars_4d[n++] = c; 
    return cars_4d; 
} 

यह सूची को दो बार घुमाता है और परीक्षण दो बार कॉल करता है, लेकिन इसमें कोई अतिरिक्त आवंटन या प्रतिलिपि नहीं है। वेक्टर-शैली के तरीके एक बार सूची को पार करते हैं, लेकिन स्मृति की लगभग दोगुनी मेमोरी आवंटित करते हैं (गतिशील रूप से) और हर अच्छे तत्व को दो बार प्रतिलिपि बनाते हैं। तो यदि आप सूची के एक छोटे से हिस्से को फ़िल्टर कर रहे हैं (या प्रदर्शन एक मुद्दा नहीं है, जो अक्सर यह नहीं होता है), तो वेक्टर विधि अच्छी है। अन्यथा, उपरोक्त संस्करण बेहतर प्रदर्शन करता है।