জাভা 8 লাম্বদা পেতে এবং তালিকা থেকে উপাদান সরান

Question 1

উপাদানের একটি তালিকা দেওয়া, আমি একটি প্রদত্ত সম্পত্তি সহ উপাদানটি পেতে এবং এটি তালিকা থেকে মুছে ফেলতে চাই। সবচেয়ে ভাল সমাধান আমি খুঁজে পেয়েছি:

ProducerDTO p = producersProcedureActive
                .stream()
                .filter(producer -> producer.getPod().equals(pod))
                .findFirst()
                .get();
producersProcedureActive.remove(p);

ল্যাম্বডা এক্সপ্রেশনে একত্রিত হওয়া এবং সরানো কি সম্ভব?

Question 2

তালিকা থেকে উপাদান সরান

objectA.removeIf(x -> conditions);

যেমন:

objectA.removeIf(x -> blockedWorkerIds.contains(x));

List<String> str1 = new ArrayList<String>();
str1.add("A");
str1.add("B");
str1.add("C");
str1.add("D");

List<String> str2 = new ArrayList<String>();
str2.add("D");
str2.add("E");

str1.removeIf(x -> str2.contains(x)); 

str1.forEach(System.out::println);

আউটপুট: এ বি সি

Question 3

যদিও থ্রেডটি বেশ পুরানো, তবুও সমাধান দেওয়ার - ব্যবহারের চিন্তাভাবনা করেছে Java8।

removeIfফাংশন ব্যবহার করুন । সময় জটিলতা হয়O(n)

producersProcedureActive.removeIf(producer -> producer.getPod().equals(pod));

এপিআই রেফারেন্স: ডক্স সরান

অনুমান: producersProcedureActiveকList

দ্রষ্টব্য: এই পদ্ধতির সাহায্যে আপনি মুছে ফেলা আইটেমটি ধরে রাখতে পারবেন না।

Question 4

কাজটি সম্পাদন করতে ভ্যানিলা জাভা পুনরায় ব্যবহার করার বিষয়টি বিবেচনা করুন:

public static <T> T findAndRemoveFirst(Iterable<? extends T> collection, Predicate<? super T> test) {
    T value = null;
    for (Iterator<? extends T> it = collection.iterator(); it.hasNext();)
        if (test.test(value = it.next())) {
            it.remove();
            return value;
        }
    return null;
}

সুবিধা :

এটা সহজ এবং সুস্পষ্ট।
এটি কেবল একবারে এবং কেবলমাত্র ম্যাচের উপাদান পর্যন্ত চলে।
আপনি সমর্থন Iterableছাড়াই যেকোনও ক্ষেত্রে এটি করতে পারেন (কমপক্ষে যারা তাদের পুনরুক্তিতে প্রয়োগ করছেন) ।stream()remove()

অসুবিধাগুলি :

আপনি এটি একক অভিব্যক্তি হিসাবে জায়গায় করতে পারবেন না (সহায়ক পদ্ধতি বা ভেরিয়েবল প্রয়োজনীয়)

জন্য

ল্যাম্বডা এক্সপ্রেশনে একত্রিত হওয়া এবং সরানো কি সম্ভব?

অন্যান্য উত্তরগুলি পরিষ্কারভাবে দেখায় যে এটি সম্ভব, তবে আপনার সচেতন হওয়া উচিত

অনুসন্ধান এবং অপসারণ এই তালিকাটিকে দুইবার অতিক্রম করতে পারে
ConcurrentModificationException তালিকা থেকে উপাদানটি পুনরাবৃত্ত হওয়ার সময় নিক্ষেপ করা হতে পারে

Question 5

সরাসরি সমাধান ডাকা হবে ifPresent(consumer)ঐচ্ছিক দ্বারা ফিরে findFirst()। Consumerচ্ছিক খালি না হলে এই গ্রাহককে ডাকা হবে। সুবিধাটিও হ'ল এটি যদি সন্ধানী ক্রিয়াকলাপটি আপনার বর্তমান কোডের মতো খালি alচ্ছিকভাবে ফিরে আসে তবে এটি ব্যতিক্রম করবে না; পরিবর্তে, কিছুই ঘটবে না।

আপনি সরানো মান ফেরত পাঠাতে চান, আপনি যা করতে পারেন কলিং ফলাফলের সাথে প্রাসঙ্গিক :mapOptionalremove

producersProcedureActive.stream()
                        .filter(producer -> producer.getPod().equals(pod))
                        .findFirst()
                        .map(p -> {
                            producersProcedureActive.remove(p);
                            return p;
                        });

তবে নোট করুন যে remove(Object)অপারেশনটি আবার সরানোর জন্য উপাদানটি সন্ধানের জন্য তালিকাটিকে অতিক্রম করবে। যদি আপনার মতো এলোমেলো অ্যাক্সেসের সাথে একটি তালিকা ArrayListথাকে তবে তালিকার সূচীগুলির উপরে একটি স্ট্রিম তৈরি করা ভাল এবং ভালির সাথে প্রথম সূচকটি খুঁজে পাওয়া ভাল:

IntStream.range(0, producersProcedureActive.size())
         .filter(i -> producersProcedureActive.get(i).getPod().equals(pod))
         .boxed()
         .findFirst()
         .map(i -> producersProcedureActive.remove((int) i));

এই সমাধানের সাথে, remove(int)অপারেশন সরাসরি সূচকগুলিতে পরিচালনা করে।

Question 6

ব্যবহার জাভা 8 এর ফিল্টার ব্যবহার করতে পারে এবং আপনি যদি পুরানো তালিকাটি পরিবর্তন করতে না চান তবে অন্য তালিকা তৈরি করতে পারেন:

List<ProducerDTO> result = producersProcedureActive
                            .stream()
                            .filter(producer -> producer.getPod().equals(pod))
                            .collect(Collectors.toList());

Question 7

আমি নিশ্চিত এটি একটি অপ্রিয় উত্তর হবে, তবে এটি কার্যকর ...

ProducerDTO[] p = new ProducerDTO[1];
producersProcedureActive
            .stream()
            .filter(producer -> producer.getPod().equals(pod))
            .findFirst()
            .ifPresent(producer -> {producersProcedureActive.remove(producer); p[0] = producer;}

p[0] হয় পাওয়া উপাদানটিকে ধরে রাখবে বা নাল হবে।

এখানে "কৌতুক" কার্যকরভাবে চূড়ান্ত, তবে এর প্রথম উপাদানটি সেট করে এমন অ্যারে রেফারেন্স ব্যবহার করে "কার্যকরভাবে চূড়ান্ত" সমস্যাটি সমাধান করছে।

Question 8

সঙ্গে অন্ধকার সংগ্রহগুলি আপনি ব্যবহার করতে পারেন detectIndexসহ remove(int)কোনো java.util.List উপর।

List<Integer> integers = Lists.mutable.with(1, 2, 3, 4, 5);
int index = Iterate.detectIndex(integers, i -> i > 2);
if (index > -1) {
    integers.remove(index);
}

Assert.assertEquals(Lists.mutable.with(1, 2, 4, 5), integers);

আপনি যদি MutableListগ্রহগ্রাহ সংগ্রহ থেকে প্রকারটি ব্যবহার করেন তবে আপনি detectIndexসরাসরি তালিকায় পদ্ধতিটি কল করতে পারেন ।

MutableList<Integer> integers = Lists.mutable.with(1, 2, 3, 4, 5);
int index = integers.detectIndex(i -> i > 2);
if (index > -1) {
    integers.remove(index);
}

Assert.assertEquals(Lists.mutable.with(1, 2, 4, 5), integers);

দ্রষ্টব্য: আমি গ্রহগ্রাহ সংগ্রহের প্রতিশ্রুতিবদ্ধ

Question 9

যখন আমরা একটি তালিকা থেকে একাধিক উপাদানকে একটি নতুন তালিকায় আনতে চাই (প্রিডিকেট ব্যবহার করে ফিল্টার) এবং সেগুলি বিদ্যমান তালিকা থেকে সরিয়ে ফেলি চাই, আমি কোথাও এর সঠিক উত্তর খুঁজে পাইনি।

জাভা স্ট্রিমিং এপিআই পার্টিশন ব্যবহার করে আমরা এটি কীভাবে করতে পারি তা এখানে।

Map<Boolean, List<ProducerDTO>> classifiedElements = producersProcedureActive
    .stream()
    .collect(Collectors.partitioningBy(producer -> producer.getPod().equals(pod)));

// get two new lists 
List<ProducerDTO> matching = classifiedElements.get(true);
List<ProducerDTO> nonMatching = classifiedElements.get(false);

// OR get non-matching elements to the existing list
producersProcedureActive = classifiedElements.get(false);

এই ভাবে আপনি কার্যকর তালিকা থেকে ফিল্টার করা উপাদানগুলি কার্যকর তালিকা থেকে সরান এবং তাদের একটি নতুন তালিকায় যুক্ত করুন।

পড়ুন 5.2। Collectors.partitioningBy বিভাগে এই নিবন্ধটি ।

Question 10

অন্যরা যেমন পরামর্শ দিয়েছে, এটি লুপ এবং পুনরাবৃত্তির ক্ষেত্রে ব্যবহারের ক্ষেত্রে হতে পারে। আমার মতে, এটি সহজতম পদ্ধতির। আপনি যদি তালিকায় স্থান পরিবর্তন করতে চান তবে এটি কোনওভাবেই "আসল" ফাংশনাল প্রোগ্রামিং হিসাবে বিবেচনা করা যায় না। তবে আপনি Collectors.partitioningBy()আপনার শর্ত পূরণ করে এমন উপাদানগুলির সাথে একটি নতুন তালিকা এবং যা না দেয় তাদের একটি নতুন তালিকা পাওয়ার জন্য আপনি ব্যবহার করতে পারেন । অবশ্যই এই পদ্ধতির সাথে, আপনার যদি শর্তটি সন্তুষ্টকারী একাধিক উপাদান থাকে তবে সেগুলি সমস্তই তালিকায় থাকবে এবং কেবল প্রথম নয়।

Question 11

নীচের যুক্তিটি মূল তালিকাটি পরিবর্তন না করেই সমাধান

List<String> str1 = new ArrayList<String>();
str1.add("A");
str1.add("B");
str1.add("C");
str1.add("D");

List<String> str2 = new ArrayList<String>();
str2.add("D");
str2.add("E");

List<String> str3 = str1.stream()
                        .filter(item -> !str2.contains(item))
                        .collect(Collectors.toList());

str1 // ["A", "B", "C", "D"]
str2 // ["D", "E"]
str3 // ["A", "B", "C"]

Question 12

আমার প্রাথমিক ধারণা এবং আপনার উত্তরগুলির সংমিশ্রণে আমি পৌঁছেছি যা আমার নিজের প্রশ্নের সমাধান বলে মনে হচ্ছে:

public ProducerDTO findAndRemove(String pod) {
    ProducerDTO p = null;
    try {
        p = IntStream.range(0, producersProcedureActive.size())
             .filter(i -> producersProcedureActive.get(i).getPod().equals(pod))
             .boxed()
             .findFirst()
             .map(i -> producersProcedureActive.remove((int)i))
             .get();
        logger.debug(p);
    } catch (NoSuchElementException e) {
        logger.error("No producer found with POD [" + pod + "]");
    }
    return p;
}

এটি সেই বস্তুটি ব্যবহার করে সরিয়ে ফেলতে দেয় remove(int)যা পুনরায় তালিকায় প্রবেশ করবে না (@ টুনাকির পরামর্শ অনুসারে) এবং এটি মুছে ফেলা বস্তুকে ফাংশন ফিরিয়ে দেয়।

আমি আপনার উত্তরগুলি পড়েছি যা আমাকে ifPresentতার পরিবর্তে নিরাপদ পদ্ধতি বেছে নেওয়ার পরামর্শ দেয়get তবে আমি এই দৃশ্যে সেগুলি ব্যবহারের কোনও উপায় পাই না।

এই জাতীয় সমাধানের ক্ষেত্রে কোনও গুরুত্বপূর্ণ ত্রুটি রয়েছে?

হোলার পরামর্শ অনুসরণ করে সম্পাদনা করুন

এটি আমার প্রয়োজন ফাংশন হওয়া উচিত

public ProducerDTO findAndRemove(String pod) {
    return IntStream.range(0, producersProcedureActive.size())
            .filter(i -> producersProcedureActive.get(i).getPod().equals(pod))      
            .boxed()                                                                
            .findFirst()
            .map(i -> producersProcedureActive.remove((int)i))
            .orElseGet(() -> {
                logger.error("No producer found with POD [" + pod + "]"); 
                return null; 
            });
}

Question 13

কাজটি হ'ল: ✶ এবং ✶ উপাদানটি তালিকা থেকে সরান

p.stream().collect( Collectors.collectingAndThen( Collector.of(
    ArrayDeque::new,
    (a, producer) -> {
      if( producer.getPod().equals( pod ) )
        a.addLast( producer );
    },
    (a1, a2) -> {
      return( a1 );
    },
    rslt -> rslt.pollFirst()
  ),
  (e) -> {
    if( e != null )
      p.remove( e );  // remove
    return( e );    // get
  } ) );