DEV Community: Dylan

From Python to Java: Using JShell

Dylan — Fri, 15 Apr 2022 16:15:02 +0000

For most of my career, I've worked primarily as a Python developer. There were occasional trips into the frontend for some JavaScript or a brief detour through a Go application, but the vast majority of my work was solidly Python.

That is, until I joined Square. Square might be better known for its Ruby code, but there is also a sizable chunk of Java within its codebase. So when I came to Square, I knew I'd be putting away my list comprehensions, generators, and @decorators, and instead I'd be learning some new programming language patterns and idioms.

But of course, my Python experience would not be for nothing. As it turns out, we can find parallel ideas throughout most programming languages. In this series, I'll be highlighting some of these parallels I've encountered switching from Python to Java in hopes that it might help someone else who also finds themselves crossing this language barrier!

Introduction

One of the first pain points that a Python developer is going to encounter when picking up Java is the lack of an interpreter. When writing in Python, I would frequently want to "test drive" a short snippet of code. In those moments, I'd pop open a terminal, run python3, and try out my code. This made it easy to make slight adjustments and see the results instantaneously before settling on a solution. If I needed to call an existing function in my codebase, it was a simple import myModule away and suddenly I was interacting with my code in new ways.

Since Java is a compiled language, we can't enjoy this on-the-fly exploratory interaction with our code. We have to wrap our snippets in a big, ugly public static void main(String[] args) method within a class and then wait for it to compile just to see that we actually wanted to write it differently. What if I told you there was a better way?

Enter JShell

No, really. Enter jshell in your terminal. Assuming you have JDK 9+ installed, you should be greeted with the following.¹

|  Welcome to JShell -- Version 17.0.2
|  For an introduction type: /help intro

jshell>

JShell was introduced in Java 9 but is still massively underappreciated, so it's understandable if you haven't heard of it until now. JShell is a REPL² for Java code.

Starting to Explore

Imagine you've just read about the Streams API³ and you want to explore it for yourself before using it in your code. Within JShell, type the following and hit enter.

var names = Stream.of("Alice", "Adam", "Bob", "Charles")

Next, let's practice consuming the stream:

names.filter(name -> name.startsWith("A"))
     .map(String::toUpperCase)
     .collect(Collectors.toList())

Great! You should see the output immediately just like we'd expect when using the Python interpreter.

Play it back

Let's try consuming our stream again within the same session:

names.filter(name -> name.startsWith("A"))
     .map(String::toLowerCase)
     .collect(Collectors.toList())

IllegalStateException: stream has already been operated upon or closed

Looks like streams can only be used once! Rather than re-declaring our initial Stream object, let's take advantage of another JShell feature. Type /list to view a numbered list of every statement we've written in this session. Number 1 should be our names initialization. Let's re-execute that statement! Type /1 to rerun the variable initialization. Once the Stream has been reinstated, we can type /3 to rerun our last snippet!

jshell> /list

   1 : var names = Stream.of("Alice", "Adam", "Bob", "Charles");
   2 : names.filter(name -> name.startsWith("A"))
                   .map(String::toUpperCase)
                   .collect(Collectors.toList())
   3 : names.filter(name -> name.startsWith("A"))
                   .map(String::toLowerCase)
                   .collect(Collectors.toList())

jshell> /1
var names = Stream.of("Alice", "Adam", "Bob", "Charles");
names ==> java.util.stream.ReferencePipeline$Head@2b05039f

jshell> /3
names.filter(name -> name.startsWith("A"))
            .map(String::toLowerCase)
            .collect(Collectors.toList())
$5 ==> [alice, adam]

Interacting with other libraries

Sometimes you need more context. Maybe you want to test out a snippet of code that calls a method of one of your classes or that uses some third-party library. In Python we could simply import myModule to pull our code into the REPL session, or we could start the session already in context with the -m flag, python3 -m myModule.

With JShell the process isn't much different. The only distinction is that our application (or any other dependencies we're trying to work with) must first be added to our class path before we can import them.

Say we'd like to explore the Apache Commons Lang library and we've already downloaded its commons-lang3-3.12.0.jar somewhere on our computer. In order to import its packages within our JShell session, we have two options:

We can start the session with the library already loaded:
jshell --class-path /path/to/commons-lang3-3.12.0.jar
After starting a new JShell session, we can add it to our environment:
/env -class-path /path/to/commons-lang3-3.12.0.jar

Once loaded into our JShell environment, we can import its packages and try it out:

jshell> /env -class-path /path/to/commons-lang3-3.12.0.jar

jshell> import org.apache.commons.lang3.StringUtils

jshell> StringUtils.isBlank("  ")
$2 ==> true

Interacting with your own application code follows the same process once you've built your own .jar file.

Tip: Loading in an application's .jar and using its methods within a JShell session can make debugging issues in other environments like staging or production much easier - so long as you exercise the proper caution!

Java script?

One last feature I'd like to call out with JShell is the ability to create Java scripts. No, not Javascript. Java scripts. Essentially, JShell can read its commands from a file rather than from the terminal prompt. For example, save the following as helloWorld.jsh.

System.out.println("Hello world!")
/exit

We can then run it via jshell helloWorld.jsh. You probably shouldn't write all of your scripts in Java now, but it's nice to have the option!

From Python to Java: Comprehensions and Streams

Dylan — Fri, 08 Apr 2022 17:36:25 +0000

Introduction

It's impossible to avoid list (and dictionary!) comprehensions when working in Python. Whether you need to create a sublist by filtering out certain values, transform each element in an existing list, or rearrange keys and values into a new dictionary, comprehensions are a quintessential Python tool.

They're so useful in Python and so numerous that you might find yourself afraid that you can't do even the simplest tasks in Java. You might recall hearing other developers groan about Java's verbosity and heavy-handedness as you start writing...

List<Integer> evenIntegers = new ArrayList<Integer>();
for (Integer integer : allIntegers) {
    if (integer % 2 == 0) {
        evenIntegers.add(integer);
    }
}

...at least that's how I felt, until I learned about Streams. With Streams, we don't have to rewire our brains or begrudgingly write lengthy boilerplate for simple tasks.

`.stream()`, `.collect()`

However, this is Java and we are going to be writing some boilerplate. Types are everything in Java and in order to leverage the Streams API, we'll have to have an object of type Stream<T>. Luckily this is often as easy as calling .stream() on our object (assuming our object is iterable: a list, set, array, etc).

Once we have our Stream<T> object, we can apply a series of filters and transformations, but in the end we're going to want a list again (or a set, map, etc). This is where .collect() comes in along with various Collectors. In this post, we'll only focus on two Collector methods, Collectors.toList() and Collectors.toMap().

The basic structure of a stream is like so

obj.stream()
   <intermediate actions>
   .collect(...)

More verbose than Python, certainly, but not too bad!

So without further ado, let's check out a few common operations and how we might do them with Python's comprehensions and then with Java's Streams.

Filtering

Imagine we have a list of integers and we want only the even numbers. (The example is trivial, but I think it generalizes well enough.)

In Python we would solve this problem with a simple list comprehension¹:

even_nums = [n for n in list_of_nums if n % 2 == 0]

With Java Streams, we could accomplish this like so:

List<Integer> evenNums = listOfNums.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

Transforming

Sometimes we want to take one list of elements and transform them into something else. For a simple example, let's take our same list of integers and multiply each by two.

First in Python²,

doubled_nums = [n * 2 for n in list_of_nums]

and then with Java Streams,

List<Integer> doubledNums = listOfNums.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList());

Lists to Dictionaries

Not everything can be accomplished with lists³, sometimes we need to put things into a dictionary (or a Map, as they're called in Java land).

Suppose we have a list of User objects and we want a dictionary of each user.name keyed by their user.id.

names_by_id = {user.id: user.name for user in users}

It's a little more complicated in Java. In our previous examples, we used Collectors.toList(). Now that we want a Map, we'll have to use Collectors.toMap(). This collector asks for a lambda function to produce the key and another one to produce the value:

Map<Integer, String> namesById = users.stream()
    .collect(Collectors.toMap(
        user -> user.getId(),
        user -> user.getName()));

Conclusion

Java has a reputation for having a verbose syntax, and Streams are no exception. But they are a marked improvement over excessive loops and temporary variables for otherwise simple transformations and collections.

While this post highlighted some ways that we can use Streams when we would otherwise write a comprehension in Python, it's important to know that Streams are much more than this and are capable of some really cool things (parallelization, lazy evaluation, sorting, querying, etc, etc)!

To learn more about Streams, check out this post by Eugen Paraschiv on Stackify and of course the Java documentation

Python does have support for the more functional programming-style filter that more closely mirrors Java's implementation. Though list comprehensions are generally considered to be more Pythonic than filter. ↩
Like the previous note, Python has support for map but in most cases the list comprehension is preferred. ↩
Lisp programmers might take issue with this statement. ↩

DEV Community: Dylan

From Python to Java: Using JShell

Introduction

Enter JShell

Starting to Explore

Play it back

Interacting with other libraries

Java script?

Further Reading

From Python to Java: Comprehensions and Streams

Introduction

.stream(), .collect()

Filtering

Transforming

Lists to Dictionaries

Conclusion

`.stream()`, `.collect()`