Rafael del Nero on foojay.io - Friends of OpenJDK

Foojay Podcast #65: Boost Your Career in 2025!

Mon, 20 Jan 2025 08:37:01 +0000

With the first Foojay podcast of 2025, we want to help you to boost your career!

By now, you’ve likely had your year-end performance review with your manager and set some goals to advance in the coming year. Are you ready to take your career growth into your own hands?

I’ve invited three fantastic guests who are eager to share their experiences and help you elevate your professional journey.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Streams Set Distinct Java Code Quiz

Thu, 11 Nov 2021 09:36:45 +0000

Using Streams and Set Collection Factory methods with Java makes code easier to read and maintain.

By using these features, we can also make it more difficult for bugs to remain hidden. If you can use the latest LTS (Long-term support) Java version in your project, it’s the best scenario, so that you can use cool Java features such as Collection Factories from Java 9 onwards.

Now that we know why it’s important to understand Java features well, it’s time for the Java Challenge!

Exception Chaos Java Code Quiz

Wed, 27 Oct 2021 15:03:38 +0000

Working correctly with exceptions is crucial to a high-quality application that users enjoy using. This quiz reinforces some of the basic concepts of exceptions.

Therefore, what do you think will happen when running the following code?

import java.io.FileNotFoundException;

public class ExceptionChaosChallenge {
 static String s = "-";

 public static void main(String... doYouBest) {
 try {
 throw new IllegalArgumentException();
 } catch (Exception e) {
 try {
 try {
 throw new FileNotFoundException();
 } catch (RuntimeException ex) {
 s += "run";
 }
 throw new NullPointerException();
 } catch (Exception x) {
 s += "exc";
 } finally {
 s += "fin";
 }
 } finally {
 s += "of";
 try {
 throw new VirtualMachineError("JVMError") {};
 } catch (Error error) {
 s += "error" + error.getMessage();
 }
 }

 System.out.println(s);
 }

}

A) -runfinoferror

Arrays and Object Reference Java Challenge Code Quiz

Wed, 29 Sep 2021 11:18:13 +0000

Arrays are objects in Java.

Variables in Java actually store references to the object, instead of the real object.

When we pass an object reference to a method, we are changing the object that is in the heap of the memory.

Considering the explanation above, can you solve the following Java Challenge? What is going to happen when you run the following code?

public class ArrayChallenge2 {
 public static void main(String... doYourBest) {
 int[] anyArray = new int[5];
 anyArray[0] = 0;
 anyArray[1] = 2;
 anyArray[2] = 4;
 anyArray[3] = 6;
 anyArray[4] = 8;

 int[] otherArray = anyArray;
 doSum(anyArray);
 doSum(otherArray);

 Arrays.stream(anyArray).forEach(System.out::println);
 }
 private static void doSum(int[] anyArray) {
 for (int i = 0; i < anyArray.length; i++) {
 anyArray[i] = anyArray[i] + 2;
 }
 }
}

a) 0

Parallel Streams Java Code Quiz

Wed, 15 Sep 2021 09:04:38 +0000

Using streams concurrently with the parallel method is a good idea to optimize performance.

However, it’s not always the case that we can use the parallel method, for example, when we depend on the order of logic execution. When we can process the method concurrently, the parallel method comes in handy.

In the following Java Challenge, we will explore the use of parallel streams with the forEachOrdered method!

It’s time to improve your Java skills with this Parallel Stream Java Challenge

Daemon Thread Java Code Quiz

Wed, 08 Sep 2021 07:29:56 +0000

When we are working with Threads, it’s important to know when to use a daemon or a non-daemon Thread.

Do you know if the main Thread is a daemon or not? And do you know what a daemon Thread is?

That’s what you will find out by trying out the following Java Challenge!

It’s time to improve your Java skills with this Daemon Thread Challenge…

Daemon Thread Challenge

What will happen when running the following main method?

Function Calculation Java Challenge

Wed, 01 Sep 2021 10:10:19 +0000

Functional programming is a very powerful paradigm that makes code more concise and easier to understand.

In Java, the “Function” functional interface can be used as a first-class citizen function, meaning that we can pass a function to a method and declare it as a variable, giving the developer a lot of power.

And now it’s time for you now to test your abilities with lambdas and functional interfaces! Get ready!

Stream Limit Filter Java Challenge

Tue, 17 Aug 2021 07:00:03 +0000

To manipulate data from a collection by using a Java stream is handy and cleaner than the alternatives.

When you learn how to use streams, your Java code will be much better, and knowing how to limit and filter data with streams is crucial for you to do something useful with streams in Java.

Without further ado, let’s go to the next Java Challenge!

It’s time to improve your Java skills with this Limit Stream Challenge.

Neo Stream Search Java Challenge

Mon, 26 Jul 2021 08:32:40 +0000

Understanding the mechanics of the functional interface Predicate of a Stream is crucial if you want to create something meaningful with streams. On this challenge, we will explore important key methods when we work with a stream so that it becomes clear for you what they do.

Without further ado, let’s go to the Java Challenge!

It’s time to improve your Java skills with this Neo Stream Search Challenge

Neo Stream Search Challenge

What do you think will happen when running the following code?

Join The Jedi Lambda Join Java Challenge!

Wed, 21 Jul 2021 08:08:24 +0000

There are many concepts involved in Java Challenge! In essence, we will explore lambdas and the Function interface the most. However, we also have static methods introduced in Java 8 the private method in interfaces introduced in Java 9. In the invocation of the interface methods, we are using anonymous inner classes too!

Are you ready for this Java Challenge? Less introduction, more action, try out this Java Challenge, and master Java concepts by having fun!

Soprano ofNullable stream Java Challenge

Mon, 05 Jul 2021 08:21:54 +0000

Since Java 9, it’s possible to use Optional with a stream when we need to manipulate values from a List.

In this Java Challenge, we will explore the use of a stream in an Optional!

Are you ready to solve this Java Challenge? It’s time to improve your Java skills with this Soprano ofNullable stream Challenge…

Soprano ofNullable filter Challenge

What will happen after the main method is executed as follows?

Method Reference VS Lambda Java Challenge

Tue, 29 Jun 2021 19:31:00 +0000

Do you know what the differences are between method references and lambdas?

In this Java Challenge, we will explore how lambdas and method references behave so that you can really understand how they work!

Now that you know the main context, it’s time for the Java Challenge!

It’s time to improve your Java skills with this Method Reference VS Lambda Challenge.

Method Reference VS Lambda Challenge

What will happen when we run the following main method?

Hidden Dracula Polymorphism Java Challenge

Mon, 14 Jun 2021 11:26:37 +0000

Polymorphism is one of the most important Java concepts. We might not even be aware we’re using it all the time but when we instantiate an ArrayList and assign it to a variable of the List type, we are using polymorphism. It’s a powerful concept because it helps us to decouple responsibilities, therefore, making code more flexible and easier to maintain.

This Java Challenge is one of the hardest ones, are you ready for this one? Now is your time to improve your Java skills by doing this Java Challenge!

Asynchronous CompletableFuture Java Challenge

Tue, 01 Jun 2021 07:42:43 +0000

The Completable Future feature is powerful for better performance when running asynchronous methods.

In Java 5, there is the Future interface, however, the Future interface doesn’t have many methods that would help us to create robust code. To solve the limitations of the Future interface, we have the CompletableFuture API with methods that will help us to build reliable high-performant software.

Now that we had the intro about CompletableFuture, let’s go to the Java Challenge!

Take the Type Erasure Generics Java Challenge!

Tue, 25 May 2021 06:50:45 +0000

It’s possible to use type erasure generics in a method with Java. To know how to use generics is important because then you are able to create highly reusable code.

In the following Java Challenge, you will see the generic type that will be erased by the compiler and then will be replaced by the type we defined at runtime.

Note also that we are using the extends keyword which means that the generic type will extend the other type.

The Map, Equals, Hashcode Java Challenge

Mon, 17 May 2021 08:38:13 +0000

Understanding deeply how to use a Map, equals, and hashcode in Java will be a massive help for you to create high-quality code. The Map and object reference concepts are not only present in the Java language but in almost all programming languages. Therefore, if you master the concept of object references, equals and hashcode, and Maps, you can apply this in other programming languages and master them far more easily.

Optional takeWhile dropWhile Java Challenge

Mon, 10 May 2021 08:05:57 +0000

The Optional concept is present in many programming languages. The main goal of the Optional class is to avoid NullPointerException. It’s much easier to deal with null values when we use the concepts of an Optional.

In this challenge, we will also explore the takeWhile and dropWhile methods from Java 9. Therefore you will be upgrading your knowledge with Optional, takeWhile, and dropWhile!

Are you prepared to have fun with this Java Challenge and refine your Java skills?

New Book Announcement: "Java Challengers"

Mon, 03 May 2021 07:03:36 +0000

To get the best jobs and create massive value, you need to know Java very well. The newly released “Java Challengers” book is a way for you to challenge yourself with fun code challenges so that you will become a better Java developer.

This book contains more than 70 well-elaborated Java Challenges that will help you break your limits on your Java skills. Want to challenge yourself and become better? The Java Challengers is the book for you!