- Java IntStream Conversions
- 1. Introduction
- 2. IntStream to Array
- 3. IntStream to List
- 4. IntStream to String
- 5. Conclusions
- Java 8 – Convert IntStream to Integer Array (Integer[])
- Related posts:
- Submit a Comment Cancel reply
- Subscribe to our Newsletter
- About Techndeck
- Privacy Overview
- Guide to IntStream in Java
Java IntStream Conversions
The Kubernetes ecosystem is huge and quite complex, so it’s easy to forget about costs when trying out all of the exciting tools.
To avoid overspending on your Kubernetes cluster, definitely have a look at the free K8s cost monitoring tool from the automation platform CAST AI. You can view your costs in real time, allocate them, calculate burn rates for projects, spot anomalies or spikes, and get insightful reports you can share with your team.
Connect your cluster and start monitoring your K8s costs right away:
We rely on other people’s code in our own work. Every day.
It might be the language you’re writing in, the framework you’re building on, or some esoteric piece of software that does one thing so well you never found the need to implement it yourself.
The problem is, of course, when things fall apart in production — debugging the implementation of a 3rd party library you have no intimate knowledge of is, to say the least, tricky.
Lightrun is a new kind of debugger.
It’s one geared specifically towards real-life production environments. Using Lightrun, you can drill down into running applications, including 3rd party dependencies, with real-time logs, snapshots, and metrics.
Learn more in this quick, 5-minute Lightrun tutorial:
Slow MySQL query performance is all too common. Of course it is. A good way to go is, naturally, a dedicated profiler that actually understands the ins and outs of MySQL.
The Jet Profiler was built for MySQL only, so it can do things like real-time query performance, focus on most used tables or most frequent queries, quickly identify performance issues and basically help you optimize your queries.
Critically, it has very minimal impact on your server’s performance, with most of the profiling work done separately — so it needs no server changes, agents or separate services.
Basically, you install the desktop application, connect to your MySQL server, hit the record button, and you’ll have results within minutes:
DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema.
The way it does all of that is by using a design model, a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.
And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.
The Kubernetes ecosystem is huge and quite complex, so it’s easy to forget about costs when trying out all of the exciting tools.
To avoid overspending on your Kubernetes cluster, definitely have a look at the free K8s cost monitoring tool from the automation platform CAST AI. You can view your costs in real time, allocate them, calculate burn rates for projects, spot anomalies or spikes, and get insightful reports you can share with your team.
Connect your cluster and start monitoring your K8s costs right away:
We’re looking for a new Java technical editor to help review new articles for the site.
1. Introduction
In this quick tutorial, we’ll go through all the possibilities regarding IntStream conversions to other types.
Interesting readings about boxing and unboxing or iterating are recommended as a complement of this tutorial.
2. IntStream to Array
Let’s start exploring how we can convert from an IntStream object to an array of ints.
For the sake of this example, let’s generate the first 50 even numbers and store them in an array as a result:
@Test public void intStreamToArray() < int[] first50EvenNumbers = IntStream.iterate(0, i ->i + 2) .limit(50) .toArray(); assertThat(first50EvenNumbers).hasSize(50); assertThat(first50EvenNumbers[2]).isEqualTo(4); >First, let’s create an infinite stream of integers starting at 0 and iterating by adding 2 to each element. Immediately after that, we need to add an intermediate operation limit in order to make this operation, somehow, terminating.
Finally, let’s use the terminating operation collect to gather this Stream to an array.
This is a straight-forward way of generating an array of ints.
3. IntStream to List
Let’s convert now an IntStream to a List of Integers.
In this case, just to add more variety to the example, let’s use the method range instead of the method iterate. This method will generate an IntStream from the int 0 to the int 50 (not included since it’s an open range):
@Test public void intStreamToList() < Listfirst50IntegerNumbers = IntStream.range(0, 50) .boxed() .collect(Collectors.toList()); assertThat(first50IntegerNumbers).hasSize(50); assertThat(first50IntegerNumbers.get(2)).isEqualTo(2); >In this example, we make use of the method range. The most notorious part here is using the method boxed, that, as its name points out, will box all the int elements in the IntStream and will return a Stream .
Finally, we can use a collector to get a list of integers.
4. IntStream to String
For our last topic, let’s explore how we could get a String from an IntStream.
In this case, we will generate just the first 3 ints (0, 1 and 2):
@Test public void intStreamToString()
First, in this case, we construct an IntStream with the constructor IntStream.of(). After having the Stream, we need to somehow generate a Stream from an IntStream. Hence, we can use the intermediate mapToObj method that will take an IntStream and will return a Stream of the type of the resulting object mapped in the method called.
Finally, we use the collector joining that takes a Stream and can append each element of the Stream by using a delimiter, and optionally a prefix and suffix.
5. Conclusions
In this quick tutorial, we have explored all the alternatives when we need to convert an IntStream to any other type. In particular, we went through examples as generating an array, a List, and a String.
And, as always, the sample code is available over on GitHub.
Slow MySQL query performance is all too common. Of course it is. A good way to go is, naturally, a dedicated profiler that actually understands the ins and outs of MySQL.
The Jet Profiler was built for MySQL only, so it can do things like real-time query performance, focus on most used tables or most frequent queries, quickly identify performance issues and basically help you optimize your queries.
Critically, it has very minimal impact on your server’s performance, with most of the profiling work done separately — so it needs no server changes, agents or separate services.
Basically, you install the desktop application, connect to your MySQL server, hit the record button, and you’ll have results within minutes:
Java 8 – Convert IntStream to Integer Array (Integer[])
Deepak Verma is a Test Automation Consultant and Software development Engineer for more than 10 years. His mission is to help you become an In-demand full stack automation tester. He is also the founder of Techndeck, a blog and online coaching platform dedicated to helping you succeed with all the automation basics to advanced testing automation tricks. View all posts
Related posts:
Submit a Comment Cancel reply
Subscribe to our Newsletter
About Techndeck
Techndeck.com is a blog revolves around software development & testing technologies. All published posts are simple to understand and provided with relevant & easy to implement examples.
Techndeck.com’s author is Deepak Verma aka DV who is an Automation Architect by profession, lives in Ontario (Canada) with his beautiful wife (Isha) and adorable dog (Fifi). He is crazy about technologies, fitness and traveling etc. He runs a Travel Youtube Channel as well. He created & maintains Techndeck.com
This website uses cookies to improve your experience. We’ll assume you’re ok with this, but you can opt-out if you wish. Cookie settingsACCEPT
Privacy Overview
This website uses cookies to improve your experience while you navigate through the website. Out of these cookies, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may have an effect on your browsing experience.
Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.
Any cookies that may not be particularly necessary for the website to function and is used specifically to collect user personal data via analytics, ads, other embedded contents are termed as non-necessary cookies. It is mandatory to procure user consent prior to running these cookies on your website.
Guide to IntStream in Java
Java IntStream class is a specialization of Stream interface for int primitive. It represents a stream of primitive int-valued elements supporting sequential and parallel aggregate operations.
IntStream is part of the java.util.stream package and implements AutoCloseable and BaseStream interfaces.
There are several ways of creating an IntStream .
This function returns a sequential ordered stream whose elements are the specified values.
It comes in two versions i.e. single element stream and multiple values stream.
- IntStream of(int t) – Returns stream containing a single specified element.
- IntStream of(int. values) – Returns stream containing specified all elements.
IntStream.of(10); //10 IntStream.of(1, 2, 3); //1,2,31.2. Generating ints in Range
The IntStream produced by range() methods is a sequential ordered stream of int values which is the equivalent sequence of increasing int values in a for-loop and value incremented by 1. This class supports two methods.
- range(int start, int end) – Returns a sequential ordered int stream from startInclusive (inclusive) to endExclusive (exclusive) by an incremental step of 1.
- rangeClosed(int start, int end) – Returns a sequential ordered int stream from startInclusive (inclusive) to endInclusive (inclusive) by an incremental step of 1.
IntStream.range(1, 5); //1,2,3,4 IntStream.rangeClosed(1, 5); //1,2,3,4,51.3. Infinite Streams with Iteration
The iterator() function is useful for creating infinite streams. Also, we can use this method to produce streams where values are increment by any other value than 1.
Given example produces first 10 even numbers starting from 0.
IntStream.iterate(0, i -> i + 2).limit(10); //0,2,4,6,8,10,12,14,16,181.4. Infinite Streams with IntSupplier
The generate() method looks a lot like iterator(), but differs by not calculating the int values by incrementing the previous value. Rather an IntSupplier is provided which is a functional interface is used to generate an infinite sequential unordered stream of int values.
Following example create a stream of 10 random numbers and then print them in the console.
IntStream stream = IntStream .generate(() -> < return (int)(Math.random() * 10000); >); stream.limit(10).forEach(System.out::println);To loop through the elements, stream support the forEach() operation. To replace simple for-loop using IntStream , follow the same approach.
IntStream.rangeClosed(0, 4) .forEach( System.out::println );We can apply filtering on int values produced by the stream and use them in another function or collect them for further processing.
For example, we can iterate over int values and filter/collect all prime numbers up to a certain limit.
IntStream stream = IntStream.range(1, 100); List primes = stream.filter(ThisClass::isPrime) .boxed() .collect(Collectors.toList()); public static boolean isPrime(int i) < IntPredicate isDivisible = index ->i % index == 0; return i > 1 && IntStream.range(2, i).noneMatch(isDivisible); >4. Converting IntStream to Array
Use IntStream.toArray() method to convert from the stream to int array.
int[] intArray = IntStream.of(1, 2, 3, 4, 5).toArray();5. Converting IntStream to List
Collections in Java can not store the primitive values directly. They can store only instances/objects.
Using boxed() method of IntStream , we can get a stream of wrapper objects which can be collected by Collectors methods.
List list = IntStream.of(1,2,3,4,5) .boxed() .collect(Collectors.toList());