অ্যারেটিকে কীভাবে তালিকায় পরিণত করবেন সে সম্পর্কে প্রশ্ন জিজ্ঞাসা করা হয়েছিল। এখনও অবধি বেশিরভাগ উত্তর দেখিয়েছে কীভাবে অ্যারে হিসাবে একই বিষয়বস্তু সহ একটি নতুন তালিকা তৈরি করা যায়, বা তৃতীয় পক্ষের লাইব্রেরিগুলিতে উল্লেখ করা হয়। তবে এই ধরণের রূপান্তরটির জন্য সহজ, অন্তর্নির্মিত বিকল্প রয়েছে। এর মধ্যে কয়েকটি ইতিমধ্যে অন্যান্য উত্তরে স্কেচ করা হয়েছে (যেমন এটি ) this তবে আমি এখানে বাস্তবায়নের জন্য স্বাধীনতার কয়েকটি ডিগ্রি তুলে ধরতে এবং বিস্তারিত জানাতে চাই এবং সম্ভাব্য সুবিধাগুলি, ঘাটতি এবং সতর্কতাগুলি প্রদর্শন করতে চাই।
কমপক্ষে দুটি গুরুত্বপূর্ণ পার্থক্য করতে হবে:
- ফলাফলের তালিকাটি অ্যারেতে একটি ভিউ হওয়া উচিত বা এটি একটি নতুন তালিকা হওয়া উচিত
- কিনা ফলে তালিকা থাকা উচিত সংশোধনযোগ্য বা না
বিকল্পগুলি এখানে দ্রুত সংক্ষিপ্ত করা হবে এবং এই উত্তরের নীচে একটি সম্পূর্ণ উদাহরণ প্রোগ্রাম দেখানো হবে।
অ্যারেতে একটি ভিউ তৈরি করা বনাম একটি নতুন তালিকা তৈরি করা
যখন ফলাফলটি একটি নতুন তালিকা হওয়া উচিত , তখন অন্য উত্তরগুলির একটি পদ্ধতির ব্যবহার করা যেতে পারে:
List<Long> list = Arrays.stream(array).boxed().collect(Collectors.toList());
তবে এটির ফলস্বরূপগুলি বিবেচনা করা উচিত: 1000000 longমান সহ একটি অ্যারে মোটামুটি 8 মেগাবাইট মেমরি দখল করবে। নতুন তালিকা করবে এছাড়াও মোটামুটিভাবে 8 মেগাবাইট ব্যাপৃত। এবং অবশ্যই, এই তালিকাটি তৈরি করার সময় পুরো অ্যারেটি অতিক্রম করতে হবে। অনেক ক্ষেত্রে, একটি নতুন তালিকা তৈরি করা সহজভাবে প্রয়োজনীয় নয়। পরিবর্তে, অ্যারেতে একটি ভিউ তৈরি করা যথেষ্ট :
// This occupies ca. 8 MB
long array[] = { /* 1 million elements */ }
// Properly implemented, this list will only occupy a few bytes,
// and the array does NOT have to be traversed, meaning that this
// operation has nearly ZERO memory- and processing overhead:
List<Long> list = asList(array);
( toListপদ্ধতিটি বাস্তবায়নের জন্য নীচে উদাহরণটি দেখুন )
অ্যারেতে একটি দর্শন থাকার বিষয়টি বোঝায় যে অ্যারেতে থাকা পরিবর্তনগুলি তালিকায় দৃশ্যমান হবে:
long array[] = { 12, 34, 56, 78 };
List<Long> list = asList(array);
System.out.println(list.get(1)); // This will print 34
// Modify the array contents:
array[1] = 12345;
System.out.println(list.get(1)); // This will now print 12345!
ভাগ্যক্রমে, ভিউ থেকে একটি অনুলিপি তৈরি করা (এটিরূপে একটি নতুন তালিকা যা অ্যারে পরিবর্তনগুলি দ্বারা প্রভাবিত হয় না) তুচ্ছ:
List<Long> copy = new ArrayList<Long>(asList(array));
এখন, এটি সত্যিকারের অনুলিপি, উপরে প্রদর্শিত স্ট্রিম-ভিত্তিক সমাধানের সাথে অর্জনের সমান।
একটি সংশোধনযোগ্য ভিউ বা একটি অশোধিত দৃশ্য তৈরি করা
অনেক ক্ষেত্রে তালিকাটি কেবল পঠনযোগ্য হলে তা যথেষ্ট হবে । ফলাফলের তালিকার বিষয়বস্তুগুলি প্রায়শই সংশোধন করা হয় না, তবে কেবল ডাউনস্ট্রিম প্রসেসিংয়ে পৌঁছে যা কেবল তালিকাটি পড়ে।
তালিকার সংশোধন করার অনুমতি দেওয়া কিছু প্রশ্ন উত্থাপন করেছে:
long array[] = { 12, 34, 56, 78 };
List<Long> list = asList(array);
list.set(2, 34567); // Should this be possible?
System.out.println(array[2]); // Should this print 34567?
list.set(3, null); // What should happen here?
list.add(99999); // Should this be possible?
পরিবর্তনযোগ্য যে অ্যারেতে একটি তালিকা ভিউ তৈরি করা সম্ভব । এর অর্থ এই যে তালিকাতে পরিবর্তনগুলি যেমন একটি নির্দিষ্ট সূচকে নতুন মান নির্ধারণের মতো অ্যারেতে দৃশ্যমান হবে।
তবে কাঠামোগতভাবে সংশোধনযোগ্য এমন একটি তালিকা ভিউ তৈরি করা সম্ভব নয় । এর মানে হল যে তালিকার আকারকে প্রভাবিত করে এমন ক্রিয়াকলাপ করা সম্ভব নয় । এটি কেবল কারণ অন্তর্নিহিত অ্যারের আকার পরিবর্তন করা যায় না।
নীচে একটি এমসিভিই রয়েছে যা বিভিন্ন প্রয়োগের বিকল্পগুলি এবং ফলাফলের তালিকাটি ব্যবহারের সম্ভাব্য উপায়গুলি দেখায়:
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.RandomAccess;
public class PrimitiveArraysAsLists
{
public static void main(String[] args)
{
long array[] = { 12, 34, 56, 78 };
// Create VIEWS on the given array
List<Long> list = asList(array);
List<Long> unmodifiableList = asUnmodifiableList(array);
// If a NEW list is desired (and not a VIEW on the array), this
// can be created as well:
List<Long> copy = new ArrayList<Long>(asList(array));
System.out.println("array : " + Arrays.toString(array));
System.out.println("list : " + list);
System.out.println("unmodifiableList: " + unmodifiableList);
System.out.println("copy : " + copy);
// Modify a value in the array. The changes will be visible
// in the list and the unmodifiable list, but not in
// the copy.
System.out.println("Changing value at index 1 of the array...");
array[1] = 34567;
System.out.println("array : " + Arrays.toString(array));
System.out.println("list : " + list);
System.out.println("unmodifiableList: " + unmodifiableList);
System.out.println("copy : " + copy);
// Modify a value of the list. The changes will be visible
// in the array and the unmodifiable list, but not in
// the copy.
System.out.println("Changing value at index 2 of the list...");
list.set(2, 56789L);
System.out.println("array : " + Arrays.toString(array));
System.out.println("list : " + list);
System.out.println("unmodifiableList: " + unmodifiableList);
System.out.println("copy : " + copy);
// Certain operations are not supported:
try
{
// Throws an UnsupportedOperationException: This list is
// unmodifiable, because the "set" method is not implemented
unmodifiableList.set(2, 23456L);
}
catch (UnsupportedOperationException e)
{
System.out.println("Expected: " + e);
}
try
{
// Throws an UnsupportedOperationException: The size of the
// backing array cannot be changed
list.add(90L);
}
catch (UnsupportedOperationException e)
{
System.out.println("Expected: " + e);
}
try
{
// Throws a NullPointerException: The value 'null' cannot be
// converted to a primitive 'long' value for the underlying array
list.set(2, null);
}
catch (NullPointerException e)
{
System.out.println("Expected: " + e);
}
}
/**
* Returns an unmodifiable view on the given array, as a list.
* Changes in the given array will be visible in the returned
* list.
*
* @param array The array
* @return The list view
*/
private static List<Long> asUnmodifiableList(long array[])
{
Objects.requireNonNull(array);
class ResultList extends AbstractList<Long> implements RandomAccess
{
@Override
public Long get(int index)
{
return array[index];
}
@Override
public int size()
{
return array.length;
}
};
return new ResultList();
}
/**
* Returns a view on the given array, as a list. Changes in the given
* array will be visible in the returned list, and vice versa. The
* list does not allow for <i>structural modifications</i>, meaning
* that it is not possible to change the size of the list.
*
* @param array The array
* @return The list view
*/
private static List<Long> asList(long array[])
{
Objects.requireNonNull(array);
class ResultList extends AbstractList<Long> implements RandomAccess
{
@Override
public Long get(int index)
{
return array[index];
}
@Override
public Long set(int index, Long element)
{
long old = array[index];
array[index] = element;
return old;
}
@Override
public int size()
{
return array.length;
}
};
return new ResultList();
}
}
উদাহরণের আউটপুট এখানে দেখানো হয়েছে:
array : [12, 34, 56, 78]
list : [12, 34, 56, 78]
unmodifiableList: [12, 34, 56, 78]
copy : [12, 34, 56, 78]
Changing value at index 1 of the array...
array : [12, 34567, 56, 78]
list : [12, 34567, 56, 78]
unmodifiableList: [12, 34567, 56, 78]
copy : [12, 34, 56, 78]
Changing value at index 2 of the list...
array : [12, 34567, 56789, 78]
list : [12, 34567, 56789, 78]
unmodifiableList: [12, 34567, 56789, 78]
copy : [12, 34, 56, 78]
Expected: java.lang.UnsupportedOperationException
Expected: java.lang.UnsupportedOperationException
Expected: java.lang.NullPointerException