আমি জাভাতে দুটি তালিকায় কীভাবে যোগদান করব?

Question

শর্তাদি: মূল তালিকাটি সংশোধন করবেন না; কেবল জেডিকে, কোনও বাহ্যিক গ্রন্থাগার নেই। ওয়ান-লাইনার বা জেডিকে 1.3 সংস্করণের জন্য বোনাস পয়েন্ট।

এর চেয়ে সহজ উপায় কি?

List<String> newList = new ArrayList<String>();
newList.addAll(listOne);
newList.addAll(listTwo);

Comments

আপনি এই কাজ হয় একমাত্র জন্য পুনরাবৃত্তির উদ্দেশ্যে অপর এক প্রশ্নের দেখুন - সেখানে পেয়ারা এবং জাভা 8 সমাধান google হয় stackoverflow.com/questions/4896662/...

— বরিস Treukhov

জাভা 8 ইউটিলিটি পদ্ধতি সঙ্গে সমাধান: stackoverflow.com/a/37386846/1216775

— akhil_mittal

কিছু উত্তর পড়ার পরে, দুঃখিত আমি জিজ্ঞাসা করেছি।

— অ্যান্টনি রুটলেজ

Answer 1

জাভা 8 তে:

List<String> newList = Stream.concat(listOne.stream(), listTwo.stream())
                             .collect(Collectors.toList());

Comments

গাওদ, এটা জাভা 8-এ একটা জিনিস? প্রযুক্তিগতভাবে আপনি জিতেন আমার ধারণা, তবে এটি একটি দীর্ঘ লাইনের একটি হেক :-)

— রবার্ট অ্যাটকিনস

নৈমিত্তিক পাঠকের জন্য, এখানে জাভা _ স্ট্রিম ব্যবহার করে একটি সংক্ষিপ্ত সমাধান দেওয়া হয়েছে: স্ট্যাকওভারফ্লো.com

— স্টিফান

এটি কুরুচিপূর্ণ তবে কমপক্ষে এর সাবলীল এবং মাল্টি লাইন ল্যাম্বডাস ছাড়া ব্যবহার করা যেতে পারে। আমি সত্যিই চাই যে সেখানে একটি সাবলীল অ্যাডআল থাকত যা সংঘবদ্ধ তালিকাটি ফিরিয়ে দেয়।

— উসমান ইসমাইল

আমি অনুমান করি যে এটি লক্ষ করার মতো যে এটির থেকেও আলাদা আলাদা তালিকা পাওয়া সত্যিই সহজ:List<String> newList = Stream.concat(listOne.stream(), listTwo.stream()).distinct().collect(Collectors.toList());

— রজার

কনকটের বিকল্প: স্রোতের স্রোতStream.of(listOne, listTwo).flatMap(Collection::stream).collect(Collectors.toList())

— পিটার ওয়ালসার

Answer 2

আমার মাথার উপরের অংশটি বন্ধ করে, আমি এটি একটি রেখার দ্বারা সংক্ষিপ্ত করতে পারি:

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Comments

আপনি প্রযুক্তিগতভাবে সঠিক হওয়ার পরে, আপনি এটি এক লাইনের দ্বারা সংক্ষিপ্ত করে রেখেছেন, এটির অসম্পূর্ণতা আমাকে এনে দেয়। অতিরিক্ত লাইনটি "ব্যয়" করতে আমি বেশি খুশি।

— রবার্ট অ্যাটকিনস

এখানে নতুন সমস্যা নেই, যেখানে নতুন তালিকার ইন্টিরিয়াল অ্যারে তালিকার একের আকারে আরম্ভ করা হবে এবং তারপরে তালিকার দুটি থেকে সমস্ত আইটেম যুক্ত করার সময় সম্ভাব্যভাবে প্রসারিত করতে হবে? প্রতিটি তালিকার আকার নেওয়া এবং নতুন অ্যারের আকারের জন্য এটি ব্যবহার করা কি ভাল?

— এরিক

এটি আমার জন্য সবচেয়ে ভাল কাজ করে এমন সমাধান ছিল। আমি বিভিন্ন সমাধানের পারফরম্যান্সের সাথে তুলনা করেছি এটির সাথে বিজয়ী এসেছিল, একসাথে খালি তালিকা তৈরি করার পরে addAll()এবং উভয়েরই। আমি তালিকাটি অনুলিপি না করার পরামর্শ দিয়েছি এমন সমস্তগুলি চেষ্টা করেছিলাম এবং তাদের ফলাফল প্রচুর ওভারহেডে ফেলেছে যা আমাদের এই সময়ের প্রয়োজন নেই need

— ম্যানুয়েলভিগার্চিয়া

দুর্দান্ত তবে আপনি এটি আরও খাটো করে তুলতে পারেন: তালিকা তালিকা = নতুন অ্যারেলিস্ট <> (তালিকা 1) .এডএডএল (তালিকা 2);

— বেগ

@ বেগ: না, এটি কাজ করে না। addAll(Collection)ফেরত a boolean।

— স্টিজন ভ্যান বেল

Answer 3

আপনি অ্যাপাচি কমন্স-সংগ্রহ লাইব্রেরি ব্যবহার করতে পারেন :

List<String> newList = ListUtils.union(list1, list2);

Comments

দুর্দান্ত, তবে অ্যাপাচি কমন্স দরকার। তিনি 'কোনও বাহ্যিক গ্রন্থাগার' নির্দিষ্ট করেন নি

— কোয়ান্টাম 7

@ কোয়ান্টাম 7, এখনও অন্য লোকের জন্য দরকারী;) এছাড়াও, অ্যাপাচি কি বাইরের লাইব্রেরিও কমন্স করে? আমি তা ছাড়া কিছুই শুরু করি না!

— টিস্টার

@ প্ল্যাটিনাম নং, দস্তাবেজ অনুসারে ListUtils.union ওপির কোডের সমান। তবে সম্ভবত একটি তালিকা প্রসঙ্গে SET অপারেশন ("ইউনিয়ন") ব্যবহার করা বিভ্রান্তিকর। আমি দেখতে পাচ্ছি আপনি কীভাবে এটি অনুলিপি বা অন্য কিছু সরিয়ে ফেলতে আশা করতে পারেন তবে এটি প্রদর্শিত হয় যে পদ্ধতিটি এটি করে না।

— কোয়ান্টাম 7

অ্যাপাচি কমন্স সংগ্রহগুলি এড়িয়ে চলুন। এটি টাইপসেফ নয়, জেনারিকস নেই। দুর্দান্ত আপনি যদি জাভা ১.৪ ব্যবহার করেন তবে জাভা ৫ এবং এর থেকে উপরে, আমি গুগল পেয়ারা পছন্দ করবো।

— মাইকেল পাইফেল

@ মিশেলপিফেল সর্বশেষতম অ্যাপাচি কমন্স সংগ্রহ 4 টি টাইপ-সেফ। জাভা 8 পদ্ধতির রেফারেন্সের সাথে, এই জাতীয় স্ট্যাটিক ইউটিলিটিগুলি খুব গুরুত্বপূর্ণ হয়ে ওঠে।

— মিংফাই

Answer 4

আপনার প্রয়োজনীয়তার একটি হ'ল মূল তালিকাগুলি সংরক্ষণ করা। আপনি যদি একটি নতুন তালিকা তৈরি করেন এবং ব্যবহার করেন তবে addAll()আপনি কার্যকরভাবে আপনার তালিকাগুলির মধ্যে উল্লেখগুলির সংখ্যা দ্বিগুণ করছেন। আপনার তালিকাগুলি খুব বড় হলে এটি মেমরির সমস্যার সৃষ্টি করতে পারে।

যদি আপনার সংক্ষিপ্ত ফলাফলটি সংশোধন করার প্রয়োজন না হয় তবে আপনি কাস্টম তালিকা প্রয়োগ করে এটি এড়াতে পারেন can কাস্টম বাস্তবায়ন শ্রেণি এক লাইনের বেশি, স্পষ্টতই ... তবে এটি ব্যবহার করা সংক্ষিপ্ত এবং মিষ্টি।

CompositeUnmodifiableList.java:

public class CompositeUnmodifiableList<E> extends AbstractList<E> {

    private final List<E> list1;
    private final List<E> list2;

    public CompositeUnmodifiableList(List<E> list1, List<E> list2) {
        this.list1 = list1;
        this.list2 = list2;
    }

    @Override
    public E get(int index) {
        if (index < list1.size()) {
            return list1.get(index);
        }
        return list2.get(index-list1.size());
    }

    @Override
    public int size() {
        return list1.size() + list2.size();
    }
}

ব্যবহার:

List<String> newList = new CompositeUnmodifiableList<String>(listOne,listTwo);

Comments

এটিই এই প্রশ্নের আসল উত্তর।

— ওয়াউটার লাইভেন্সস

এটি একটি কার্যক্ষম সমাধান, তবে মনে রাখবেন যে যদি অন্তর্নিহিত তালিকার অবজেক্টগুলি পরিবর্তন হয় (list1, list2), এই তালিকার বিষয়বস্তুগুলি পরিবর্তিত হয়। আপনি নিজেই কম্পোজিটইউনডেফাইফায়াল লিস্টের একটি উদাহরণ সংশোধন করতে পারবেন না তবে আপনি যদি মূল তালিকাগুলির একটি রেফারেন্স পেতে পারেন তবে আপনি পারেন। এছাড়াও অপরিচিতদের জন্য: চূড়ান্ত সংশোধকটি কেবলমাত্র তালিকার অবজেক্টের রেফারেন্সকে প্রভাবিত করে নিজেই পরিবর্তন করতে পারে না তবে তালিকার বিষয়বস্তু পরিবর্তন করা এখনও সম্ভব!

— jwj

@jwj সমস্ত ভাল পয়েন্ট, আপনাকে ধন্যবাদ। ক্লাসের নামটি সম্ভবত কিছু ব্যাখ্যার দাবিদার। আমি এই শ্রেণিটি Collections.unmodifiableList()পদ্ধতির সাথে খুব মিল কিছু করার হিসাবে দেখছি , যা এটি অবিচ্ছেদ্য করতে একটি তালিকা জড়িত । CompositeUnmodifiableListএটি দুটি তালিকাগুলি মোড়ক করে এবং একটি সংক্ষিপ্ত দৃশ্য সরবরাহ করে। একই জিনিসটি করে। আপনি যে সমস্ত পয়েন্টগুলি তৈরি করেন CompositeUnmodifiableListসেগুলিও সত্য Collections.unmodifiableList()।

— কেভিন কে

কনস্ট্রাক্টর নিতে পারেনList<? extends E>

— প্যাট্রিক পার্কার

Answer 5

সম্ভবত সহজ নয়, তবে আগ্রহী এবং কুরুচিপূর্ণ:

List<String> newList = new ArrayList<String>() { { addAll(listOne); addAll(listTwo); } };

এটি প্রোডাকশন কোডে ব্যবহার করবেন না ...;)

Comments

কুরুচিপূর্ণ এবং অশুভ, ডাবল ব্রেস আরম্ভের প্রায় কোনও ব্যবহার যেমন। এটি আরও ছোট, যদিও;)

— জর্ন

@ মার্নিক্সক্লুস্টার: গ্রহনটি জানে যে আপনার এটি ব্যবহার করা উচিত নয় এবং এটি ব্যবহারে অপ্রীতিকর করে তোলে ;-)

— জোচিম সৌর

যদিও এটি শারীরিকভাবে একটি লাইন, আমি এটিকে "ওয়ান-লাইনার" মনে করি না।

— splungebob

লোকেরা কেন বেনামে ব্লক ইনিশিয়ালাইজারগুলি ঘৃণা করে

— নিমচিম্পস্কি

@ নিমচিম্পস্কি আমার মনে হয় এটি বেশিরভাগ কারণ এটি কেবল একটি বেনাম ব্লক ইনিশিয়ালাইজার নয়, আপনি আসলে অ্যারেলিস্টের একটি বেনামে সাবক্লাস তৈরি করছেন। বলা হচ্ছে, আপনি যদি এই ডাবল ব্রেস ইনিশিলাইজেশন প্রশ্নের ফলাফলগুলিতে বিশ্বাস করেন তবে মনে হয় ডিবিআইকে ঘৃণা করা বেশিরভাগ ক্ষেত্রে স্টাইলিস্টিক স্বাদ এবং মাইক্রো-অপ্টিমাইজেশনের বিষয়। আমি যতদূর বলতে পারি, এটি করার জন্য কোনও বড় জরিমানা নেই। আপনি যদি কখনও এর ক্লাসের সাথে তুলনা করার চেষ্টা করেন তবে এই অ্যারেলিস্ট হবে না বলেই হুড়াহুড়ো ক্ষতি হয়।

— প্যাট্রিক

Answer 6

অন্য জাভা 8 ওয়ান-লাইনার:

List<String> newList = Stream.of(listOne, listTwo)
                            .flatMap(Collection::stream)
                            .collect(Collectors.toList());

বোনাস হিসাবে, যেহেতু Stream.of()বৈচিত্র্যময়, আপনি নিজের পছন্দ অনুসারে যতগুলি তালিকার সাথে তাল মিলিয়ে নিতে পারেন।

List<String> newList = Stream.of(listOne, listTwo, listThree)
                            .flatMap(Collection::stream)
                            .collect(Collectors.toList());

Comments

x -> x.stream()সঙ্গে প্রতিস্থাপন করা যেতে পারে Collection::stream।

— মার্টিন

... বা এমনকি সাথে List::stream।

— এমসি সম্রাট

Answer 7

সহজ নয়, তবে ওভারহেডের আকার পরিবর্তন না করে:

List<String> newList = new ArrayList<>(listOne.size() + listTwo.size());
newList.addAll(listOne);
newList.addAll(listTwo);

Answer 8

বাহ্যিক লাইব্রেরিগুলিকে মনে না রেখে, তালিকাগুলির নির্বিচার পরিমাণের সাথে মিল রেখে এই প্রশ্নটি খুঁজে পেয়েছে। সুতরাং, সম্ভবত এটি অন্য কাউকে সহায়তা করবে:

com.google.common.collect.Iterables#concat()

আপনি যদি () এর জন্য একটিতে বিভিন্ন সংখ্যক সংকলনে একই যুক্তি প্রয়োগ করতে চান তবে দরকারী।

Comments

উদাহরণস্বরূপ: তালিকাগুলি.নউআরলিলিস্ট (Iterables.concat (list1, list2));

— মাইলিচ

আপনার com.google.common.collect.Iterators#concat(java.util.Iterator<? extends java.util.Iterator<? extends T>>)পরিবর্তে কল করা উচিত Iterables#concat(); কারণ পরবর্তী সময়ে অস্থায়ী লিঙ্কে উপাদানগুলি অনুলিপি করে!

— বব

Answer 9

জাভা 8 ( Stream.ofএবং Stream.concat)

প্রস্তাবিত সমাধানটি তিনটি তালিকার জন্য হলেও এটি দুটি তালিকার জন্যও প্রয়োগ করা যেতে পারে। জাভা 8-এ আমরা স্ট্রিম.ওফ বা স্ট্রিম.কম্যাট ব্যবহার করতে পারি :

List<String> result1 = Stream.concat(Stream.concat(list1.stream(),list2.stream()),list3.stream()).collect(Collectors.toList());
List<String> result2 = Stream.of(list1,list2,list3).flatMap(Collection::stream).collect(Collectors.toList());

Stream.concatইনপুট হিসাবে দুটি স্ট্রিম গ্রহণ করে এবং একটি অলস সংক্ষিপ্ত স্ট্রিম তৈরি করে যার উপাদানগুলি প্রথম স্ট্রিমের সমস্ত উপাদান হয় এবং দ্বিতীয় স্রোতের সমস্ত উপাদান অনুসরণ করে। আমাদের তিনটি তালিকা রয়েছে বলে আমরা এই পদ্ধতিটি ( Stream.concat) দুটিবার ব্যবহার করেছি ।

আমরা এমন একটি পদ্ধতি সহ একটি ইউটিলিটি ক্লাসও লিখতে পারি যা কোনও সংখ্যক তালিকাগুলি ( ভারার্গস ব্যবহার করে ) নেয় এবং একটি সংক্ষিপ্ত তালিকাটি এইভাবে ফেরত দেয়:

public static <T> List<T> concatenateLists(List<T>... collections) {
        return Arrays.stream(collections).flatMap(Collection::stream).collect(Collectors.toList()); 
}

তারপরে আমরা এই পদ্ধতিটি এইভাবে ব্যবহার করতে পারি:

List<String> result3 = Utils.concatenateLists(list1,list2,list3);

Comments

আপনি সম্ভবত তালিকা <স্ট্রিং> ফলাফল1 = স্ট্রিমকনক্যাট (স্ট্রিম.কমস্ট্র্যাট (list1.stream (), list2.stream ()), list3.stream ()) বলতে সংগ্রহ করতে পারেন (সংগ্রহকারী.টলিস্ট ()); আপনার প্রথম অপারেটরে দয়া করে ঠিক করুন

— ওয়েবকোমার

Answer 10

এখানে দুটি জাভা ব্যবহার করে একটি জাভা 8 সমাধান দেওয়া হয়েছে:

List<Object> newList = new ArrayList<>();
Stream.of(list1, list2).forEach(newList::addAll);

সচেতন হন যে এই পদ্ধতিটি ব্যবহার করা উচিত নয় যদি

• এর উত্স newListজানা যায় নি এবং এটি ইতিমধ্যে অন্যান্য থ্রেডের সাথে ভাগ করা যেতে পারে
• যে স্ট্রিমটি সংশোধন করে newListতা সমান্তরাল স্ট্রিম এবং এতে অ্যাক্সেস newListসিঙ্ক্রোনাইজ বা থ্রেডসেফ হয় না

পার্শ্ব প্রতিক্রিয়া বিবেচনার কারণে।

উপরোক্ত দুটি শর্তই দুটি তালিকায় যোগদানের উপরের ক্ষেত্রে প্রযোজ্য নয়, সুতরাং এটি নিরাপদ।

অন্য প্রশ্নের এই উত্তরের ভিত্তিতে ।

Comments

আমি যদি ভুল না হয় তবে এটি আসলে প্রস্তাবিত নয় - ডকস.ওরাকল.com/javase/8/docs/api/java/util/stream/… দয়া করে পার্শ্ব-প্রভাব বিভাগটি দেখুন। > স্ট্রিম অপারেশনের আচরণগত পরামিতিগুলির পার্শ্ব প্রতিক্রিয়াগুলি সাধারণভাবে নিরুৎসাহিত করা হয় কারণ তারা প্রায়শই রাষ্ট্রহীনতার প্রয়োজনীয়তার অযাচিত লঙ্ঘন এবং পাশাপাশি থ্রেড-সুরক্ষা বিপদের কারণ হতে পারে। সুতরাং

— এক্ষেত্রে

এটি যদি সত্যিই কোনও পার্শ্ব প্রতিক্রিয়া হয় তবে @ অ্যান্টন বালানিয়ুক প্রশ্ন। সেই সময়ে newListঅন্য কোনও থ্রেড দ্বারা পর্যবেক্ষণযোগ্য নয়। তবে আপনি ঠিক বলেছেন যে মানটি newListকোথা থেকে এসেছে তা অজানা থাকলে সম্ভবত এটি করা উচিত নয় (উদাহরণস্বরূপ যদি newListপ্যারামিটার হিসাবে পাস করা হয়

— স্পেসট্রুকার

আমি কৌতুহলী; এর .forEach(newList::addAll);পরিবর্তে কেন .collect(Collectors.toList());?

— 11684

@ 11684 কারণ সংগ্রাহক একটি সংগ্রহ করবেন List<List<Object>>। কি আপনি মনের মধ্যে থাকতে পারে ভালো কিছু হয় stackoverflow.com/questions/189559/...

— SpaceTrucker

@ স্পেসট্রিকার ওফস, আমি এটি উপেক্ষা করেছি। আমার বিভ্রান্তি দূর করার জন্য ধন্যবাদ। হ্যাঁ, আমার কথা ভাবা উচিত ছিল flatMap।

— 11684

Answer 11

এটি সহজ এবং মাত্র একটি লাইন, তবে তালিকার দুটি বিষয়বস্তু তালিকায় যুক্ত হবে list আপনার কি সত্যিই বিষয়গুলি তৃতীয় তালিকায় রাখা দরকার?

Collections.addAll(listOne, listTwo.toArray());

Comments

মূল তালিকাগুলি সংশোধন না করা একটি মানদণ্ড ছিল, তবে পরিস্থিতিগুলির ক্ষেত্রে উদাহরণ হিসাবে এখানে থাকা সীমাবদ্ধ নয় যেখানে এটি সীমাবদ্ধ নয়।

— রবার্ট অ্যাটকিনস

ধন্যবাদ, বা আরও সহজ তালিকাঅন.এলডিএল (তালিকা দুটি)

— জে

Answer 12

সামান্য সরল:

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Comments

এটি কি নকল স্ট্রিংগুলির কারণ হবে? মানে উভয় তালিকায় বিদ্যমান একটি স্ট্রিং ফলাফলের তালিকায় দু'বার থাকবে?

— এজেন্টকনফফ

@ জয়নোডিস হ্যাঁ, এখানে সদৃশ হতে পারে। Listগঠন কোন স্বতন্ত্রতা সীমাবদ্ধতার আরোপ করে। আপনি সেটগুলি দিয়ে একই জিনিসটি করে ডুপসগুলি সরাতে পারেন। Set<String> newSet = new HashSet<>(setOne); newSet.addAll(setTwo);

— প্যাট্রিক

Answer 13

একটু খাটো হবে:

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Answer 14

যে কোনও সংখ্যক তালিকার সংস্থান করতে আপনি আপনার জেনারিক জাভা 8 ইউটিলিটি পদ্ধতি তৈরি করতে পারেন ।

@SafeVarargs
public static <T> List<T> concat(List<T>... lists) {
    return Stream.of(lists).flatMap(List::stream).collect(Collectors.toList());
}

Answer 15

লক্ষ্য তালিকাটি পূর্বনির্ধারিত থাকলে আপনি অননিলার করতে পারেন।

(newList = new ArrayList<String>(list1)).addAll(list2);

Answer 16

ইন জাভা 8 (অন্যান্য উপায়):

List<?> newList = 
Stream.of(list1, list2).flatMap(List::stream).collect(Collectors.toList());

Comments

এই পদ্ধতির ইতিমধ্যে এই উত্তরটির দ্বারা পরামর্শ দেওয়া হয়েছে: stackoverflow.com/a/37386846

— মাইলস

Answer 17

Java8স্ট্রিম ব্যবহার করে অন্য একটি লাইনারের সমাধান , যেহেতু flatMapসমাধান ইতিমধ্যে পোস্ট করা হয়েছে, তাই এখানে একটি সমাধান ছাড়াইflatMap

List<E> li = lol.stream().collect(ArrayList::new, List::addAll, List::addAll);

অথবা

List<E> ints = Stream.of(list1, list2).collect(ArrayList::new, List::addAll, List::addAll);

কোড

    List<List<Integer>> lol = Arrays.asList(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6));
    List<Integer> li = lol.stream().collect(ArrayList::new, List::addAll, List::addAll);
    System.out.println(lol);
    System.out.println(li);

আউটপুট

[[1, 2, 3], [4, 5, 6]]
[1, 2, 3, 4, 5, 6]

Comments

আমি যুক্ত করব যে এই সমাধানটি সম্ভবত ব্যবহারকারীর চেয়ে বেশি পারফরম্যান্ট flatMap, কারণ তালিকাগুলি সংগ্রহ করা হলে কেবল একবারে পুনরাবৃত্তি করা হয়

— স্টিফান হ্যাবারেল

Answer 18

আমার মতে সবচেয়ে স্মার্ট:

/**
 * @param smallLists
 * @return one big list containing all elements of the small ones, in the same order.
 */
public static <E> List<E> concatenate (final List<E> ... smallLists)
{
    final ArrayList<E> bigList = new ArrayList<E>();
    for (final List<E> list: smallLists)
    {
        bigList.addAll(list);
    }
    return bigList;
}

Comments

ভুলে যাবেন না @SafeVarargs!

— রেডন রোসবারো

Answer 19

আপনি এটি একটি স্থিতিশীল আমদানি এবং একটি সহায়ক শ্রেণীর সাহায্যে করতে পারেন

এনবি সম্ভবত এই শ্রেণীর জেনারেশন উন্নত করা যেতে পারে

public class Lists {

   private Lists() { } // can't be instantiated

   public static List<T> join(List<T>... lists) {
      List<T> result = new ArrayList<T>();
      for(List<T> list : lists) {
         result.addAll(list);
      }
      return results;
   }

}

তারপরে আপনি এই জাতীয় জিনিসগুলি করতে পারেন

import static Lists.join;
List<T> result = join(list1, list2, list3, list4);

Comments

স্থিতিশীল আমদানি বা সহায়ক শ্রেণি কীভাবে প্রাসঙ্গিক?

— shmosel

Answer 20

অবজেক্ট কী দ্বারা যোগদানের জন্য সমর্থন সহ জাভা 8 সংস্করণ:

public List<SomeClass> mergeLists(final List<SomeClass> left, final List<SomeClass> right, String primaryKey) {
    final Map<Object, SomeClass> mergedList = new LinkedHashMap<>();

    Stream.concat(left.stream(), right.stream())
        .map(someObject -> new Pair<Object, SomeClass>(someObject.getSomeKey(), someObject))
        .forEach(pair-> mergedList.put(pair.getKey(), pair.getValue()));

    return new ArrayList<>(mergedList.values());
}

Answer 21

public static <T> List<T> merge(List<T>... args) {
    final List<T> result = new ArrayList<>();

    for (List<T> list : args) {
        result.addAll(list);
    }

    return result;
}

Answer 22

একটি সহায়ক শ্রেণি ব্যবহার করুন।

আমার পরামর্শ:

public static <E> Collection<E> addAll(Collection<E> dest, Collection<? extends E>... src) {
    for(Collection<? extends E> c : src) {
        dest.addAll(c);
    }

    return dest;
}

public static void main(String[] args) {
    System.out.println(addAll(new ArrayList<Object>(), Arrays.asList(1,2,3), Arrays.asList("a", "b", "c")));

    // does not compile
    // System.out.println(addAll(new ArrayList<Integer>(), Arrays.asList(1,2,3), Arrays.asList("a", "b", "c")));

    System.out.println(addAll(new ArrayList<Integer>(), Arrays.asList(1,2,3), Arrays.asList(4, 5, 6)));
}

Answer 23

public static <T> List<T> merge(@Nonnull final List<T>... list) {
    // calculate length first
    int mergedLength = 0;
    for (List<T> ts : list) {
      mergedLength += ts.size();
    }

    final List<T> mergedList = new ArrayList<>(mergedLength);

    for (List<T> ts : list) {
      mergedList.addAll(ts);
    }

    return mergedList;
  }

Answer 24

আমরা 2 টি পদ্ধতির সাথে জাভা 8 ব্যবহার করে 2 টি তালিকায় যোগ দিতে পারি।

    List<String> list1 = Arrays.asList("S", "T");
    List<String> list2 = Arrays.asList("U", "V");

1) কনক্যাট ব্যবহার করে:

    List<String> collect2 = Stream.concat(list1.stream(), list2.stream()).collect(toList());
    System.out.println("collect2 = " + collect2); // collect2 = [S, T, U, V]

2) ফ্ল্যাটম্যাপ ব্যবহার:

    List<String> collect3 = Stream.of(list1, list2).flatMap(Collection::stream).collect(toList());
    System.out.println("collect3 = " + collect3); // collect3 = [S, T, U, V]

Comments

এগারো বছরের পুরনো প্রশ্নের উত্তর দেওয়ার সাথে সাথে আরও ত্রিশটি উত্তর উত্তর দেওয়ার সময় আপনার উত্তরটির প্রশ্নের নতুন দিকগুলি কী বলে চিহ্নিত করা উচিত তা লক্ষ্য করুন এবং প্রশ্নটি জিজ্ঞাসা করার সময় এই কৌশলগুলি কাজ করত কিনা, বা যদি সেগুলি বৈশিষ্ট্যগুলির উপর নির্ভর করে তবে বছরের পর বছর ধরে চালু।

— জেসন অ্যালার

Answer 25

প্রায় উত্তরগুলির মধ্যে একটি অ্যারেলিস্ট ব্যবহার করার পরামর্শ দেওয়া হয়।

List<String> newList = new LinkedList<>(listOne);
newList.addAll(listTwo);

দক্ষ যোগ করার ক্রিয়াকলাপের জন্য একটি লিঙ্কডলিস্ট ব্যবহার করতে পছন্দ করুন।

অ্যারেলিস্ট অ্যাডটি হ'ল (1) মোড়কযুক্ত, তবে ওরে (এন) সবচেয়ে খারাপ ক্ষেত্রে যেহেতু অ্যারেরটি পুনরায় আকার দিতে হবে এবং অনুলিপি করতে হবে। লিঙ্কডলিস্ট অ্যাড সর্বদা ধ্রুবক O (1) থাকে।

আরও ইনফোজ https://stackoverflow.com/a/322742/311420

Answer 26

আমি দাবি করছি না যে এটি সহজ, তবে আপনি ওয়ান-লাইনারগুলির জন্য বোনাস উল্লেখ করেছেন ;-)

Collection mergedList = Collections.list(new sun.misc.CompoundEnumeration(new Enumeration[] {
    new Vector(list1).elements(),
    new Vector(list2).elements(),
    ...
}))

Comments

কেন কেউ কখনও সেগুলি ব্যবহার করা উচিত নয়?

— ডেভিড

@ ডেভিড কারণ এটি জেডিকে অভ্যন্তরীণভাবে ব্যবহার করার লক্ষ্য ছিল। যদি আপনি এটি আপনার কোডটিতে ব্যবহার করেন তবে আপনার কোডটি সম্ভবত নন-সান (বা এখন অ-ওরাকল এখন) জেডিকে / জেআরই তে চলবে না।

— অ্যাড্রিয়ান শাম

@ অ্যাড্রিয়ানশাম কি ওরাকলের চেয়ে আরও জেডিকে / জেআরই আছে? এটা আমাকে অবাক করে দেবে। এমনকি সর্বাধিক সাধারণ এপিআই কার্যকারিতা সীমাবদ্ধ থাকলেও, পুরো জিনিসটি পুনর্নির্মাণে সম্ভবত যুগে যুগে সময় লাগবে ...

— এগার হ্যানস

বেশ জেভিএম রয়েছে। এন্টারপ্রাইজ বিশ্বে সর্বাধিক দেখা যায় এমন একটি আইবিএম হওয়া উচিত যা ওয়েবস্পিয়ারের সাথে বান্ডিল করা হয়

— অ্যাড্রিয়ান শাম

Answer 27

ওয়ান-লাইনের কাছাকাছি কোনও উপায় নয়, তবে আমি মনে করি এটিই সবচেয়ে সহজ:

List<String> newList = new ArrayList<String>(l1);
newList.addAll(l2);

for(String w:newList)
        System.out.printf("%s ", w);

Answer 28

আপনার তালিকাতে বিভিন্ন ধরণের থাকে এবং আপনি এগুলি অন্য ধরণের তালিকার সাথে সংযুক্ত করতে চান তবে এখানে স্ট্রিম এবং জাভা 8 ব্যবহার করে এমন একটি পদ্ধতির উপায় রয়েছে।

public static void main(String[] args) {
    List<String> list2 = new ArrayList<>();
    List<Pair<Integer, String>> list1 = new ArrayList<>();

    list2.add("asd");
    list2.add("asdaf");
    list1.add(new Pair<>(1, "werwe"));
    list1.add(new Pair<>(2, "tyutyu"));

    Stream stream = Stream.concat(list1.stream(), list2.stream());

    List<Pair<Integer, String>> res = (List<Pair<Integer, String>>) stream
            .map(item -> {
                if (item instanceof String) {
                    return new Pair<>(0, item);
                }
                else {
                    return new Pair<>(((Pair<Integer, String>)item).getKey(), ((Pair<Integer, String>)item).getValue());
                }
            })
            .collect(Collectors.toList());
}

Answer 29

আপনি যদি এটি স্থিতিশীলভাবে করতে চান তবে নিম্নলিখিতগুলি করতে পারেন।

উদাহরণগুলি প্রাকৃতিক ক্রমে 2 এনামসেট ব্যবহার করে (== এনাম-অর্ডার) A, Bএবং তারপরে একটি ALLতালিকায় যোগ দেয় ।

public static final EnumSet<MyType> CATEGORY_A = EnumSet.of(A_1, A_2);
public static final EnumSet<MyType> CATEGORY_B = EnumSet.of(B_1, B_2, B_3);

public static final List<MyType> ALL = 
              Collections.unmodifiableList(
                  new ArrayList<MyType>(CATEGORY_A.size() + CATEGORY_B.size())
                  {{
                      addAll(CATEGORY_A);
                      addAll(CATEGORY_B);
                  }}
              );

Comments

এটি একটি নতুন বেনামে শ্রেণি তৈরি করবে। প্রস্তাবিত পদ্ধতির!

— ক্রাভেমির

Answer 30

import java.util.AbstractList;
import java.util.List;


/**
 * The {@code ConcatList} is a lightweight view of two {@code List}s.
 * <p>
 * This implementation is <em>not</em> thread-safe even though the underlying lists can be.
 * 
 * @param <E>
 *            the type of elements in this list
 */
public class ConcatList<E> extends AbstractList<E> {

    /** The first underlying list. */
    private final List<E> list1;
    /** The second underlying list. */
    private final List<E> list2;

    /**
     * Constructs a new {@code ConcatList} from the given two lists.
     * 
     * @param list1
     *            the first list
     * @param list2
     *            the second list
     */
    public ConcatList(final List<E> list1, final List<E> list2) {
        this.list1 = list1;
        this.list2 = list2;
    }

    @Override
    public E get(final int index) {
        return getList(index).get(getListIndex(index));
    }

    @Override
    public E set(final int index, final E element) {
        return getList(index).set(getListIndex(index), element);
    }

    @Override
    public void add(final int index, final E element) {
        getList(index).add(getListIndex(index), element);
    }

    @Override
    public E remove(final int index) {
        return getList(index).remove(getListIndex(index));
    }

    @Override
    public int size() {
        return list1.size() + list2.size();
    }

    @Override
    public boolean contains(final Object o) {
        return list1.contains(o) || list2.contains(o);
    }

    @Override
    public void clear() {
        list1.clear();
        list2.clear();
    }

    /**
     * Returns the index within the corresponding list related to the given index.
     * 
     * @param index
     *            the index in this list
     * 
     * @return the index of the underlying list
     */
    private int getListIndex(final int index) {
        final int size1 = list1.size();
        return index >= size1 ? index - size1 : index;
    }

    /**
     * Returns the list that corresponds to the given index.
     * 
     * @param index
     *            the index in this list
     * 
     * @return the underlying list that corresponds to that index
     */
    private List<E> getList(final int index) {
        return index >= list1.size() ? list2 : list1;
    }

}