আমি কীভাবে জাভাতে দুটি অ্যারে সংযুক্ত করতে পারি?

Question

আমার Stringজাভাতে দুটি অ্যারে যুক্ত করতে হবে ।

void f(String[] first, String[] second) {
    String[] both = ???
}

এই কাজ করতে সবচেয়ে সহজ পদ্ধিতি হল উপায় কি?

Comments

পেয়ারা থেকে বাইটস কনক্যাট

— বেন পেজ

আমি এখানে প্রচুর প্রতিক্রিয়া দেখছি কিন্তু প্রশ্নটি এতটা উচ্চারণ করা হয়েছে ('সহজতম উপায়'?) যাতে এটি সর্বোত্তম উত্তরটি নির্দেশ করতে দেয় না ...

— আর্তুর ওপালিনস্কি

এখানে কয়েক ডজন উত্তর নতুন অ্যারেতে ডেটা অনুলিপি করছে কারণ এটির জন্যই জিজ্ঞাসা করা হয়েছিল - তবে যখন কঠোরভাবে প্রয়োজন হয় না তখন ডেটা অনুলিপি করা বিশেষত জাভাতে করা খারাপ কাজ। পরিবর্তে, সূচকের উপর নজর রাখুন এবং দুটি অ্যারে ব্যবহার করুন যেন তারা যোগ দিয়েছে। আমি কৌশলটি চিত্রিত করে একটি সমাধান যুক্ত করেছি।

— ডগলাস

এই জাতীয় প্রশ্নের বর্তমানে ৫০ টি পৃথক উত্তর রয়েছে এ বিষয়টি আমাকে বিস্মিত করে যে জাভা কখনই সরল array1 + array2বক্তব্য রাখেনি।

— JollyJoker

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

— rghome

Answer 1

ভাল পুরানো অ্যাপাচি কমন্স ল্যাং লাইব্রেরি থেকে আমি একটি লাইন সমাধান পেয়েছি।
ArrayUtils.addAll(T[], T...)

কোড:

String[] both = ArrayUtils.addAll(first, second);

Comments

যদি প্রশ্নের উত্তর দেয় তবে এটি "প্রতারণা" কীভাবে? অবশ্যই, এই নির্দিষ্ট পরিস্থিতির জন্য অতিরিক্ত নির্ভরতা থাকা খুব সম্ভবত অতিরিক্ত দক্ষতা অর্জন করা, তবে এটি উপস্থিত রয়েছে বলে ডাকাতে কোনও ক্ষতি করা হয় না, বিশেষত যেহেতু অ্যাপাচি কমন্সে কার্যকরীতার এত দুর্দান্ত বিট রয়েছে।

— রব

আমি সম্মত, এটি সত্যই প্রশ্নের উত্তর দিচ্ছে না। উচ্চ স্তরের গ্রন্থাগারগুলি দুর্দান্ত হতে পারে তবে আপনি যদি এটি করার একটি কার্যকর উপায় শিখতে চান তবে আপনি লাইব্রেরি পদ্ধতিটি যে কোডটি ব্যবহার করছেন সেটি দেখতে চাই। এছাড়াও, অনেক পরিস্থিতিতে, আপনি উড়ে যাওয়ার পণ্যটিতে কেবল অন্য লাইব্রেরির মাধ্যমে পারেন না।

— অ্যাডামসি

আমি মনে করি এটি একটি ভাল উত্তর। পজোর সমাধানও সরবরাহ করা হয়েছে, তবে ওপি যদি ইতিমধ্যে তাদের প্রোগ্রামে অ্যাপাচি কমন্স ব্যবহার করে থাকে (এর জনপ্রিয়তা বিবেচনা করে একেবারে সম্ভব) তিনি এখনও এই সমাধানটি জানেন না। তারপরে তিনি "এই একটি পদ্ধতির জন্য নির্ভরতা যুক্ত করবেন না", তবে বিদ্যমান লাইব্রেরিটির আরও ভাল ব্যবহার করবেন।

— আদম

আপনি যদি কোনও একক পদ্ধতির জন্য একটি লাইব্রেরি না যুক্ত সম্পর্কে সর্বদা উদ্বিগ্ন থাকেন তবে কোনও নতুন লাইব্রেরি আর যুক্ত হবে না। অ্যাপাচি কমন্সে উপস্থিত দুর্দান্ত ইউটিলিটিগুলি প্রদত্ত, আমি যখন প্রথমবার ব্যবহারের ঘটনাটি ঘটে তখন আমি এটি যুক্ত করার পরামর্শ দিই।

— হিন্দোল

অ্যাপাচি কমন্স ব্যবহার করা কখনই 'প্রতারণা' বলা উচিত নয় i আমি বিকাশকারীদের বুদ্ধি সম্পর্কে প্রশ্ন করি যারা এটি একটি অপ্রয়োজনীয় নির্ভরতা।

— জেরিল কুক

Answer 2

এখানে একটি সহজ পদ্ধতি যা দুটি অ্যারে সংযুক্ত করে ফলাফলটি ফিরিয়ে দেবে:

public <T> T[] concatenate(T[] a, T[] b) {
    int aLen = a.length;
    int bLen = b.length;

    @SuppressWarnings("unchecked")
    T[] c = (T[]) Array.newInstance(a.getClass().getComponentType(), aLen + bLen);
    System.arraycopy(a, 0, c, 0, aLen);
    System.arraycopy(b, 0, c, aLen, bLen);

    return c;
}

মনে রাখবেন যে এটি আদিম ডেটা ধরণের সাথে কাজ করবে না, কেবলমাত্র বস্তুর প্রকারের সাথে।

নিম্নলিখিত সামান্য জটিল সংস্করণ উভয় অবজেক্ট এবং আদিম অ্যারে নিয়ে কাজ করে। এটি আর্গুমেন্ট টাইপের Tপরিবর্তে ব্যবহার করে এটি করে T[]।

ফলাফলের উপাদান ধরণের হিসাবে সর্বাধিক সাধারণ প্রকারটি বাছাই করে দুটি পৃথক ধরণের অ্যারেগুলি সংযুক্ত করাও এটি সম্ভব করে তোলে।

public static <T> T concatenate(T a, T b) {
    if (!a.getClass().isArray() || !b.getClass().isArray()) {
        throw new IllegalArgumentException();
    }

    Class<?> resCompType;
    Class<?> aCompType = a.getClass().getComponentType();
    Class<?> bCompType = b.getClass().getComponentType();

    if (aCompType.isAssignableFrom(bCompType)) {
        resCompType = aCompType;
    } else if (bCompType.isAssignableFrom(aCompType)) {
        resCompType = bCompType;
    } else {
        throw new IllegalArgumentException();
    }

    int aLen = Array.getLength(a);
    int bLen = Array.getLength(b);

    @SuppressWarnings("unchecked")
    T result = (T) Array.newInstance(resCompType, aLen + bLen);
    System.arraycopy(a, 0, result, 0, aLen);
    System.arraycopy(b, 0, result, aLen, bLen);        

    return result;
}

এখানে একটি উদাহরণ:

Assert.assertArrayEquals(new int[] { 1, 2, 3 }, concatenate(new int[] { 1, 2 }, new int[] { 3 }));
Assert.assertArrayEquals(new Number[] { 1, 2, 3f }, concatenate(new Integer[] { 1, 2 }, new Number[] { 3f }));

Comments

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

— কেভিএন

নিম্নলিখিত লাইনটি জেনেরিক অংশটি ভেঙে ফেলবে: সংযুক্তি (নতুন স্ট্রিং [] {"1"}, নতুন অবজেক্ট [] {নতুন অবজেক্ট ()})

— ড্রাগন 66

@ সাপ্রেস ওয়ার্নিংস টিকাটি ব্যবহার না করা ভাল হবে - আমি নীচে এর জন্য একটি সমাধান পোস্ট করব।

— বিউডেট

+1 এর জন্য Array.newInstance(a.getClass().getComponentType(), aLen + bLen);। আমি আশ্চর্যজনকভাবে এর আগে কখনও দেখিনি। @ বিউদেটে আমি মনে করি যে টীকাটি কেন দমন করা হচ্ছে তা বিবেচনা করে এখানে টীকাটি ঠিক আছে।

— ব্লেক

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

— বিউডেট

Answer 3

এমন একটি সম্পূর্ণ জেনেরিক সংস্করণ লেখা সম্ভব যা কোনও সংখ্যক অ্যারে সংযুক্ত করতে এমনকি বাড়ানো যেতে পারে। এই সংস্করণগুলির জাভা 6 প্রয়োজন যেমন তারা ব্যবহার করেArrays.copyOf()

উভয় সংস্করণ কোনও মধ্যস্থতাকারী Listঅবজেক্ট তৈরি করা এড়াতে পারে এবং System.arraycopy()বড় অ্যারেগুলি অনুলিপি করা যত তাড়াতাড়ি সম্ভব তা নিশ্চিত করার জন্য ব্যবহার করে।

দুটি অ্যারে এটির মতো দেখাচ্ছে:

public static <T> T[] concat(T[] first, T[] second) {
  T[] result = Arrays.copyOf(first, first.length + second.length);
  System.arraycopy(second, 0, result, first.length, second.length);
  return result;
}

এবং একটি নির্বিচার সংখ্যক অ্যারে (> = 1) এর জন্য এটি দেখতে এটির মতো দেখাচ্ছে:

public static <T> T[] concatAll(T[] first, T[]... rest) {
  int totalLength = first.length;
  for (T[] array : rest) {
    totalLength += array.length;
  }
  T[] result = Arrays.copyOf(first, totalLength);
  int offset = first.length;
  for (T[] array : rest) {
    System.arraycopy(array, 0, result, offset, array.length);
    offset += array.length;
  }
  return result;
}

Comments

@djBO: এবং প্রতিটি প্রতিস্থাপন শুধু কোড কপি: আদিম টাইপ অ্যারে জন্য আপনি প্রতিটি টাইপ জন্য একটি জমিদার করতে হবে চাই Tসঙ্গে byte(এবং হারান <T>)।

— জোছিম সৌর

আপনি কীভাবে আমার ক্লাসে <T> অপারেটর টাইপ ব্যবহার করবেন তা আমাকে বলতে পারেন?

— জনিডিপ

আমি এটিকে শুরুতে যুক্ত করব, কেবল প্রতিরক্ষামূলক হতে। if (প্রথম == নাল) {if (দ্বিতীয় == নাল) {প্রত্যাবর্তন নাল; second দ্বিতীয় ফিরে; } if (দ্বিতীয় == নাল) {প্রথমে ফিরে আসুন; }

— ম্যারাথন

@ ডিজেবো: কি সম্পর্কে:ByteBuffer buffer = ByteBuffer.allocate(array1.length + array2.length); buffer.put(array1); buffer.put(array2); return buffer.array();

— স্যাম গোল্ডবার্গ

এই পদ্ধতির যা হয়ে আপাত আপনি উদাহরণস্বরূপ বিভিন্ন উপাদান ধরনের অ্যারে সঙ্গে এই ফাংশন ডাকা, একটি বাগ concat(ai, ad), যেখানে aiহয় Integer[]এবং adহয় Double[]। (এই ক্ষেত্রে, টাইপ পরামিতি সংকলক দ্বারা <T>সমাধান করা <? extends Number>হয়।) তৈরি Arrays.copyOfঅ্যারে প্রথম অ্যারের উপাদান ধরণ থাকবে, Integerউদাহরণস্বরূপ। যখন ফাংশনটি দ্বিতীয় অ্যারের অনুলিপি করতে চলেছে তখন একটি ArrayStoreExceptionনিক্ষেপ করা হবে। সমাধানটি অতিরিক্ত Class<T> typeপ্যারামিটার রাখার জন্য।

— টি-বুল

Answer 4

Streamজাভা 8 এ ব্যবহার করা:

String[] both = Stream.concat(Arrays.stream(a), Arrays.stream(b))
                      .toArray(String[]::new);

বা এটির মতো ব্যবহার করে flatMap:

String[] both = Stream.of(a, b).flatMap(Stream::of)
                      .toArray(String[]::new);

জেনেরিক টাইপের জন্য এটি করতে আপনাকে প্রতিবিম্ব ব্যবহার করতে হবে:

@SuppressWarnings("unchecked")
T[] both = Stream.concat(Arrays.stream(a), Arrays.stream(b)).toArray(
    size -> (T[]) Array.newInstance(a.getClass().getComponentType(), size));

Comments

এটি কতটা দক্ষ?

— সুপহস্টার

একটি পঠনযোগ্য: jaxenter.com/… টিএল; ডাঃ - স্ট্রিমগুলি পারফরম্যান্ট হতে পারে বা না, এটি আপনি তাদের সাথে কী করছেন এবং সমস্যার সীমাবদ্ধতার উপর নির্ভর করে (এটি কি সর্বদা উত্তর নয়? লল)

— ট্রেভর ব্রাউন

অধিকন্তু, যদি ক বা বি আদিম ধরণের অ্যারে হয় তবে তাদের স্ট্রিমগুলি যেমন উদাহরণের চেয়ে .boxed()প্রকারের হয় তবে এটি পরামিতি হিসাবে পাস করা যায় না । StreamIntStreamStream.concat

— উইল হার্ডউইক-স্মিথ

@ উইল হার্ডউইক-স্মিথ: না, আপনাকে কেবল সঠিক স্ট্রিম শ্রেণি বেছে নিতে হবে, যেমন aএবং যদি bহয় তবে int[]ব্যবহার করুনint[] both = IntStream.concat(Arrays.stream(a), Arrays.stream(b)).toArray();

— হলগার

@ সুপুহস্তর: এটি সম্ভবত তত দ্রুত নয় System.arrayCopy। তবে বিশেষভাবে ধীর হয় না। আপনি সম্ভবত এই একটি যা করতে হবে খুব সঙ্গে অনেকবার বিশাল ক্ষেত্রে বিন্যাসগুলির সত্যিই ব্যাপার সঞ্চালনের সময় পার্থক্য জন্য কর্মক্ষমতা সংবেদনশীল প্রেক্ষিতে।

— লিই

Answer 5

বা প্রিয় পেয়ারার সাথে :

String[] both = ObjectArrays.concat(first, second, String.class);

এছাড়াও, আদিম অ্যারেগুলির জন্য সংস্করণ রয়েছে:

• Booleans.concat(first, second)
• Bytes.concat(first, second)
• Chars.concat(first, second)
• Doubles.concat(first, second)
• Shorts.concat(first, second)
• Ints.concat(first, second)
• Longs.concat(first, second)
• Floats.concat(first, second)

Comments

আমি পেয়ারা যতটা ভালোবাসি, অ্যাপাচি কমন্স থেকে প্রাপ্ত পদ্ধতিটি নালাগুলির সাথে আরও ভাল আচরণ করে।

— রবি ওয়াল্লাউ

গ্রন্থাগারগুলি ব্যবহার করা ভাল, তবে সমস্যাটি দূরে সরানো হয়েছে এটি দুর্ভাগ্যজনক। সুতরাং অন্তর্নিহিত সমাধান অধরা থেকে যায় remains

— ব্যবহারকারী 924272

অ্যাবস্ট্রাকশন নিয়ে সমস্যা কী? ডান্নো এখানে চাকাটি পুনরায় উদ্ভাবনের সাথে কী চুক্তি করে, আপনি যদি সমস্যাটি উত্সটি দেখতে চান বা এটি পড়তে চান তবে। পেশাদার কোডটি উচ্চ স্তরের লাইব্রেরি ব্যবহার করা উচিত, এটি গুগলের অভ্যন্তরে বিকশিত হলে আরও ভাল!

— ব্রেণো সালগাদো

@ রাভিওয়াল্লাউ আপনি কি ক্লাসের সাথে লিঙ্ক করতে পারবেন যে এটি করে?

— সাবস্টিয়ান ট্রম্প

@ সাবস্টিয়ানট্রম্প এটি এই প্রশ্নের শীর্ষ সমাধান - অ্যারে ইউটিলস।

— রবি ওয়ালাউ

Answer 6

আপনি কোডের দুটি লাইনে দুটি অ্যারে সংযুক্ত করতে পারেন।

String[] both = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, both, first.length, second.length);

এটি একটি দ্রুত এবং দক্ষ সমাধান এবং আদিম ধরণের জন্য কাজ করবে পাশাপাশি জড়িত দুটি পদ্ধতির ওভারলোড করা রয়েছে।

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

আপনার forবড় অ্যারেগুলির জন্য লুপগুলি এড়ানো উচিত কারণ এগুলি দক্ষ নয়। বিল্ট ইন পদ্ধতিগুলিতে অত্যন্ত দ্রুত গতিযুক্ত ব্লক-অনুলিপি ফাংশন ব্যবহার করা হয়।

Comments

এটি সেরা সমাধানগুলির মধ্যে একটি। 100% স্ট্যান্ডার্ড জাভা ফাস্ট / দক্ষ। আরও upvotes পাওয়া উচিত!

— শেবলা তসমা

Answer 7

জাভা এপিআই ব্যবহার করে:

String[] f(String[] first, String[] second) {
    List<String> both = new ArrayList<String>(first.length + second.length);
    Collections.addAll(both, first);
    Collections.addAll(both, second);
    return both.toArray(new String[both.size()]);
}

Comments

সরল, তবে অদক্ষ কারণ এটি অ্যারেলিস্টের জন্য একটি অ্যারে তৈরি করে এবং তারপরে টু অ্যারে পদ্ধতির জন্য অন্যটি তৈরি করে। এটি পড়া সহজ হিসাবে এখনও বৈধ।

— ফোনিক্স

স্ট্রিংস এবং অবজেক্টের জন্য প্রযোজ্য (যেমন প্রশ্নটি চায়) তবে প্রাথমিক ধরণের (

— ইনট

এই নিবন্ধে যেমন বর্ণনা করা হয়েছে , ব্যবহার both.toArray(new String[0])করা তত দ্রুততর হবে both.toArray(new String[both.size()]), এমনকি এটি আমাদের নির্বোধ অন্তর্দৃষ্টিগুলির সাথে বৈপরীত্যও করে। এজন্যই অনুকূলিতকরণের সময় প্রকৃত কর্মক্ষমতা পরিমাপ করা এত গুরুত্বপূর্ণ। অথবা আরও সহজ সরল কনস্ট্রাক্ট ব্যবহার করুন, যখন আরও জটিল ভেরিয়েন্টের সুবিধা প্রমাণ করা যায় না।

— হোলার

Answer 8

একটি সমাধান 100% পুরাতন জাভা এবং ছাড়াই System.arraycopy (উদাহরণস্বরূপ GWT ক্লায়েন্টে উপলব্ধ নয়):

static String[] concat(String[]... arrays) {
    int length = 0;
    for (String[] array : arrays) {
        length += array.length;
    }
    String[] result = new String[length];
    int pos = 0;
    for (String[] array : arrays) {
        for (String element : array) {
            result[pos] = element;
            pos++;
        }
    }
    return result;
}

Comments

ফাইলের জন্য আমার পুনরায় কাজ করেছিলেন [], তবে এটি একই। আপনার সমাধানের জন্য ধন্যবাদ

— ShadowFlame

সম্ভবত বেশ অদক্ষ যদিও।

— জোনাসসিজে - মনিকা

আপনি nullচেক যোগ করতে চাইতে পারেন । এবং সম্ভবত আপনার কিছু ভেরিয়েবল সেট করুন final।

— ট্রিপ কাইনেটিক্স

@ ট্রিপকিনেটিক্স nullচেকগুলি এনপিই- র দেখানোর পরিবর্তে লুকিয়ে রাখবে এবং স্থানীয় যুদ্ধগুলির জন্য ফাইনাল ব্যবহারের কোনও সুবিধা নেই (এখনও)।

— মার্টেন বোদেউয়েস

@ মার্টেন বোদেউয়েস আমি মনে করি আপনি খুঁজে পাবেন (যদি আপনি এটির বেঞ্চমার্ক করেন, যা আমার রয়েছে) যে প্রতিটির জন্য একই সাথে জাভা এর শেষ সংস্করণে সূচকযুক্ত লুপ হিসাবে চালিত হয়। অপ্টিমাইজার এটি যত্ন করে।

— rghome

Answer 9

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

private static <T> T[] concatOrReturnSame(T[] a, T[] b) {
    final int alen = a.length;
    final int blen = b.length;
    if (alen == 0) {
        return b;
    }
    if (blen == 0) {
        return a;
    }
    final T[] result = (T[]) java.lang.reflect.Array.
            newInstance(a.getClass().getComponentType(), alen + blen);
    System.arraycopy(a, 0, result, 0, alen);
    System.arraycopy(b, 0, result, alen, blen);
    return result;
}

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

Comments

তবে এর অর্থ হ'ল আপনি একই অ্যারেটি ফিরে আসছেন এবং প্রত্যাবর্তিত অ্যারেতে একটি মান পরিবর্তন করে ফেরত ইনপুট অ্যারের একই অবস্থানে মান পরিবর্তন করে।

— লরেঞ্জো বোকাক্সিয়া

হ্যাঁ - অ্যারের পুনরায় ব্যবহার সম্পর্কিত আমার পোস্টের শেষে মন্তব্য দেখুন। এই সমাধান দ্বারা আরোপিত রক্ষণাবেক্ষণের ওভারহেডটি আমাদের বিশেষ ক্ষেত্রে এটি মূল্যবান ছিল, তবে সম্ভবত বেশিরভাগ ক্ষেত্রে প্রতিরক্ষামূলক অনুলিপি ব্যবহার করা উচিত।

— ভলিউমে

লরেঞ্জো / ভল্লি, আপনি কোডের কোন অংশটি অ্যারে পুনরায় ব্যবহারের কারণ হিসাবে ব্যাখ্যা করতে পারেন? আমি ভাবলাম System.arraycopyঅ্যারের বিষয়বস্তু অনুলিপি করে?

— রোসদি কাসিম

একজন কলার সাধারণত একটি নতুন বরাদ্দ করা অ্যারে ফিরিয়ে আনার জন্য কনটাক্ট () এর কল করতে পারে। যদি ক বা বি হয় নাল হয়, কনক্যাট () তবে এতে প্রবেশ করা একটি অ্যারে ফিরিয়ে দেবে। এই পুনরায় ব্যবহারটি অপ্রত্যাশিত হতে পারে। (হ্যাঁ, অ্যারেকপিটি কেবল অনুলিপি করে The পুনরায় ব্যবহার হয় সরাসরি বা এক থেকে খ সরাসরি ফিরে আসে))

— ভল্লি

কোড যথাসম্ভব স্ব-বর্ণনামূলক হওয়া উচিত। কোড পড়ার লোকদের একটি নির্দিষ্ট অবস্থার জন্য এবং অন্যের জন্য অন্য কিছু করার জন্য এটি সনাক্ত করার জন্য একটি কথিত ফাংশনের জাভাডকটি অনুসন্ধান করতে হবে না। সংক্ষেপে: আপনি সাধারণত কোনও মন্তব্যে নকশার সমস্যাগুলি ঠিক করতে পারবেন না। কেবলমাত্র দুটি ifবিবৃতি ছেড়ে দেওয়া সহজ সমাধান হবে।

— মার্টেন বোদেউয়েস

Answer 10

প্রায়োগিক জাভা লাইব্রেরি একটি অ্যারের রাপার ক্লাস সংযুক্তকরণের মত কুশলী পদ্ধতি অ্যারে equips যে হয়েছে।

import static fj.data.Array.array;

...এবং তারপর

Array<String> both = array(first).append(array(second));

মোড়কজাত অ্যারেটি ফিরে পেতে কল করুন

String[] s = both.array();

Answer 11

ArrayList<String> both = new ArrayList(Arrays.asList(first));
both.addAll(Arrays.asList(second));

both.toArray(new String[0]);

Comments

উত্তরটি দুর্দান্ত তবে একটি সামান্য বিভক্ত। এটিকে নিখুঁত করার জন্য আপনার প্রয়োজনীয় ধরণের অ্যারে () এ অ্যারে যেতে হবে pass উপরের উদাহরণে, কোড হওয়া উচিত: both.toArray (নতুন স্ট্রিং [0]) দেখুন: stackoverflow.com/questions/4042434/...

— রনেন Rabinovici

কেন এই উত্তরটিকে উচ্চতর রেট দেওয়া হয়নি তা জানেন না ... যদিও এটির জন্য @ রোনেনরবিনোভিসি প্রস্তাবিত পরিবর্তনের প্রয়োজন বলে মনে হচ্ছে

— drmrbrewer

বা আরও ভাল, শূন্য-দৈর্ঘ্যের অ্যারের অপ্রয়োজনীয় বরাদ্দ ছাড়াই both.toArray(new String[both.size()])

— :;

@Honza পড়া সুপারিশ

— হোলগার

হাই @ হোনজা, 3 লাইনে কোনও আদিম পূর্ণসংখ্যার অ্যারে ফেরত দেওয়ার জন্য একই কাজ করা সম্ভব?

— জাম্পিং_মোনকি

Answer 12

স্ট্রিম ব্যবহার করে জাভা 8 এর সাথে অন্য একটি উপায়

  public String[] concatString(String[] a, String[] b){ 
    Stream<String> streamA = Arrays.stream(a);
    Stream<String> streamB = Arrays.stream(b);
    return Stream.concat(streamA, streamB).toArray(String[]::new); 
  }

Answer 13

জেনেরিক্স পুনঃনির্মাণিত সহ সিলভার্টব এর সমাধানটির এখানে একটি রূপান্তরকরণ রয়েছে:

static <T> T[] concat(T[] a, T[] b) {
    final int alen = a.length;
    final int blen = b.length;
    final T[] result = (T[]) java.lang.reflect.Array.
            newInstance(a.getClass().getComponentType(), alen + blen);
    System.arraycopy(a, 0, result, 0, alen);
    System.arraycopy(b, 0, result, alen, blen);
    return result;
}

দ্রষ্টব্য: জাভা 6 সমাধানের জন্য জোচিমের উত্তর দেখুন । এটি কেবল সতর্কতা দূর করে না; এটি আরও খাটো, আরও দক্ষ এবং পড়া সহজ!

Comments

আপনি এই পদ্ধতির জন্য সতর্কতা দমন করতে পারেন, তবে এর চেয়ে অনেক কিছুই আপনি করতে পারেন না। অ্যারে এবং জেনেরিকগুলি আসলে মিশ্রিত হয় না।

— ড্যান ডায়ার

আপনি যদি অ্যারেস.কোপিওফ () ব্যবহার করেন তবে চেক না করা সতর্কতাটি দূর করা যাবে। একটি বাস্তবায়নের জন্য আমার উত্তর দেখুন।

— জোছিম সৌর

@ সাপ্রেস ওয়ার্নিংস ("চেক না করা")

— মার্ক রেনুফ

Answer 14

আপনি যদি এইভাবে ব্যবহার করেন তবে আপনার কোনও তৃতীয় পক্ষের শ্রেণি আমদানির দরকার নেই।

আপনি যদি সম্মতি চান String

দুটি স্ট্রিং অ্যারে সংক্ষিপ্তকরণের জন্য নমুনা কোড

public static String[] combineString(String[] first, String[] second){
        int length = first.length + second.length;
        String[] result = new String[length];
        System.arraycopy(first, 0, result, 0, first.length);
        System.arraycopy(second, 0, result, first.length, second.length);
        return result;
    }

আপনি যদি সম্মতি চান Int

দুটি পূর্ণসংখ্যার অ্যারে সংক্ষিপ্ত কোডের জন্য নমুনা কোড

public static int[] combineInt(int[] a, int[] b){
        int length = a.length + b.length;
        int[] result = new int[length];
        System.arraycopy(a, 0, result, 0, a.length);
        System.arraycopy(b, 0, result, a.length, b.length);
        return result;
    }

এখানে মেইন মেথড

    public static void main(String[] args) {

            String [] first = {"a", "b", "c"};
            String [] second = {"d", "e"};

            String [] joined = combineString(first, second);
            System.out.println("concatenated String array : " + Arrays.toString(joined));

            int[] array1 = {101,102,103,104};
            int[] array2 = {105,106,107,108};
            int[] concatenateInt = combineInt(array1, array2);

            System.out.println("concatenated Int array : " + Arrays.toString(concatenateInt));

        }
    }  

আমরাও এইভাবে ব্যবহার করতে পারি।

Answer 15

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

@SuppressWarnings("unchecked")
public static <T> T[] concat(T[]... inputArrays) {
  if(inputArrays.length < 2) {
    throw new IllegalArgumentException("inputArrays must contain at least 2 arrays");
  }

  for(int i = 0; i < inputArrays.length; i++) {
    if(inputArrays[i] == null) {
      throw new IllegalArgumentException("inputArrays[" + i + "] is null");
    }
  }

  int totalLength = 0;

  for(T[] array : inputArrays) {
    totalLength += array.length;
  }

  T[] result = (T[]) Array.newInstance(inputArrays[0].getClass().getComponentType(), totalLength);

  int offset = 0;

  for(T[] array : inputArrays) {
    System.arraycopy(array, 0, result, offset, array.length);

    offset += array.length;
  }

  return result;
}

Comments

আপনি যে নাল চেক করছেন সেখানে আমি একই লুপটির দৈর্ঘ্যটি যোগ করব - তবে এটি অন্যান্য উত্তরগুলির সত্যিই খুব ভাল সংক্ষিপ্তসার। আমি বিশ্বাস করি এটি এমনকি পূর্ণসংখ্যক অবজেক্টগুলিতে পরিবর্তন না করে "ইনট" জাতীয় অভ্যন্তরীণ ধরণের হ্যান্ডলগুলিও পরিচালনা করে যা কেবল অ্যারেলিস্টে সবকিছু পরিবর্তনের পরিবর্তে অ্যারে হিসাবে তাদের মোকাবেলা করার একমাত্র কারণ। এছাড়াও আপনার পদ্ধতিতে 2 টি অ্যারে এবং একটি (...) প্যারামিটার লাগতে পারে যাতে কলার জানেন যে এটি চালানোর আগে এবং ত্রুটিটি দেখার আগে তাকে কমপক্ষে দুটি অ্যারে পাস করতে হবে তবে লুপিং কোডটি জটিল করে তোলে ....

— বিল কে

Answer 16

আপনি এটিকে অ্যারেলিস্টে রূপান্তর করতে চেষ্টা করতে পারেন এবং অ্যাডএল পদ্ধতিটি ব্যবহার করে আবার অ্যারেতে রূপান্তর করতে পারেন।

List list = new ArrayList(Arrays.asList(first));
  list.addAll(Arrays.asList(second));
  String[] both = list.toArray();

Comments

ভাল সমাধান - অ্যারেলিস্টের পক্ষে পুরোপুরি অ্যারেগুলি এড়ানোর জন্য কোডটি যদি রিফ্যাক্ট করা হয় তবে এটি "উত্তর" এর নিয়ন্ত্রণের বাইরে এবং প্রশ্নকর্তার পক্ষে ভাল would

— বিল কে

আমি গণনা করি এটির জন্য কাজ করতে 4 অতিরিক্ত অস্থায়ী বস্তু প্রয়োজন।

— rghome

@ রাঘোম, কমপক্ষে এ জাতীয় সহজ কাজটি প্রয়োগ করার জন্য অতিরিক্ত গ্রন্থাগারের প্রয়োজন হবে না

— ফরিদ

Answer 17

জাভা 8+ স্ট্রিম ব্যবহার করে আপনি নিম্নলিখিত ফাংশনটি লিখতে পারেন:

private static String[] concatArrays(final String[]... arrays) {
    return Arrays.stream(arrays)
         .flatMap(Arrays::stream)
         .toArray(String[]::new);
}

Answer 18

সিলভার্টাব দ্বারা লিখিত সিউডো কোড সমাধানের কার্যকরী কোডের এখানে একটি সম্ভাব্য বাস্তবায়ন।

ধন্যবাদ সিলভার্টব!

public class Array {

   public static <T> T[] concat(T[] a, T[] b, ArrayBuilderI<T> builder) {
      T[] c = builder.build(a.length + b.length);
      System.arraycopy(a, 0, c, 0, a.length);
      System.arraycopy(b, 0, c, a.length, b.length);
      return c;
   }
}

এরপরে নির্মাতা ইন্টারফেসটি অনুসরণ করা হবে।

দ্রষ্টব্য: একজন নির্মাতা প্রয়োজনীয় কারণ জাভাতে এটি করা সম্ভব নয়

new T[size]

জেনেরিক ধরণের ক্ষয়ের কারণে:

public interface ArrayBuilderI<T> {

   public T[] build(int size);
}

এখানে একটি কংক্রিট নির্মাতা ইন্টারফেস প্রয়োগ করছে, একটি Integerঅ্যারে তৈরি করছে:

public class IntegerArrayBuilder implements ArrayBuilderI<Integer> {

   @Override
   public Integer[] build(int size) {
      return new Integer[size];
   }
}

এবং শেষ পর্যন্ত আবেদন / পরীক্ষা:

@Test
public class ArrayTest {

   public void array_concatenation() {
      Integer a[] = new Integer[]{0,1};
      Integer b[] = new Integer[]{2,3};
      Integer c[] = Array.concat(a, b, new IntegerArrayBuilder());
      assertEquals(4, c.length);
      assertEquals(0, (int)c[0]);
      assertEquals(1, (int)c[1]);
      assertEquals(2, (int)c[2]);
      assertEquals(3, (int)c[3]);
   }
}

Answer 19

এটি ওয়ান-লাইনার হওয়া উচিত।

public String [] concatenate (final String array1[], final String array2[])
{
    return Stream.concat(Stream.of(array1), Stream.of(array2)).toArray(String[]::new);
}

Answer 20

কি দারুন! বাহ্যিক নির্ভরতার উপর নির্ভর করে এমন কিছু সাধারণ জবাব সহ এখানে অনেক জটিল উত্তর। এটি কিভাবে এটি সম্পর্কে:

String [] arg1 = new String{"a","b","c"};
String [] arg2 = new String{"x","y","z"};

ArrayList<String> temp = new ArrayList<String>();
temp.addAll(Arrays.asList(arg1));
temp.addAll(Arrays.asList(arg2));
String [] concatedArgs = temp.toArray(new String[arg1.length+arg2.length]);

Comments

.. তবে অদক্ষ এবং ধীর।

— জোনাসসিজে - মনিকা

Answer 21

এটি কাজ করে তবে আপনার নিজের ত্রুটি পরীক্ষা করে inোকানো দরকার।

public class StringConcatenate {

    public static void main(String[] args){

        // Create two arrays to concatenate and one array to hold both
        String[] arr1 = new String[]{"s","t","r","i","n","g"};
        String[] arr2 = new String[]{"s","t","r","i","n","g"};
        String[] arrBoth = new String[arr1.length+arr2.length];

        // Copy elements from first array into first part of new array
        for(int i = 0; i < arr1.length; i++){
            arrBoth[i] = arr1[i];
        }

        // Copy elements from second array into last part of new array
        for(int j = arr1.length;j < arrBoth.length;j++){
            arrBoth[j] = arr2[j-arr1.length];
        }

        // Print result
        for(int k = 0; k < arrBoth.length; k++){
            System.out.print(arrBoth[k]);
        }

        // Additional line to make your terminal look better at completion!
        System.out.println();
    }
}

এটি সম্ভবত সবচেয়ে দক্ষ নয়, তবে এটি জাভার নিজস্ব API ছাড়া অন্য কোনও কিছুর উপর নির্ভর করে না।

Comments

+1 টি। এটির forসাথে দ্বিতীয় লুপটি প্রতিস্থাপন করা ভাল হবে :for(int j = 0; j < arr2.length; j++){arrBoth[arr1.length+j] = arr2[j];}

— ব্যান্সার

String[] arrBoth = java.util.Arrays.copyOf(arr1, arr1.length + arr2.length)প্রথম forলুপটি এড়িয়ে যেতে ব্যবহার করুন । আকারের সাথে আনুপাতিক সময় সাশ্রয় করে arr1।

— জন মেয়ার

Answer 22

এটি স্ট্রিং অ্যারের জন্য রূপান্তরিত ফাংশন:

public String[] mergeArrays(String[] mainArray, String[] addArray) {
    String[] finalArray = new String[mainArray.length + addArray.length];
    System.arraycopy(mainArray, 0, finalArray, 0, mainArray.length);
    System.arraycopy(addArray, 0, finalArray, mainArray.length, addArray.length);

    return finalArray;
}

Answer 23

কিভাবে সহজভাবে

public static class Array {

    public static <T> T[] concat(T[]... arrays) {
        ArrayList<T> al = new ArrayList<T>();
        for (T[] one : arrays)
            Collections.addAll(al, one);
        return (T[]) al.toArray(arrays[0].clone());
    }
}

এবং শুধু কি Array.concat(arr1, arr2)। যতক্ষণ arr1এবং arr2একই ধরণের হয়, এটি আপনাকে একই ধরণের আরেকটি অ্যারে দেয় যেখানে উভয় অ্যারে রয়েছে।

Comments

পারফরম্যান্সের কারণে, আমি অ্যারেলিস্টের চূড়ান্ত আকারের প্রাক-গণনা করব কারণ সংজ্ঞা অনুসারে অ্যারেলিস্ট একটি নতুন অ্যারে বরাদ্দ করে এবং বর্তমান অ্যারেটি পূর্ণ হওয়ার সাথে সাথে তার উপাদানগুলি অনুলিপি করে। অন্যথায় আমি সরাসরি লিঙ্কডলিস্টে যাব যা এ জাতীয় সমস্যায় ভুগছে না

— usr-local-

Answer 24

একটি জেনেরিক স্ট্যাটিক সংস্করণ যা @ সাপ্রেস ওয়ার্নিংস টিকা রোধ ছাড়াই উচ্চতর পারফর্মিং সিস্টেম.আরেকেপি ব্যবহার করে:

public static <T> T[] arrayConcat(T[] a, T[] b) {
    T[] both = Arrays.copyOf(a, a.length + b.length);
    System.arraycopy(b, 0, both, a.length, b.length);
    return both;
}

Answer 25

public String[] concat(String[]... arrays)
{
    int length = 0;
    for (String[] array : arrays) {
        length += array.length;
    }
    String[] result = new String[length];
    int destPos = 0;
    for (String[] array : arrays) {
        System.arraycopy(array, 0, result, destPos, array.length);
        destPos += array.length;
    }
    return result;
}

Answer 26

জোছিম সউরের কনক্যাটএল-এর আমার সামান্য উন্নত সংস্করণ এখানে। এটি জাভা 5 বা 6 তে কাজ করতে পারে, জাভা 6 এর সিস্টেম.আর্রাইকপি ব্যবহার করে এটি রানটাইম এ উপলব্ধ থাকলে। এই পদ্ধতিটি (আইএমএইচও) অ্যান্ড্রয়েডের জন্য উপযুক্ত, কারণ এটি অ্যান্ড্রয়েড <9 -এ কাজ করে (যার সিস্টেম.আররেইকপি নেই) তবে সম্ভব হলে দ্রুত পদ্ধতিটি ব্যবহার করবে।

  public static <T> T[] concatAll(T[] first, T[]... rest) {
    int totalLength = first.length;
    for (T[] array : rest) {
      totalLength += array.length;
    }
    T[] result;
    try {
      Method arraysCopyOf = Arrays.class.getMethod("copyOf", Object[].class, int.class);
      result = (T[]) arraysCopyOf.invoke(null, first, totalLength);
    } catch (Exception e){
      //Java 6 / Android >= 9 way didn't work, so use the "traditional" approach
      result = (T[]) java.lang.reflect.Array.newInstance(first.getClass().getComponentType(), totalLength);
      System.arraycopy(first, 0, result, 0, first.length);
    }
    int offset = first.length;
    for (T[] array : rest) {
      System.arraycopy(array, 0, result, offset, array.length);
      offset += array.length;
    }
    return result;
  }

Comments

ভাল সাধারণ ধারণা, তবে বাস্তবায়নকারী কারও কাছে: আমি প্রতিবিম্বের মাধ্যমে উভয়রকমের চেয়ে একটি অনুলিপি ও নন-অনুলিপি সংস্করণ পছন্দ করব।

— রেকটিড

Answer 27

প্রশ্নটি সম্পর্কে চিন্তা করার আরও একটি উপায়। দুই বা ততোধিক অ্যারে সংমিশ্রিত করার জন্য আপনাকে প্রতিটি অ্যারের সমস্ত উপাদান তালিকাবদ্ধ করতে হবে এবং তারপরে একটি নতুন অ্যারে তৈরি করতে হবে। এটি একটি তৈরি করা List<T>এবং তারপরে কল toArrayকরার মতো শোনাচ্ছে । কিছু অন্যান্য উত্তর ব্যবহার করে ArrayList, এবং এটি ঠিক আছে। তবে কীভাবে আমাদের নিজের বাস্তবায়ন? এটি কঠিন নয়:

private static <T> T[] addAll(final T[] f, final T...o){
    return new AbstractList<T>(){

        @Override
        public T get(int i) {
            return i>=f.length ? o[i - f.length] : f[i];
        }

        @Override
        public int size() {
            return f.length + o.length;
        }

    }.toArray(f);
}

আমি বিশ্বাস করি যে উপরেরটি সমাধানগুলির সমতুল্য System.arraycopy। তবে আমি মনে করি এটির একটি নিজস্ব সৌন্দর্য আছে।

Answer 28

কেমন :

public String[] combineArray (String[] ... strings) {
    List<String> tmpList = new ArrayList<String>();
    for (int i = 0; i < strings.length; i++)
        tmpList.addAll(Arrays.asList(strings[i]));
    return tmpList.toArray(new String[tmpList.size()]);
}

Answer 29

একাধিক অ্যারে যোগদানের অনুমতি দেয় এমন একটি সাধারণ প্রকরণ:

public static String[] join(String[]...arrays) {

    final List<String> output = new ArrayList<String>();

    for(String[] array : arrays) {
        output.addAll(Arrays.asList(array));
    }

    return output.toArray(new String[output.size()]);
}

Answer 30

কেবল জাভাসের নিজস্ব এপিআই ব্যবহার করে:

String[] join(String[]... arrays) {
  // calculate size of target array
  int size = 0;
  for (String[] array : arrays) {
    size += array.length;
  }

  // create list of appropriate size
  java.util.List list = new java.util.ArrayList(size);

  // add arrays
  for (String[] array : arrays) {
    list.addAll(java.util.Arrays.asList(array));
  }

  // create and return final array
  return list.toArray(new String[size]);
}

এখন, এই কোডটি সবচেয়ে কার্যকর নয়, তবে এটি কেবল মানক জাভা শ্রেণীর উপর নির্ভর করে এবং এটি সহজেই বোঝা যায়। এটি যে কোনও সংখ্যক স্ট্রিং [] (এমনকি শূন্য অ্যারে) এর জন্য কাজ করে।

Comments

সমস্ত অপ্রয়োজনীয় তালিকা অবজেক্ট তৈরির জন্য এটিকে একটি ডাউনওয়েট করতে হয়েছিল।

— আউটলা প্রোগ্রামার