I’ve deployed yet another artifact to Maven Central - this time a record mapping strategy that allows you to read and write Java Record Classes with OpenCSV.

The other day I was using OpenCsv and needed to register a customer converter to convert a string to a simple object. For whatever reason, using OpenCsv’s annotations wasn’t an option.

To help secure Spring applications, I created a Content Security Policy builder and bean and published it to Maven Central.

An easy coding challenge just to practice recording and uploading.

An interesting thing happened the other day when I was spinning off threads in a Groovy for loop.

Introducing JoeHx Tees - a web site dedicated to showcasing my Merch by Amazon t-shirts.

So I’ve been playing around with the OWASP WebGoat project.

A week or so ago I wrote about how I was helping junior developer analyze the incoming parameters of an HTTP request in a Spring/Java Servlet application.

Recently I was helping a junior developer analyze the incoming parameters of an HTTP request in a Spring/Java Servlet application.

This is my third week providing examples for the Java Collections Framework. It’s actually been four weeks since my first of these posts, but I missed last week due to being sick. I’ll miss next week as well due to being on vacation.

This is the second week of my Java Collections Framework examples. This week I’m going to give examples for the Map interface.

Over the next few weeks, I’m going to go over the Java Collections Framework and just so examples for each method. This week being the first week I’ll start with what is probably the most commonly used collections: the List.

As part of my goals for this year, I’ve been working on a rather simple Android app.

If you’ve ever programmed in Eclipse, you’re probably familiar with the call hierarchy window. You know the part that lets you find all instances of a variable? When you right-click on a variable and select “Open Call Hierarchy” or simply type CTRL-ALT-H?

I’ve been having a bit of trouble with constructing an ArrayAdapter for a “spinner” (aka drop-down list) for an Android app I’ve been working on.

I was recently adding some type parameters to a raw JList in some old Java code.

Google Drive no longer syncs with Google Photos, meaning viewing your Google Photos on your desktop or laptop is no longer simple.

Recently I was working with an array of objects where each object itself held an array of different objects. I wanted to go through each of the second items via a Java 8 Stream.

It’s been a little while since I wrote something Java-related (March 28, 2019 was the last time, to be exact) so I figured I write something simple.

Java 8 introduced the ability for interfaces to have default methods. Default methods are methods with an implementation. This is in stark contrast to the notion that interfaces should only have unimplemented, abstract methods.

I’m a Java programmer by trade, and, for whatever reason, I tend to think about edge-cases I might (or might not) encounter while programming (see my article Four Java Limitations You May Never Encounter). One particular example I’ve been contemplating recently is if one null object equals another null object in Java.

I’m almost done with grad school and graduating with my Master’s in Computer Science - just one class left on Wednesday, and that’s the final exam. Originally I had hoped to graduate last year, but things happened that delayed my graduation year (to be specific, I switched from a thesis to non-thesis curriculum). My final class is Distributed Computing, which I had a project to do. This project included a report. For my project, I compared the performance of a Java 8 parallel stream to a “normal” non-parallel (i.e. serial) stream.

I’ve been playing around with JavaFX (the desktop/windows application interface for Java) recently and was trying to find a list of the different “Simple...Property” to use in TableColumn’s setCellValueFactory() method.

I’ve been wanting to play around making Android apps for awhile now. Though difficult, I was able to setup things using Maven and IntelliJ. Almost everything was working - I could even build an APK and install it on my phone - but when I tried to run it on my computer via an Android Virtual Device, I needed to download some components via IntelliJ. Unfortunately, I received the following error:

One way using if/else would be bad design, from an OOP standpoint, is if you’re using a chain of instanceof checks instead of polymorphism.

Kenny Yu mentioned the standard ways to loop through an array. A unique way, I suppose, is to use recursion.

There are four access specifiers in Java: public, private, protected, and default. Three of them use their associated word, while default uses none.

When dealing with numbers, it adds them like you’d expect. When dealing with string, it concatenates them. That is, puts one after another into another string.

You can even do a little shorter than Garry Taylor’s solution, by giving main’s argument a shorter name:

If you’ve programmed in Java for any amount of time, you’ll inevitably come across the terms bean, JavaBean, and POJO. What are they and how do they differ? Let’s start with some definitions:

I'll start with one you probably have encountered... Or least covered in an introductory class.

I was curious as to the effects of autoboxing on equality, so I wrote this short class:

Interesting problem / assumption I had with polymorphism recently. Take this code:

So at my midpoint review for this year, my boss wanted me to get some kind of certificate.