Java vs Python for Data Scientists: A Practical Comparison

import pandas as pd

df = pd.DataFrame({
    "city": ["Pune", "Jaipur", "Pune", "Kochi", "Jaipur"],
    "amount": [1200.0, 800.0, 950.0, 400.0, 1100.0],
})
print(df.groupby("city")["amount"].agg(["count", "mean"]).round(1))

import java.util.*;
import java.util.stream.*;

public class GroupSummary {
    record Sale(String city, double amount) {}

    public static void main(String[] args) {
        List<Sale> sales = List.of(
            new Sale("Pune", 1200), new Sale("Jaipur", 800),
            new Sale("Pune", 950), new Sale("Kochi", 400),
            new Sale("Jaipur", 1100));

        Map<String, DoubleSummaryStatistics> stats = sales.stream()
            .collect(Collectors.groupingBy(Sale::city, TreeMap::new,
                     Collectors.summarizingDouble(Sale::amount)));

        stats.forEach((city, s) -> System.out.printf(
            "%-7s count=%d mean=%.1f%n", city, s.getCount(), s.getAverage()));
    }
}

# pip install pyspark
from pyspark.sql import SparkSession
from pyspark.sql import functions as F

spark = SparkSession.builder.appName("city_sales").getOrCreate()
df = spark.createDataFrame(
    [("Pune", 1200.0), ("Jaipur", 800.0), ("Pune", 950.0)],
    ["city", "amount"])

(df.groupBy("city")
   .agg(F.count("*").alias("orders"), F.avg("amount").alias("avg_amount"))
   .orderBy("city")
   .show())
spark.stop()

import org.apache.spark.sql.*;
import org.apache.spark.sql.types.*;
import java.util.List;
import static org.apache.spark.sql.functions.*;

public class CitySales {
    public static void main(String[] args) {
        SparkSession spark = SparkSession.builder()
            .appName("city_sales").master("local[*]").getOrCreate();
        StructType schema = new StructType()
            .add("city", DataTypes.StringType)
            .add("amount", DataTypes.DoubleType);
        List<Row> rows = List.of(RowFactory.create("Pune", 1200.0),
            RowFactory.create("Jaipur", 800.0), RowFactory.create("Pune", 950.0));
        Dataset<Row> df = spark.createDataFrame(rows, schema);
        df.groupBy("city").agg(count("*").alias("orders"),
            avg("amount").alias("avg_amount")).orderBy("city").show();
        spark.stop();
    }
}

# pip install fastapi uvicorn scikit-learn joblib
# Run: uvicorn serve:app --port 8000
import joblib
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
model = joblib.load("churn_model.joblib")

class Customer(BaseModel):
    tenure_months: float
    monthly_spend: float

@app.post("/predict")
def predict(c: Customer):
    p = model.predict_proba([[c.tenure_months, c.monthly_spend]])[0][1]
    return {"churn_probability": round(float(p), 3)}

import java.net.URI;
import java.net.http.*;

public class ChurnClient {
    public static void main(String[] args) throws Exception {
        String body = "{\"tenure_months\": 4, \"monthly_spend\": 799}";
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("http://localhost:8000/predict"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> res = HttpClient.newHttpClient()
            .send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.statusCode() + " " + res.body());
    }
}

Target role: ______________________
Team's main stack (if known): ______________________

Listings read: ___
Python mentioned: ___
Java mentioned: ___
Spark / Kafka mentioned: ___

Plan:
[ ] Python deeply (always)
[ ] Java reading level (if Java or JVM tools appear often)
[ ] Java working level (if role is ML engineering on JVM systems)

Stage 1  Python, pandas, statistics, scikit-learn
Stage 2  SQL and one end-to-end project
Stage 3  Model serving with FastAPI and Docker
Stage 4  (If needed) Java basics: types, classes, collections, streams
Stage 5  (If needed) PySpark, then read the Spark Java API docs

Project: Churn model used by a Java app

1. Train a model in Python with a baseline comparison
2. Serve it with FastAPI in Docker
3. Write a small Java client that calls the API
4. Document latency, errors and how to retrain

Shows: modelling, deployment and cross-team integration.