উত্তর:
আপনি অ্যারেস্ট্রিম ডিম ব্যবহার করতে পারেন
Arrays.stream(array);
আপনি Stream.of
@fge দ্বারা উল্লিখিত হিসাবে ব্যবহার করতে পারেন , যা দেখতে ভাল লাগে
public static<T> Stream<T> of(T... values) {
return Arrays.stream(values);
}
তবে নোটটি Stream.of(intArray)
ফিরে আসবে Stream<int[]>
যেখানে Arrays.stream(intArr)
আপনাকে IntStream
টাইপের একটি অ্যারে পাস করে প্রদান করবে int[]
। সুতরাং আদিম টাইপের সংক্ষেপে আপনি 2 টি পদ্ধতির উদাহরণের মধ্যে পার্থক্য পর্যবেক্ষণ করতে পারেন
int[] arr = {1, 2};
Stream<int[]> arr1 = Stream.of(arr);
IntStream stream2 = Arrays.stream(arr);
আপনি যখন আদিম অ্যারেটি পাস করেন Arrays.stream
, নীচের কোডটি চাওয়া হয়
public static IntStream stream(int[] array) {
return stream(array, 0, array.length);
}
এবং আপনি যখন Stream.of
নিম্নলিখিত কোডটিতে আদিম অ্যারে পাস করেন তখন আপনাকে অনুরোধ করা হয়
public static<T> Stream<T> of(T t) {
return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
}
অতএব আপনি বিভিন্ন ফলাফল পেতে।
আপডেট : স্টুয়ার্ট মার্কস মন্তব্য হিসাবে উল্লিখিত হিসাবে এর subrange ওভারলোড Arrays.stream
ব্যবহার করা পছন্দনীয় Stream.of(array).skip(n).limit(m)
কারণ একটি SIZED প্রবাহে প্রাক্তন ফলাফল যেখানে দ্বিতীয়টি হয় না। কারণটি হ'ল limit(m)
আকারটি মিটার বা মিটারের চেয়ে কম কিনা তা জানে না, যেখানে Arrays.stream
রেঞ্জটি চেক করে এবং স্ট্রিমের সঠিক আকারটি জানে আপনি Arrays.stream(array,start,end)
এখানে ফিরে আসা স্ট্রিম বাস্তবায়নের জন্য উত্স কোডটি পড়তে পারেন , অন্যদিকে স্ট্রিম বাস্তবায়নের জন্য Stream.of(array).skip().limit()
রয়েছে মধ্যে এই পদ্ধতি ।
Stream.of
কিছু চমক দিতে পারে (যেমন আপনি যখন Arrays.asList
কোনও আদিম অ্যারে দিয়ে কল করেন এবং লোকেরা List<Integer>
ফিরে প্রত্যাশা করেন ) :-)
Arrays.stream
অ্যারের একটি পরিসর স্ট্রিমিং সমর্থন IntStream.of
করে , যা না। এর বিপরীতে, Stream.of
ভাল পছন্দ যদি তুমি চান একটি Stream<int[]>
আকারের 1
...
Arrays.stream
ব্যবহার করা পছন্দনীয় Stream.of(array).skip(n).limit(m)
কারণ পূর্ববর্তী ফলাফলগুলি এসআইজেড স্ট্রিমে প্রবাহিত হয় যদিও এর পরে নেই। কারণটি হ'ল limit(m)
আকারটি m
কম বা কম কিনা তা জানে না m
, তবে Arrays.stream
রেঞ্জটি চেক করে এবং প্রবাহের সঠিক আকারটি জানে।
Arrays.stream(array,start,end)
ফেরৎ একটি Stream
যার বাস্তবায়ন এখানে , যেহেতু Stream.of(array).skip().limit()
আয় একটি Stream
যার বাস্তবায়ন মধ্যে এই পদ্ধতি ।
@ Sol4me এর সমাধানের বিকল্প:
Stream.of(theArray)
এই এবং এর মধ্যে পার্থক্যের মধ্যে Arrays.stream()
: যদি আপনার অ্যারেটি কোনও আদিম ধরণের হয় তবে এটি কোনও পার্থক্য করে। উদাহরণস্বরূপ, যদি আপনি এটি করেন:
Arrays.stream(someArray)
যেখানে someArray
একটি long[]
, এটি একটি ফিরে আসবে LongStream
। Stream.of()
অন্যদিকে, Stream<long[]>
একটি একক উপাদান সহ একটি প্রদান করবে ।
Arrays.stream()
কাজ করে
*Stream.of()
সময় আপনার যখন কল করার দরকার নেই Arrays.stream()
। এবং অ্যারেগুলি সত্যিকারের বস্তু হিসাবে না থেকে যায়, ঠিক আছে, এটি জাভা, এটি 1.0 এর পর থেকে তাই এটি মোকাবেলা করুন; এই উপর ব্রীডিং কিছুই সাহায্য করে
Arrays.stream()
সুবিধাজনক না বিবেচনা , আমি এটি সুবিধাজনক হিসাবে বিবেচনা। যথেষ্ট বলেছ.
*Stream.of()
পক্ষে আরও সুবিধাজনক; কারণ এটি পছন্দের বিষয় । আমি এই Arrays.stream()
জাতীয় ক্ষেত্রে বেশি পছন্দ করি , যা সাধারণ নিয়ম হিসাবে Stream.of()
এটি আরও বেশি সুবিধাজনক (পানো বীজগণিত) হিসাবে ভুল করে তোলে ।
Stream.of("foo", "bar", "baz")
অথবা, আপনার যদি ইতিমধ্যে অ্যারে থাকে তবে আপনি এটি করতেও পারেন
Stream.of(array)
আদিম ধরণের ব্যবহার IntStream.of
বা LongStream.of
ইত্যাদির জন্য
int[]
ভ্যারেজ গ্রহণ করার পদ্ধতিতে পাস করা যায়, তবে তার পরিবর্তে কেন Stream.of(intArray)
উত্পাদন হবে না ? এছাড়াও, আদিমদের জন্য বিশেষ স্ট্রিম শ্রেণি রয়েছে কেন এমন কোনও প্রযুক্তিগত যুক্তি রয়েছে? Stream<Integer>
Stream<int[]>
int[]
অন্যান্য অ্যারে মত নয়। এটি একটি উপশ্রেণী নয় Object[]
, কিন্তু এটি হল একটি উপশ্রেণী Object
। সুতরাং, আপনি যখন এটি পাস করেন Stream.of
, এটি Object
, প্যারামিটার হিসাবে নেওয়া হয় এবং আপনি এর স্ট্রিম পান int[]
। আদিম জন্য বিশেষায়িত ক্লাস করার অন্যতম কারণ - আপনি যদি আদিম অ্যারেগুলি থেকে স্ট্রিম তৈরি না করেন তবে বেশ বেদনাদায়ক হবে। অন্য কারণটি হ'ল বিশেষায়িত ক্লাসগুলি আরও দক্ষ, কারণ Object
বক্সিং থেকে ওভারহেড ব্যয় করার প্রয়োজন নেই ( এটিকে সাধারণ জিনিসের মতো দেখতে রূপান্তর int
করা Integer
)।
int[]
এটি একটি Object
, এটি ওভারলোডেড পদ্ধতির সাথে মিলবে of(T t)
এবং তাই এটি ফিরে আসে Stream<int[]>
। সুতরাং, তাত্ত্বিকভাবে বলতে গেলে, যদি এই পদ্ধতিটি না পাওয়া যেত, তবে আমরা কি তার বিনিময়ে Stream<Integer>
পাইতাম? বা সম্ভবত এটি একটি সংকলন ত্রুটির ফলস্বরূপ কারণ এটি ম্যাচের পদ্ধতিটি খুঁজে পায় না? অর্থাত্ int[]
চিকিত্সা করা যায় নাT...
Stream<Integer>
সেভাবে Stream.of(t ... T)
পেতাম না , কারণ এখনও একইভাবে মেলে।
আপনি এটি নিম্ন স্তরের পদ্ধতিতেও তৈরি করতে পারেন যার সমান্তরাল বিকল্প রয়েছে:
/**
* Creates a new sequential or parallel {@code Stream} from a
* {@code Spliterator}.
*
* <p>The spliterator is only traversed, split, or queried for estimated
* size after the terminal operation of the stream pipeline commences.
*
* @param <T> the type of stream elements
* @param spliterator a {@code Spliterator} describing the stream elements
* @param parallel if {@code true} then the returned stream is a parallel
* stream; if {@code false} the returned stream is a sequential
* stream.
* @return a new sequential or parallel {@code Stream}
*
* <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel)
*/
StreamSupport.stream(Arrays.spliterator(array, 0, array.length), true)
আপনি অ্যারে স্ট্রিম ব্যবহার করতে পারেন:
(অ্যারে) Arrays.stream;
এটি আপনার অ্যারের ইনপুট প্রকারের উপর ভিত্তি করে বাষ্পের রিটার্নের ধরণটি নিশ্চিত করে যদি এটির String []
পরে ফিরে আসে Stream<String>
, তবে যদি ফিরে int []
আসেIntStream
আপনি যদি ইতিমধ্যে ইনপুট টাইপ অ্যারে জানেন তবে নির্দিষ্ট ইনপুট টাইপের মতো ব্যবহার করা ভাল int[]
IntStream.of (অ্যারে);
এটি ইনটস্ট্রিমটি ফিরিয়ে দেয়।
প্রথম উদাহরণ হিসাবে, জাভা overloading
ইনপুট ধরণের ভিত্তিতে সুনির্দিষ্ট পদ্ধতি সন্ধানের জন্য পদ্ধতিটি ব্যবহার করে যখন দ্বিতীয় হিসাবে আপনি ইতিমধ্যে ইনপুট প্রকার এবং কলিং নির্দিষ্ট পদ্ধতিটি জানেন।
Arrays.stream
আদিম অ্যারেগুলির জন্য সমস্ত ওভারলোডেড কেস রয়েছে। অর্থাতStream.of(new int[]{1,2,3})
একটি দিতে হবেStream<int[]>
যেহেতুArrays.stream
দেব আপনি একটি ব্যাকIntStream
যা সম্ভবত আপনি যা চান তা। সুতরাং +1