Bradley Winter's Blog | Full Stack Software Engineer based in London

How to Implement Your Own Array List in Java

Bradley Winter — Thu, 16 Jan 2025 19:06:37 GMT

Introduction

Have you ever wondered how Java’s ArrayList works under the hood? While the standard ArrayList is efficient and easy to use, building your own version from scratch can significantly enhance your understanding of data structures, memory management, and Java programming in general.

In this blog post, we’ll walk step by step through implementing a custom ArrayList in Java, covering its core features such as dynamic resizing, adding, removing, and accessing elements. By the end, you’ll have a solid grasp of how ArrayList operates and the confidence to experiment with other custom data structures.

Prerequisites

Before diving in, make sure you’re familiar with:

Basic Java programming concepts.
Arrays and object-oriented programming principles.

If you're comfortable with these topics, you’re ready to proceed!

What Is an ArrayList?

An ArrayList is a dynamic array. Unlike a traditional array with a fixed size, an ArrayList can grow or shrink as needed. This flexibility makes it an essential tool in many applications. Key features of an ArrayList include:

Dynamic resizing: Automatically increases capacity when needed.
Element manipulation: Easy addition, removal, and access of elements.
Random access: Elements can be accessed using an index.

We’ll implement these features in our custom ArrayList.

Step 1: Define the Structure

To get started, we’ll create a generic class called MyArrayList. It will include:

An internal array to store elements.
A size variable to keep track of the number of elements.
A default capacity for the initial size of the array.

Here’s the code:

class MyArrayList<E> {
    private int DEFAULT_CAPACITY = 10;
    private int size = 0;
    private E[] arr;

    public MyArrayList() {
        arr = (E[]) new Object[DEFAULT_CAPACITY];
    }
}

This creates the foundation of our ArrayList.

Step 2: Implement Core Methods

Now, let’s add the essential functionality.

Adding Elements

We’ll start with a method to add elements to the ArrayList. When the array is full, we’ll resize it to accommodate more elements.

    public void add(E e) {
        if (size == arr.length) {
            increase();
        }
        arr[size++] = e;
    }

    private void increase() {
        int newSize = arr.length * 2;
        arr = Arrays.copyOf(arr, newSize);
    }

The ensureCapacity method doubles the array size when needed, and the add method appends a new element.

Accessing Elements

To retrieve elements, we’ll implement a get method that includes bounds checking to avoid accessing invalid indices.

    public E get(int i) {
        if (i>=size || i<0) {
            throw new IndexOutOfBoundsException("Index: " + i + ", Size " + size);
        }
        return (E) arr[i];
    }

Removing Elements

The remove method deletes an element by shifting all subsequent elements to the left.

    public E remove(int i) {
        if (i>=size || i<0) {
            throw new IndexOutOfBoundsException("Index: " + i + ", Size: " + size);
        }
        E removedElement = (E) arr[i];
        for (int j=i; j1; j++) {
            arr[j] = arr[j+1];
        }
        arr[--size] = null; // Prevent memory leaks
        return removedElement;
    }

Step 3: Add Utility Methods

To make our ArrayList easier to use, we’ll add some helper methods:

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void clear() {
        arr = (E[]) new Object[DEFAULT_CAPACITY];
    }

These methods provide basic information about the list and allow users to reset it.

Step 4: Testing the Custom ArrayList

Let’s write a main method to test our MyArrayList:

class Tests {
    public void runTests() {
        testAdd();
        testDelete();
    }

    private void testAdd() {
        MyArrayList le = new MyArrayList();
        le.add(10);
        int result = le.get(0);
        if (result == 10) {
            System.out.println("testAdd passed.");
        } else {
            System.out.println("testAdd failed. Expected 10 but got " + result);
        }
    }

    private void testDelete() {
        MyArrayList le = new MyArrayList();
        le.add(10);
        le.add(20);
        le.remove(0);
        int result = le.get(0);
        if (result == 20) {
            System.out.println("testDelete passed.");
        } else {
            System.out.println("testDelete failed. Expected 20 but got " + result);
        }
    }
}

With this simple test, you can verify the core functionality of your custom ArrayList.

Step 5: Driver Code

Lastly our driver code to run the tests

    // Driver method 
    public static void main(String[] args) {
        MyArrayList le = new MyArrayList();
        le.add(10);
        le.add(20);
        System.out.println(le.get(0));

        Tests tests = new Tests();
        tests.runTests();
    }

Step 6: Comparing with Java’s Built-In ArrayList

Our implementation provides basic functionality similar to Java’s ArrayList. However, the built-in ArrayList includes advanced features like:

Iterators for traversing elements.
Thread-safety options (with Collections.synchronizedList).
Better error handling and performance optimizations.

While our version is more limited, understanding its inner workings lays the groundwork for deeper insights into Java’s standard library.

Conclusion

In this blog post, we implemented a simple version of an ArrayList in Java, covering dynamic resizing, adding, removing, and accessing elements. This exercise is an excellent way to strengthen your understanding of data structures and Java programming.

Ready to take it further? Try adding features like iterators, sublists, or synchronization to enhance your custom ArrayList. The possibilities are endless!

If you'd like to explore the complete code, check out the GitHub repository. Happy coding!

How to Start Using the Serverless Framework with AWS

Bradley Winter — Wed, 22 Dec 2021 17:51:45 GMT

What is the Serverless Framework

There is a distinction to be made here between Serverless and the Serverless Framework.

Serverless is the new buzzword in technology but what exactly is it?

The basic premise is allowing the developer to focus on the application and not the infrastructure.

It's a cloud computing model where your provider e.g. Amazon (AWS), Google, or others manage the provision of servers. The provider spins up the server when needed so you only pay for what you use. You just focus on the code and everything else is taken care of.

For a more detailed introduction to Serverless and its pros and cons take a look at my 'The Complete Beginners Guide to Serverless' article

This article is about the Serverless Framework, an open-source framework for building and operating serverless applications including;

Developing
Deploying
Monitoring

Why use the Serverless Framework

There are many ways to set up, develop, deploy and monitor serverless applications and I encourage you to research them.

I find the Serverless framework to be the most efficient. It's a complete open source solution for developing serverless applications. If you want to delve deeper feel free to take a look at my article on the pros and cons of the serverless framework

Creating an account

First things first we need to create a serverless account, which can be done from https://dashboard.serverless.com/

Installing Serverless

Once you have created an account it's time to set up the Serverless CLI (command line interface) on your system. This will allow you to run commands from your terminal.

Make sure you have npm installed by following this guide. Now it's time to install the serverless framework.

To do this run

npm install -g serverless

By adding the -g this will install serverless globally so you can access the command anywhere not just in a certain directory. Now you need to login, this will redirect you to the Serverless login page. From your terminal type

serverless login

Now make sure you have an AWS account if you have you can skip this section and go straight to the 'First Project' section. If not then sign up for an AWS account. It's free and comes with 12 months of generous usage limits, then

Create AWS Access Keys

Login to your AWS account and go to the Identity and Access Management (IAM) page
Click on Users and then Add user. Fill in the details and be sure to select the Programmatic access checkbox. Click Next to go through to the permissions page, click on Attach existing policies directly. Search for and select AdministratorAccess then click Next: Review and Create user.
View and copy the API Key and Secret as we will need this in the next and final step

The final step is to run and enter your API Key, Secret, and region as eu-west-2 by entering into your terminal

aws configure

First Project

Now that you have installed and logged in to the Serverless framework we can now create our first project.

I have set up a template that we can use to get familiar with using the serverless commands.

You can take a look through the repository here feel free to fork/star the repo as we will be building on top of it in the upcoming articles.

To clone the repo to your machine run this command in your terminal

git clone git@github.com:GoldenRatio3/Serverless-101.git

Next, change into the directory so we can link to your AWS account

cd Serverless-101

Run the serverless command to create an application and connect to AWS. Looks like the below image, you can name your application serverless-101.

serverless

Now open in your favorite IDE (I would recommend visual studio code)

You should see something like this

We have 5 files

.gitignore file which allows us to ignore committing auto-generated files to git
handler.js file this is the entry point to our application and where the logic lives
LICENSE file stating the uses for this code
README.md file that explains how to install, run etc.
serverless.yml file which is the main config file for your serverless function

Let's Deploy

We have set up the Serverless framework and cloned the repo to our machine.

The next step is to deploy to your cloud provider (we will be using AWS for this article)

To deploy we just run

serverless deploy

This will build our packages and deploy them to our cloud provider

Once the command completes, fire up postman and hit the endpoint that's showing in the terminal. If all has been done correctly you should receive a response like the one below

under the 'endpoints' section is the endpoint you want to copy and paste

You should see something similar to the above

Update

Now we have deployed our first serverless application, let's update the function's logic and see how easy it is to update and then redeploy.

First, we will update the message being returned to the client by opening up handler.js and updating the string on line 8 from:

message: "Great work! You have now deployed your first lambda"

message: "Great work! You have now updated and redeployed your lambda"

now we can save and run

serverless deploy

this will repackage our new application and deploy it.

To test the update has been successful, fire up postman as before and hit the endpoint. You should now see a response similar to below

Nice work!

Remove

We can also remove and clean up the application we have deployed by running

serverless remove

this will remove all objects from AWS including the S3 objects and the cloud formation stack, then at any time we can redeploy by running

serverless deploy

That's a wrap

We have now created, setup and deployed our very first serverless application to AWS and confirmed the endpoint is up and available using postman.

If you want to be notified when the next articles are released for adding POST and DELETE endpoints, monitoring, running locally and debugging tips then you can subscribe to my mailing list over at my blog.

Thanks for reading this article, if you have any questions, feel free to reach out in the comments section below.

The Complete Beginners Guide to Serverless

Bradley Winter — Mon, 13 Dec 2021 13:10:11 GMT

What is Serverless?

Serverless computing is a cloud computing execution model, where your provider e.g. Amazon (AWS), Google Cloud, Microsoft (Azure) runs the server and you focus on the implementation.

It simplifies the process of deploying and managing code in production and abstracts away scaling, capacity planning and maintenance from the developer.

This article will take you through everything you need to know about the Serverless model, including comparisons against the current options and explain in detail when to use the model and when not to.

Current way vs Serverless?

There are many alternative models to the Serverless one, the most popular models are managing the infrastructure yourself, where you buy, maintain and upgrade your servers or deploying your application to a managed server also known as IaaS (infrastructure as a service)

So why Serverless?

Why then has this new serverless model taken hold and becoming popular within the community.

All the current models put the large overhead of owning and managing a server on the developer/company. This increases the costs for the company and creates a limitation to scalability and flexibility for the developer.

In comes Serverless which is a managed, stateless and ephemeral service, that allows you the developer to focus on the most important part (the business logic) and leave the rest to your cloud provider.

We will delve into the pros and cons of this model and discuss examples of when to use and not to use the serverless execution model.

Serverless pros

There are many different perspectives we can view the serverless execution model from. The main three we will be viewing from is the developer, the business and the user.

Pricing

For the serverless model, the charge is execution based, meaning you are charged by the number of executions of a particular bit of code. This reduces the running costs as you will pay zero if that bit of code is never run. Further, the business will not need to hire a team to buy, maintain and upgrade the infrastructure which will reduce overhead.

Environments

As developers, we don't want to code and test in production so we create replica environments to do this e.g. QA, Staging, Development environments. Setting many environments up is a resource-intensive task, by using the serverless model it makes setting up many versions of your code as simple as an extra configuration line.

Scale

Serverless allows for automatic scaling based on certain parameters e.g. CPU usage, memory usage etc. This allows you to scale up and down to meet your performance requirements for your user base without having to acquire, set up and deploy your code to new servers.

Invocation

Serverless computing allows for different kinds of events to invoke your code e.g. a client hits one of your endpoints, uploads and image, tweets or makes a call. This allows for a lot of flexibility while keeping costs down as you don't need the task running 24/7, you only need it when a particular event happens e.g. when a user uploads an image, call your image resize code that resizes the image and uploads to your storage area.

Deployability

When developing there is a question around when to deploy my code to production. This is a spectrum but at either side, there are the fast deployable iterations which mean as soon as you have finished your development work and it has passed the tests and been reviewed it goes straight out to production. At the other end, there is the monthly or even bi-yearly releases where a massive bundle of changes are pushed into production, then the month following is spent debugging and fixing the issues.

The preferred state is to be able to deploy once the code has been tested and reviewed, as this allows for smaller deployable commits resulting in less risk and faster delivery of value to your users. This is exactly what the serverless model can do.

Monitoring

No need to add custom code to your backend for monitoring purposes, cloud providers provide this right out of the box, for example, AWS pipe your lambda logs into AWS CloudWatch

Programming Languages

When you create your new function within the serverless model you can select what language you want that function to run in. There are many languages available to run your code on so you can choose any modern language e.g. Javascript, Python, Golang.

Further, each function can be a different language so you can choose the language that best fits the requirements.

Serverless cons

So there are quite a few positives to using the Serverless model yet, there are also a few drawbacks which we will discuss below.

Networking

Now you have completed and deployed your code how do you access it? Once deployed you cannot access directly and will need to set up a wrapper, for example, an API Gateway to access them which on AWS is pretty straightforward

3rd Party Dependencies

Have to bundle dependencies into one executable and can make the lambda heavy, which can hit your providers limits and leads to slower startup times so the current thinking is when you have a small number of dependencies use the serverless model, for larger projects with more dependencies use the current architecture. However, they are looking to add a new technique called layers which will reduce the drawback of this.

Execution time

Serverless computing is meant for short-running tasks, which means most of the providers have an upper timeout limit around 300 seconds for processing an incoming request. Therefore if you have long-running tasks, you could not use the serverless model for them and would not want to as it would be expensive.

Startup Time

Takes time to get function within the serverless model started, approx 100ms from a cold start, but, there are tactics to reduce this and increase performance for your application for example by periodically invoking your function to keep it 'warm'

Vendor lock-in

Can end up being locked into a particular cloud provider but by using a framework e.g. the serverless framework and architecting your system for multi-cloud providers you will be able to reduce this and deploy on many clouds at once. Increasing reliability.

AWS Serverless Architecture Example

Let's go through a quick example of how you could architecture a serverless application on AWS.

Client-side javascript application, allows us to use a simple, static web server.
For the web server, we will use Amazon S3 buckets, which provide a simple and reliable web server to server HTML, CSS, JS and Images.
For our backend business logic, we will use AWS Lambda Functions (FaaS)
To expose our backend functions we will wrap them with AWS API Gateway
To store our data we will use AWS DynamoDB which provides a managed NoSQL database
Finally, to authenticate our users, we will use AWS Cognito which is an identity service integrated with API Gateway and AWS Lambda, which can allow users to signup and log into your web and mobile applications.

Wrap up

As you can see the serverless model is one of many and can be useful in certain situations. It is not a one size fits all solution and is not for every use case.

If you want to try deploying your first Serverless application, you can follow along with this article approx 10 minute completion time.

If you have any other ideas for further pros and cons of the serverless model and what you are currently using them for, feel free to add a comment below.

Thanks for reading as always if you are interested in learning more about technical topics in Software engineering and technical interview best practices check out my website

The 6 Biggest Technical Interview Blunders

Bradley Winter — Mon, 29 Nov 2021 13:12:23 GMT

Not prepared your intro

Most interviewers start off asking you to introduce yourself, this is the first impression they will have of you so make sure you prepare a short 2-minute introduction.

An introduction should include

Where you are currently working and your job title e.g. “I’m currently a Software Engineer at Goldman Sachs, leading a team of 5 for the last two years.”

What you are currently working on and key highlights e.g. “I’m working on the initial architecture of our reporting service and have just finished building out a messaging system which has scaled with our rapid growth.”

What technologies you are using e.g. “I’m a full-stack developer, primary working with Java for the backend and Javascript frameworks e.g. React for the frontend.”

Not Asking clarifying questions

Listen intently and note any useful information in the question, then confirm the requirements from the interviewer and make sure you fully understand the problem, before coming up with a solution.

For example

If the question mentions sorted e.g. “sorted array” then it is highly likely that will be needed for the optimal solution

If the interviewer mentions inputs for a function make sure to clarify any boundary conditions e.g. interviewer mentions string input, you could ask “can null be passed as a parameter?” which will impact your solution

Diving straight into a solution

I have seen many candidates start coding not long after the question, only to realise they will have to rewrite their code because they can optimize.

Stop. Think. Take a couple of minutes to come up with a brute force solution (without coding) which will get you thinking about the problem and your interviewer may give you advice, then optimise.

Not Listening to the Interviewer

This is a simple one, but candidates can get focused on their code and not do this.

Listen to the interviewer, they have used this question multiple times and know it inside and out. If they propose an idea or say to look deeper into a certain section of code, there is always a reason.

Take a couple of minutes to think about their advice and how you can implement it in your code to optimize the solution.

Not testing

Once you have finished your implementation, you are not done. The interviewer is looking at how you would work in the real world and after writing some code, the next step is testing.

Now the interviewer does not expect you to test every single permutation but first walk through your code with your interviewer, talking about what would happen at each step (an example will help).

Pay special attention to

Non-standard code e.g. x = length — 2; or for (int i=10; i>start; i--) make sure the values make sense when walking through your code

Arithmetic and null inputs/outputs e.g. x = (digit * 10) / 2 + 1 and ArrayIndexOutOfBounds Exceptions

Edge cases e.g. unexpected input convertStrToNum("test")

Once you find bugs, take a minute to understand why they have happened and how you would fix them. Do not patch up the code before thinking about the root cause, as you could be introducing more bugs or fixing a bug that should not have happened in the first place.

Not saying Thank you

Thank the interviewer for their time. It’s polite and it goes a long way.

Bonus: Giving up

Don’t. Technical Interview questions are designed to be tough, you are not expected to get the optimal solution straight away.

Take a few minutes and talk through the solution with your interviewer, although all interviewers are different, they will usually give you some advice to keep you on track.

Thanks for reading! If you found this article useful or are looking to prepare for technical interviews, subscribe to my mailing list on my blog for useful articles and advice at bradleywinter.dev