প্রথমে সাধারণ ক্ষেত্রে: কোনও সংগ্রহের কিছু উপাদান একটি নির্দিষ্ট শর্ত পূরণ করে কিনা তা পরীক্ষা করতে পতাকা ব্যবহার করা অস্বাভাবিক নয়। তবে এটি সমাধান করার জন্য আমি যে প্যাটার্নটি বেশিরভাগ ক্ষেত্রে দেখেছি তা হ'ল চেকটি একটি অতিরিক্ত পদ্ধতিতে সরানো এবং সরাসরি এখান থেকে ফিরে আসা (যেমন তার উত্তরটিতে বর্ণিত কিলিয়ান ফথ ):
private <T> boolean checkCollection(Collection<T> collection)
{
for (T element : collection)
if (checkElement(element))
return true;
return false;
}
জাভা 8-এর পর থেকে আরও বেশি সংক্ষিপ্ততর উপায় রয়েছে Stream.anyMatch(…):
collection.stream().anyMatch(this::checkElement);
আপনার ক্ষেত্রে এটি সম্ভবত এটির মতো দেখাবে ( list == entry.getValue()আপনার প্রশ্নের ধারণা ধরে ):
map.values().stream().anyMatch(list -> list.size() > limit);
আপনার নির্দিষ্ট উদাহরণটিতে সমস্যাটি অতিরিক্ত কল fillUpList()। এই পদ্ধতিটি কী করার কথা রয়েছে তার উত্তর অনেকটাই নির্ভর করে।
পার্শ্ব দ্রষ্টব্য: এটি যেমন দাঁড়িয়েছে, fillUpList()তেমন কলটি তেমন কোনও অর্থবোধ করে না, কারণ এটি বর্তমানে আপনি যে উপাদানটি পুনরাবৃত্তি করছেন তার উপর নির্ভর করে না। আমি অনুমান করি যে এটি আপনার প্রকৃত কোডটি প্রশ্নের ফর্ম্যাটের সাথে মানিয়ে নেওয়ার ফলাফল। তবে ঠিক এটি একটি কৃত্রিম উদাহরণের দিকে নিয়ে যায় যা ব্যাখ্যা করা কঠিন এবং এইরকম যুক্তিযুক্ত হওয়া শক্ত। সুতরাং একটি ন্যূনতম, সম্পূর্ণ এবং যাচাইযোগ্য উদাহরণ প্রদান করা এত গুরুত্বপূর্ণ ।
সুতরাং আমি ধরে নিই যে আসল কোডটি বর্তমানটিতে entryপদ্ধতিটি পাস করে ।
তবে আরও জিজ্ঞাসা করার জন্য আরও প্রশ্ন রয়েছে:
- এই কোডে পৌঁছানোর আগে মানচিত্রের তালিকাগুলি কি খালি আছে? যদি তা হয় তবে কেন ইতিমধ্যে একটি মানচিত্র রয়েছে এবং কেবল
BigIntegerকীগুলির তালিকা বা সেট নয় ? যদি সেগুলি খালি না থাকে তবে আপনাকে তালিকাগুলি পূরণ করার দরকার কেন ? যখন তালিকায় ইতিমধ্যে উপাদান রয়েছে, তখন এটি কোনও আপডেট বা এই ক্ষেত্রে কোনও অন্য গণনা নয়?
- সীমা ছাড়িয়ে একটি তালিকা বড় হওয়ার কারণ কী? এটি কি একটি ত্রুটিযুক্ত অবস্থা বা প্রায়শই ঘটবে বলে আশা করা যায়? এটি কি অবৈধ ইনপুট দ্বারা সৃষ্ট?
- আপনি কি সীমা থেকে বৃহত্তর একটি তালিকায় পৌঁছেছেন এমন বিন্দু পর্যন্ত তালিকাগুলি গণনা করতে হবে?
- " কিছু করুন " অংশটি কী করে?
- আপনি কি এই অংশের পরে ফিলিং পুনরায় চালু করবেন?
কোডের খণ্ডটি বোঝার চেষ্টা করার সময় এটি কেবল আমার মনে আসে questions সুতরাং, আমার মতে, এটিই আসল কোডের গন্ধ : আপনার কোডটি স্পষ্টভাবে অভিপ্রায়টি যোগাযোগ করে না।
এটি হয় এর অর্থ হতে পারে ("সমস্ত কিছু বা কিছুই নয়" এবং সীমাতে পৌঁছানো ত্রুটি নির্দেশ করে):
/**
* Computes the list of all foo strings for each passed number.
*
* @param numbers the numbers to process. Must not be {@code null}.
* @return all foo strings for each passed number. Never {@code null}.
* @throws InvalidArgumentException if any number produces a list that is too long.
*/
public Map<BigInteger, List<String>> computeFoos(Set<BigInteger> numbers)
throws InvalidArgumentException
{
if (numbers.isEmpty())
{
// Do you actually need to log this here?
// The caller might know better what to do in this case...
logger.info("Nothing to compute");
}
return numbers.stream().collect(Collectors.toMap(
number -> number,
number -> computeListForNumber(number)));
}
private List<String> computeListForNumber(BigInteger number)
throws InvalidArgumentException
{
// compute the list and throw an exception if the limit is exceeded.
}
বা এর অর্থ এটি হতে পারে ("প্রথম সমস্যা হওয়া পর্যন্ত আপডেট করুন"):
/**
* Refreshes all foo lists after they have become invalid because of bar.
*
* @param map the numbers with all their current values.
* The values in this map will be modified.
* Must not be {@code null}.
* @throws InvalidArgumentException if any new foo list would become too long.
* Some other lists may have already been updated.
*/
public void updateFoos(Map<BigInteger, List<String>> map)
throws InvalidArgumentException
{
map.replaceAll(this::computeUpdatedList);
}
private List<String> computeUpdatedList(
BigInteger number, List<String> currentValues)
throws InvalidArgumentException
{
// compute the new list and throw an exception if the limit is exceeded.
}
অথবা এটি ("সমস্ত তালিকা আপডেট করুন তবে এটি যদি খুব বড় হয়ে যায় তবে মূল তালিকাটি রাখুন"):
/**
* Refreshes all foo lists after they have become invalid because of bar.
* Lists that would become too large will not be updated.
*
* @param map the numbers with all their current values.
* The values in this map will be modified.
* Must not be {@code null}.
* @return {@code true} if all updates have been successful,
* {@code false} if one or more elements have been skipped
* because the foo list size limit has been reached.
*/
public boolean updateFoos(Map<BigInteger, List<String>> map)
{
boolean allUpdatesSuccessful = true;
for (Entry<BigInteger, List<String>> entry : map.entrySet())
{
List<String> newList = computeListForNumber(entry.getKey());
if (newList.size() > limit)
allUpdatesSuccessful = false;
else
entry.setValue(newList);
}
return allUpdatesSuccessful;
}
private List<String> computeListForNumber(BigInteger number)
{
// compute the new list
}
অথবা এমনকি নিম্নলিখিতগুলি ( computeFoos(…)প্রথম উদাহরণ থেকে তবে ব্যতীত ব্যবহার করে ):
/**
* Processes the passed numbers. An optimized algorithm will be used if any number
* produces a foo list of a size that justifies the additional overhead.
*
* @param numbers the numbers to process. Must not be {@code null}.
*/
public void process(Collection<BigInteger> numbers)
{
Map<BigInteger, List<String>> map = computeFoos(numbers);
if (isLimitReached(map))
processLarge(map);
else
processSmall(map);
}
private boolean isLimitReached(Map<BigInteger, List<String>> map)
{
return map.values().stream().anyMatch(list -> list.size() > limit);
}
বা এর অর্থ সম্পূর্ণ আলাদা কিছু হতে পারে… ;-)