Practical Data Manipulation Techniques in Java

Hello and welcome! Today, we're exploring practical data manipulation techniques in Java. We'll use Java lists to represent our data stream and perform projection, filtering, and aggregation. And here's the star of the show: our operations will be neatly packaged within a Java class! No mess, all clean code.

Introduction to Data Manipulation

Data manipulation is akin to being a sculptor but for data. We chisel and shape our data to get the desired structure. Java lists are perfect for this, and our operations will be conveniently bundled inside a Java class. So, let's get our toolbox ready! Here's a simple Java class, DataStream, that will serve as our toolbox:

import java.util.List;

public class DataStream<T> {
    private List<T> data;

    public DataStream(List<T> data) {
        this.data = data;
    }

    public List<T> getData() {
        return data;
    }
}
Data Projection in Practice

Our first stop is data projection. Think of it like capturing a photo of our desired features. Suppose we have data about people. If we're only interested in names and ages, we project our data to include just these details. We'll extend our DataStream class with a projectData method for this:

import java.util.List;
import java.util.stream.Collectors;
import java.util.Map;
import java.util.HashMap;

public class DataStream<T> {
    private List<T> data;

    public DataStream(List<T> data) {
        this.data = data;
    }

    public List<Map<String, Object>> projectData(List<String> keys) {
        return data.stream()
                .map(d -> {
                    Map<String, Object> projectedMap = new HashMap<>();
                    for (String key : keys) {
                        try {
                            projectedMap.put(key, d.getClass().getDeclaredMethod("get" + key).invoke(d));
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    return projectedMap;
                })
                .collect(Collectors.toList());
    }
}

class Person {
    private String name;
    private int age;
    private String profession;

    // Constructor and getters
    public Person(String name, int age, String profession) {
        this.name = name;
        this.age = age;
        this.profession = profession;
    }

    public String getName() { return name; }
    public int getAge() { return age; }
    public String getProfession() { return profession; }
}

public class Main {
    public static void main(String[] args) {
        List<Person> people = List.of(
            new Person("Alice", 25, "Engineer"),
            new Person("Bob", 30, "Doctor")
        );

        DataStream<Person> ds = new DataStream<>(people);
        List<Map<String, Object>> projectedData = ds.projectData(List.of("Name", "Age"));

        for (Map<String, Object> item : projectedData) {
            System.out.println(item.get("Name") + ", " + item.get("Age"));
        }
        // Outputs:
        // Alice, 25
        // Bob, 30
    }
}

As you can see, we now have a new list with just the names and ages!

Sign up
Join the 1M+ learners on CodeSignal
Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal