DEV Community: Jostin Soza

Arrays

Jostin Soza — Mon, 04 Aug 2025 16:41:26 +0000

The next topic we're going to discuss is the arrays in Java.

Firstly, we need to know what an array is. An array is a container object that holds a fixed number of values of a single type. Arrays are a fundamental data structure used to store collections of data elements of the same type.

Characteristics of Java arrays:

Fixed Size: The size of an array is determined at the time of its creation and cannot be changed later.

Homogeneous Elements: All elements within an array must be of the same data type. This can be primitive types (like int, double, boolean) or reference types (like String, Object, or custom class objects).

Indexed: Array elements are accessed by their numerical index, starting from 0 for the first element.

Objects: In Java (and other languages like javascript), arrays are objects, meaning they are reference types and are allocated on the heap.

To declare an array:

Define the variable type with square brackets:

String[] food; // Its the most recommended
//or
String food[]; //Also valid


///====CREATING AN ARRAY====
numbers = new int[5]; // Creates an array with 5 elements (default values: 0)

///You can also declare and initialize in one line:
int[] numbers = new int[5];

We have now declared a variable that holds an array of strings.

To insert values into it:

String[] food = {"Apple", "Carrots", "Pasta", "Pizza"};

The same with other data types:

int[] nums = {1,2,3,4};

boolean[] bools = {true, false};

double[] doubleNums = {1.23, 4.52};

Access the elements of an array

You can access an array element by referring to the index number:

System.out.println(food[0]); //Output: Apple

Change an array element

It's the same here; we only have to access the index and assign the new value:

food[0] = "Hamburguer";

Array Length

To find out how many elements an array has, use the length property:

String[] names = {"Juan", "Mario"};
System.out.println(names.length); //Ouputs: 2

Differences between `Array` and `ArrayList`

In Java, both are used to store collections of elements, but they have differences in how they work, and they're used for.

Feature	`Array`	`ArrayList`
Size	Fixed after creation	Dynamic (can grow/shrink)
Type	Can store primitives or objects	Only stores objects (use wrapper types)
Syntax	More basic	Easier and more flexible to use
Performance	Slightly faster (less overhead)	Slightly slower (more functionality)
Part of	Core Java (language-level feature)	Part of Java Collections Framework
Utility methods	Limited	Rich set of methods (add, remove, etc.)

Example: Array vs ArrayList

➤ Array

int[] numbers = new int[3];

numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

System.out.println(numbers[1]) // 20

➤ ArrayList

import java.util.ArrayList;

ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
System.out.println(numbers.get(1)); // 20

Note. You must use wrapper classes like Integer, Double, etc., in ArrayList because it only stores objects, not primitives.

Resizing

Array (can't resize):

int[] arr = new int[2];
// arr[2] = 100; // ❌ ArrayIndexOutOfBoundsException

ArrayList (dynamic):

ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C"); //Automatically resizes

Common methods in ArrayList:

list.add("Hello");
list.get(0);
list.set(1, "World");
list.remove(0);
list.size();
list.contains("Hello");

When to Use What?

Use Arrays when:

The number of elements is known and fixed.
You need to store primitives (e.g., int, char, etc.) for performance.
Memory optimization is crucial.

Use ArrayList when:

The number of elements can change dynamically.
You want convenient methods (add, remove, search).
You are working with collections in modern Java.

Spring Boot Project

Jostin Soza — Sun, 03 Aug 2025 01:19:08 +0000

Hello everyone!

It's been a while since I last posted. Over the past few months, I’ve been focused on building new portfolio projects and managing college responsibilities. Now that I have more time, I’ll start sharing posts about the Java Roadmap soon.

But today, I want to talk about the most complete project I've built so far: a Library Management System built with the Spring Framework. It supports managing books, authors, categories, customers, loans, and returns.

It was built using Java 17 and Spring Boot 3.5.3, with PostgreSQL as the database. I used Spring Data JPA, Spring Web, and Swagger UI for the API documentation. The app also includes caching (via Caffeine), validation (with Hibernate Validator and custom annotations), and follows a clean, modular folder structure. Maven was used for build management.

Here some example of the JSON respond:

Route: api/book/1

{
  "bookId": 1,
  "title": "Cien años de soledad",
  "isbn": "9780307474728",
  "publicationYear": 1967,
  "pages": 417,
  "language": "Español",
  "authors": [
    {
      "authorId": 1,
      "firstName": "Gabriel",
      "lastName": "García Márquez",
      "bio": "Escritor colombiano, premio Nobel de Literatura en 1982",
      "status": true
    }
  ],
  "categoryId": {
    "categoryId": 1,
    "name": "Ficción",
    "description": "Obras de literatura imaginativa",
    "status": true
  },
  "stock": 5,
  "status": false
}

Route: api/customer/1

{
  "customerId": 1,
  "firstName": "María",
  "lastName": "González",
  "email": "maria.g@email.com",
  "phone": "555-1234",
  "registrationDate": "2023-01-15",
  "status": true
}

I implemented several features in this project. Like isbn validation with decorators, implementation of cache for better performance, and a clean structure of the folders. I think that for someone who uses Spring for the first time, it's not bad.

If you are interested to check out my project, you can find it here:

GitHub Repo:

And the PostgreSQL database:

Database:

I'd love to hear your thoughts or suggestions. Feel free to star the repo or open an issue if you have questions!

Strings in Java.

Jostin Soza — Sun, 08 Jun 2025 17:01:39 +0000

In this post we're going to talk about the strings in Java. A string, in Java, is an object that represents a sequence of characters. Although we use it like a primitive data. Actually, it is a class from the java.lang packet.

String variable = "Hello, world!";

📌 Main Features.

They are immutable: When we create a string, we can't modify it. Methods like toUpperCase() or replace() don't change the original variable; they make a new one.
Simplified syntax: You can create a string directly with two quotes, and then Java automatically makes it into an string object.
Intern pool: Java automatically saves literal strings in a "pool" to save memory. If two strings have the same value, point at the same object (if you use literals).

In Java, pool are like a memory special place where are stored reutilizable objects, to not make an unnecessary new instance.

So, as we recently saw, in Java you have two different ways to make a string.

Literals:

String literalString = "Hello";

With `new`:

String newString = new String("Hello");

This second way forces the creation of a new object, even if a similar one already exists in a pool.

🔧 Utils methods.

String text = “Java is cool.”

text.length(); // Returns length
text.charAt(2); // Returns character at index 2
text.substring(5); // Returns “it's cool”.
text.contains(“cool”); // true
text.equals(“JAVA”); // false (case sensitive)
text.equalsIgnoreCase(“JAVA”); // true
text.toUpperCase(); // “JAVA IS COOL”; // “JAVA IS COOL”.
text.replace(“great”, “powerful”); // “Java is powerful”.

Compare Strings

Be careful!
Using == compares references, not content:

String a = “hello”;
String b = new String(“hello”);

System.out.println(a == b); // false
System.out.println(a.equals(b)); // true

🔄 Concatenation

String name = “Juan”;
String salutation = “Hello ” + name; // Concatenation with +

Or with the concat() method:

String new = “Hello ‘.concat(’John”);

📏 Efficiency: StringBuilder and StringBuffer

When you need to modify a string many times (for example, in loops), it is better to use:

StringBuilder: unsynchronized (faster on a single thread).
StringBuffer: synchronized (for threads)

StringBuilder sb = new StringBuilder(“Hello”);
sb.append(“ world”); // “Hello world”.

Strings in Java are more than just sequences of characters—they are powerful, immutable objects that come with a rich set of methods and memory optimization mechanisms like the String pool.

Understanding how they work, how they are created, and how to manipulate them efficiently is fundamental to writing clean and effective Java code.

Whether you're using simple literals or working with StringBuilder for performance, mastering Strings is an essential step in your Java journey.

See you!
🐱‍👤

Learn the basics.

Jostin Soza — Sat, 07 Jun 2025 16:55:54 +0000

Hey there! 👋

Starting your journey with Java? Great choice. Let's talk about the basic syntax — the building blocks you'll use all the time. This is one of the first posts talking about basic concepts. We'll explore the whole Java Roadmap. Think of this like learning the grammar of a new language. Once you get it down, everything else starts making sense.

🧱 The Java Structure

A basic Java program looks something like this:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

Let’s break that down:

public class HelloWorld: Everything in Java lives inside a class. This one is named HelloWorld.
public static void main(String[] args): This is the main method. It's where Java starts running your code.
System.out.println("Hello, world!");: Prints stuff to the console. You’ll use this a lot for debugging.

Variables & Data Types

Java is a statically typed language, which means you need to declare the type of every variable.

int age = 25;
double price = 19.99;
boolean isJavaFun = true;
String name = "Alice";

Some common data types:

int: Whole numbers
double: Decimal numbers
boolean: true or false
String: Text

Control Structures

Loops and conditionals keep your code from being boring.

If-Else:

if (age > 18) {
    System.out.println("You're an adult!");
} else {
    System.out.println("You're a minor.");
}

For Loop:

for (int i = 0; i < 5; i++) {
    System.out.println("i is: " + i);
}

While Loop:

int count = 0;
while (count < 3) {
    System.out.println("Counting: " + count);
    count++;
}

Methods (aka Functions)

Methods let you reuse code. Here’s how you write one:

public static int add(int a, int b) {
    return a + b;
}

And to call it:

int result = add(5, 3); // result is 8

Don’t Forget the Semicolon!

In Java, most lines end with a ;. It’s easy to forget at first, but trust me, the compiler won’t let it slide. 😅

So, What’s Next?

Once you're comfy with the basic syntax, in the next post we're going to talk about another basic concept that you must know in Java. Spoiler Strings on Java

Stay curious, and keep coding! 💻🔥
#JavaRoadmap #JavaBeginner #LearnToCode

My Java Journey ☕

Jostin Soza — Sat, 07 Jun 2025 16:34:16 +0000

Hello, everybody! I’m Jostin, Software Developer and Systems Engineering student. This blog is where I’ll document all my journey into Java development. I’ll talk about Java concepts, share my experiences, and give some tips along the way. I hope this blog helps others who are also learning Java. Feel free to follow along and share thoughts!

So, why Java?

Java is one of the most popular programming languages in the world. It’s widely used in enterprise environments. Learning Java can be very useful if you’re aiming to get a job at a big company. And of course, it is the best programming language in the world. If you disagree, I don’t care — it’s a fact. 👾

Where should I start?

Let’s be honest. Java documentation is not the best. Trying to find something there can be hard, especially when you’re just starting your Java journey. If you’re not familiar with the world of programming, I recommend taking a course to get started with programming logic. One great option is “Introduction to Programming and Computer Science—Full Course” by freeCodeCamp.org.

Link of the video 🧠

After that, you should follow the Java Developer Roadmap. Link to the page below 👇

Java Roadmap

I've already started that roadmap, but I actually know more Java than it covers at this point.

In the next posts, I’ll explore all the concepts from that roadmap. If that sounds interesting, feel free to follow along on my profile. Good luck with your learning journey! ☕