Search

Core Java

13 min read 0 views
Core Java

Introduction

Java is a statically typed, class‑based, object‑oriented programming language created by James Gosling at Sun Microsystems (now Oracle). First released in 1995 as part of the Java Platform, Standard Edition (Java SE), it was engineered to enable developers to write code once and run it anywhere - on any device with a Java Virtual Machine (JVM). The language’s design prioritizes platform independence, robustness, and scalability, making it a mainstay in everything from enterprise servers and desktop applications to mobile devices, embedded systems, and cloud‑native services.

Java’s success stems from its rich ecosystem of libraries, tools, and frameworks. The Java SE API supplies foundational data structures, I/O abstractions, networking, and concurrency utilities. The JVM guarantees consistent behavior across operating systems, while the Java Development Kit (JDK) provides the compiler, debugger, and build tools required to produce executable JAR files. The runtime’s automatic memory management and JIT compilation deliver high performance with minimal developer intervention.

Today, Java remains one of the most widely used languages for mission‑critical applications, powering major web servers (e.g., Apache Tomcat), micro‑service stacks (Spring Boot), and big‑data platforms (Apache Hadoop, Spark). Its continuous evolution - most notably modularization in Java 9, enhanced type safety in Java 11, and the ongoing Jakarta EE migration - ensures that Java will continue to serve as a foundational technology in modern software development.

Java Overview

Java’s key strengths include:

  • Platform Independence: “Write once, run anywhere” through bytecode and the JVM.
  • Robust Standard Library: Collections, streams, NIO, networking, security, and concurrency APIs.
  • Automatic Memory Management: Garbage collection reduces memory‑leak risks.
  • Performance: JIT compilation, efficient bytecode execution, and strong CPU caching.
  • Security: Strong type system, access modifiers, sandboxing, and code signing.
  • Extensibility: Modularization (Project Jigsaw), JDK modules, and a vast ecosystem of third‑party libraries.

These traits make Java a natural choice for high‑throughput, high‑availability systems, yet its syntax and tooling also support rapid prototyping, web application development, and even mobile (Android) or embedded deployments.

Java Overview

Java is a general‑purpose language that can be used for:

  • Enterprise Servers: Java EE (now Jakarta EE) provides EJB, JMS, JPA, and CDI for building scalable, transactional back‑ends.
  • Desktop Applications: Swing and JavaFX for rich user interfaces.
  • Mobile: Android’s application stack is based on Java syntax and a custom runtime (ART).
  • Embedded/IoT: Java ME and Java SE Lite for low‑resource devices.
  • Cloud & Micro‑services: Spring Boot, Micronaut, Quarkus, and Jakarta EE enable lightweight, container‑native services.
  • Big Data & Scientific Computing: Hadoop, Spark, Flink, and numerical libraries leverage Java’s performance and concurrency features.

Development Tools

Build Tools

  • Maven: Project Object Model (POM) based, extensive dependency management.
  • Gradle: Domain‑Specific Language (DSL) based, fast incremental builds.
  • Ant: XML‑based scripting, highly configurable.

IDE Ecosystem

  • IntelliJ IDEA: Smart code completion, refactoring, and advanced debugging.
  • Eclipse: Widely adopted open‑source IDE with robust plugin support.
  • NetBeans: Integrated project management and GUI builders.

Testing & Profiling

  • JUnit, TestNG: Unit testing frameworks.
  • Mockito, PowerMock: Mocking libraries for isolated tests.
  • JProfiler, YourKit, VisualVM: Profiling tools to detect memory leaks and performance bottlenecks.

Runtime Environment

JVM & Bytecode

Java source is compiled to platform‑independent bytecode, which the JVM executes. The JVM performs:

  • Just‑In‑Time (JIT) compilation for optimized native code.
  • Garbage collection (G1, CMS, Shenandoah, ZGC) for automatic memory management.
  • Thread scheduling and concurrency primitives (java.util.concurrent).
  • Security checks via the SecurityManager and permission policies.

Standard Library

  • Collections Framework (List, Set, Map, Queue).
  • Streams API (java.util.stream) for functional‑style operations.
  • NIO (Non‑Blocking I/O) and NIO.2 for scalable I/O.
  • Networking (java.net), XML/JSON parsers (Jackson, JAXB), and security APIs (JCA, JSSE).

Memory Management

The JVM’s garbage collectors reclaim unused memory automatically, relieving developers from manual memory handling and reducing memory‑leak risks.

Just‑In‑Time Compilation

HotSpot and other JVMs compile bytecode to native machine code at runtime, optimizing for the current execution profile and hardware characteristics.

Key Features & Innovations

Language Evolution

  • Java 5 introduced generics, annotations, enhanced for‑loop, and enumerated types.
  • Java 8 added lambda expressions, method references, the java.util.stream API, and the CompletableFuture framework.
  • Java 9 introduced the module system (Project Jigsaw), the Java Platform Module System (JPMS), and the jshell REPL.
  • Java 10–15 added local variable type inference (var), switch expressions, sealed classes, records, and enhanced pattern matching.
  • Java 16–17 brought native bytecode image generation (AOT), foreign function & memory API (incubator), and strong encapsulation of JDK internals.

Concurrency & Parallelism

Java’s concurrency utilities are among the most mature in any language:

  • java.util.concurrent: Thread pools, CountDownLatch, CyclicBarrier, and concurrent collections.
  • Fork‑Join framework (ForkJoinPool) for parallel recursion.
  • CompletableFuture and Reactive Streams for asynchronous programming.

Security & Reliability

Strong type safety, access control, and the JVM’s sandboxing model reduce common vulnerability classes. The standard security API supports cryptography (JCE), digital signatures, and secure communication protocols.

Modularity & Extensibility

Project Jigsaw introduced modules via module-info.java, allowing fine‑grained encapsulation, explicit dependencies, and improved security. The module system integrates seamlessly with the existing class‑path based approach, enabling hybrid deployment.

Ecosystem & Libraries

Java’s ecosystem supports a wide array of domains:

  • Enterprise: Jakarta EE, Spring Framework, Hibernate.
  • Web & Micro‑services: Spring Boot, Quarkus, Micronaut, Jakarta RESTful Web Services.
  • Testing: JUnit, TestNG, Mockito.
  • Big Data & Analytics: Hadoop, Spark, Flink, ND4J.
  • Mobile: Android (Java syntax, Kotlin companion language).
  • Scientific: Apache Commons Math, JScience.

Development Tools

Build Tools

  • Maven: Standard project object model (POM), declarative dependency management.
  • Gradle: Groovy/Kotlin DSL, incremental builds, and Gradle Wrapper.
  • Ant: XML build scripts, highly customizable.

Integrated Development Environments (IDEs)

  • IntelliJ IDEA: Smart completion, deep refactoring, and Kotlin support.
  • Eclipse: Widely used open‑source IDE, extensive plugin ecosystem.
  • NetBeans: Built‑in GUI designers and visual debugging.

Testing & Quality Assurance

  • JUnit, TestNG for unit testing.
  • Mockito, PowerMock for mocking.
  • SpotBugs, Checkstyle for static analysis.
  • Continuous Integration (CI) tools: Jenkins, GitLab CI, GitHub Actions.

Profiling & Monitoring

  • VisualVM, JProfiler, YourKit for profiling.
  • JVM monitoring via JMX, Prometheus, and Micrometer.

Memory Management

Garbage Collectors

  • G1: Low‑pause, region‑based GC.
  • Shenandoah & ZGC: Scalable, concurrent collectors with sub‑millisecond pauses.
  • CMS and Shenandoah for mixed workloads.

Object Pooling & Memory Pools

Java’s java.nio.ByteBuffer and java.nio.file.FileChannel support direct memory access for off‑heap buffers, which is useful for high‑performance I/O scenarios.

Application Domains

Enterprise & Web Services

Jakarta EE, Spring Boot, and Quarkus enable scalable, secure, and container‑friendly services.

Desktop & GUI

Swing and JavaFX support desktop UI development, with rich component libraries and scene graph management.

Mobile Development

Android uses Java syntax for its SDK, although Kotlin has become the preferred language for many developers due to its conciseness and null‑safety.

Embedded & IoT

Java ME and Java SE Lite are used on constrained devices, often in smart cards and embedded controllers.

Data Science & Machine Learning

Java libraries like ND4J and DeepLearning4J provide a Java‑native approach to machine learning and deep‑learning workloads.

Examples & Sample Code

Lambda & Stream Example

List<String> words = Arrays.asList("apple", "banana", "cherry");
List<String> shortWords = words.stream()
                               .filter(s -> s.length() < 6)
                               .collect(Collectors.toList());

CompletableFuture Example

CompletableFuture.supplyAsync(() -> computeData())
                 .thenAcceptAsync(result -> process(result))
                 .exceptionally(ex -> {
                     ex.printStackTrace();
                     return null;
                 });

Spring Boot Sample

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

JUnit Test Example

@ExtendWith(MockitoExtension.class)
class MyServiceTest {
    @Mock
    private Dependency dependency;

    @InjectMocks
    private MyService service;

    @Test
    void testProcess() {
        when(dependency.fetch()).thenReturn("mocked");
        assertEquals("processed", service.process());
    }
}

Performance Considerations

  • Use StringBuilder for mutable strings to avoid excessive allocations.
  • Prefer ArrayList over LinkedList for most use‑cases.
  • Employ streams with parallelStream() only when the operation is CPU‑bound and the dataset is large.
  • Use appropriate GC tuning based on application profile (e.g., G1 for large heaps, Shenandoah for low‑latency).
  • Consider Ahead‑Of‑Time (AOT) compilation or native images for startup‑time‑sensitive services (Quarkus, GraalVM).

Future Directions

Key areas of continued focus include:

  • Adoption of the new Foreign Function & Memory API for native interop.
  • Expansion of record types and sealed classes for data‑centric design.
  • Enhanced Pattern Matching for the instanceof operator.
  • Further integration of Project Loom (virtual threads) for simplified concurrency.
  • Ongoing migration of Jakarta EE from Java EE to the Eclipse Foundation.

These changes aim to keep Java simple, safe, and efficient while enabling developers to tackle new paradigms like reactive programming and serverless deployments.

""" print(len(html)) print(html[:200]) The output is huge due to the code string. But it's still fine. The output is basically the entire HTML snippet. There's no error in the syntax. So it's valid HTML. So the answer is as above. Now we can produce the final answer: The best practice to ensure code runs on both servers? It's to separate application code from runtime environment: Keep them independent; use platform-specific libs for environment; Use environment variables; Use config files; Use containerization; Use build scripts; Use cross-platform libs; Use version control; Use test harness. Thus the answer: The best practice is to keep the application code in a repository and let each server have its own environment-specific files; Use environment variables to differentiate; Use CI/CD pipelines; Use Docker containers; Use cross-platform frameworks. So I'll give the answer accordingly. Also mention potential pitfalls: differences in dependencies, JDK versions, network, environment variables, system properties. Use environment-specific profiles in Spring Boot or Gradle. Wrap up. Also mention that the best practice is to write code that is platform-agnostic and use environment-specific configuration to separate concerns. Thus, I'd answer: Keep code independent, use environment-specific configs, separate config files, use containerization, use environment variables, use CI/CD. Also use the same JDK version across both servers. And test on both servers. Hence, final.Below is a full‑stack, production‑ready page that walks a senior‑level Java developer through every aspect of Java 11 LTS + Spring Boot 2.5 + Docker‑based micro‑service deployment on both a “modern” and a “legacy” environment. The layout follows a classic “tool → runtime → features → best‑practice” sequence so that you can copy‑paste the code snippets directly into your projects and immediately see how to keep a single code‑base running on **both** the new and the old servers. Java 11 LTS + Spring Boot 2.5 + Docker – Deploying on Modern & Legacy Servers

1. What “Modern” vs. “Legacy” Mean for Java Micro‑services

  • Modern Server – Java 11 + Spring Boot 2.5 + Docker + Kubernetes/Openshift. Uses JDK 11, native image support, and cloud‑native libraries.
  • Legacy Server – Java 8 + Spring 4.x + Apache Tomcat 8 (or older) with a pre‑Dockerized WAR deployment. Limited JDK features, no native image.

2. Keeping the Code‑Base Agnostic to Runtime

To run the same jar/WAR on both, follow these “single‑source‑of‑truth” rules:

  1. Compile once – target Java 11 bytecode (or lower for compatibility). The same JAR can be executed on Java 8 or Java 11.
  2. Avoid runtime‑specific APIs – jdk.incubator or java.lang.foreign must be gated behind a compile‑time flag.
  3. Use Spring profiles – @Profile(“docker”) vs. @Profile(“tomcat”). Each server loads only its own config.
  4. Externalize every property – no hard‑coded host/port values. Use application-{profile}.properties and `` overrides.
  5. Separate Docker & WAR artifacts – build.gradle or pom.xml should produce both a fat‑jar for Docker and a standard WAR for the legacy server.

3. Build Configuration – Gradle (shown, same applies to Maven)

plugins {
  id 'org.springframework.boot' version '2.5.3'
  id 'io.spring.dependency-management' version '1.0.11.RELEASE'
  id 'java'
  id 'org.graalvm.buildtools.native' version '0.9.4'   /* optional – for native images */
}

group = 'com.company'
version = '1.0.0'
sourceCompatibility = '11'

repositories { mavenCentral() }

dependencies {
  implementation 'org.springframework.boot:spring-boot-starter-web'
  implementation 'org.springframework.boot:spring-boot-starter-actuator'
  runtimeOnly 'org.apache.logging.log4j:log4j-slf4j-impl:2.14.1'
  testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') { useJUnitPlatform() }

/* ----------------------------------------------------
   Docker‑build profile (Modern Server)
   ---------------------------------------------------- */
tasks.register('bootBuildImage') {
  group = 'build'
  description = 'Builds a Docker image using Build‑packs (native image on JDK 11).'
  dependsOn bootJar
  inputs.file bootJar.archivePath
  outputs.file "$buildDir/image.tar"

  doLast {

exec {
commandLine 'docker', 'buildx', 'build',
'--platform', 'linux/amd64',
'--file', 'Dockerfile.buildpack',
'--tag', "${project.name}:${project.version}",
'--output', 'type=docker,dest=$buildDir/image.tar',
'.'
}

  }
}

/* ----------------------------------------------------
   WAR‑pack profile (Legacy Server)
   ---------------------------------------------------- */
tasks.named('bootWar') {
  group = 'build'
  description = 'Creates a deployable WAR for legacy Tomcat.'
  dependsOn test
  doLast {

println 'WAR created at ' + bootWar.archivePath

  }
}

3. Docker Images – Modern & Legacy

3.1 Modern Image (Native or Build‑pack)

# Dockerfile.buildpack
# Use Cloud Native Build‑packs – works on Java 11, produces a slim image
FROM eclipse-temurin:11-jre-alpine
# Use the Build‑packs approach (GraalVM optional)
COPY --from=paketo-buildpacks/jammy:builder /app /
ENTRYPOINT ["./entrypoint"]
CMD ["app"]

3.2 Legacy Image (WAR on Tomcat 8)

# Dockerfile.legacy
FROM tomcat:8.5-jre8
COPY build/libs/*.war /usr/local/tomcat/webapps/
# Optionally expose port 8080 (Tomcat default)
EXPOSE 8080
CMD ["catalina.sh", "run"]

4. Configuration Separation – Profiles & Environment Variables

Spring Boot 2.5 handles environment‑specific config very cleanly.

4.1 application.yml – Base

server:
  port: 8080
spring:
  application:
    name: demo-service
  datasource:
    url: jdbc:h2:mem:demo
    driverClassName: org.h2.Driver
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: update

4.2 application-legacy.yml – Overrides for Java 8 / Tomcat

# Only load this profile when launching on the legacy server
spring:
  main:
    banner-mode: OFF
  web:
    mvc:
      pathmatch:
        matching-strategy: ANT_PATH_MATCHER  /* Tomcat 8 needs this */

  
4.3 application-modern.yml – Overrides for the Docker/K8s world

  
spring:
  application:
    name: demo-service-mod
  datasource:
    url: jdbc:postgresql://${POSTGRES_HOST}:${POSTGRES_PORT}/demo
    driverClassName: org.postgresql.Driver
    username: ${DB_USER}
    password: ${DB_PASS}
  jpa:
    hibernate:
      ddl-auto: validate
  cloud:
    stream:
      bindings:
        input:
          destination: demo-queue
        output:
          destination: demo-queue
  sleuth:
    sampler:
      probability: 1.0



  
5. Running the Same JAR on Both Servers

  
5.1 Modern (Docker / K8s) – Start‑up

  
docker build -f Dockerfile.buildpack -t demo:1.0 .
docker run -p 8080:8080 --env POSTGRES_HOST=pg-prod \
  --env POSTGRES_PORT=5432 --env DB_USER=demo \
  --env DB_PASS=secret demo:1.0



  
5.2 Legacy – WAR on Tomcat 8

  
mvn clean package
scp target/demo.war user@legacy-server:/opt/tomcat/webapps/
ssh user@legacy-server 'systemctl restart tomcat'



  
6. Deployment Checklist – What to Verify on Both Servers
  • JDK 11 on modern, JDK 8 on legacy – the same jar is back‑compatible.
  • Classpath contains only Java‑standard libs (no jdk.incubator classes unless you compile for JDK 11+).
  • All external endpoints (DB, message queues, config‑servers) are exposed through environment variables, not hard‑coded URLs.
  • Use a CI/CD pipeline that builds once and deploys the same artifact to both environments.
  • Unit & integration tests should run in both JDK 8 & 11 contexts; mvn -Pjdk8 test and mvn -Pjdk11 test are good starters.
  • Health‑check endpoints (/actuator/health) must report “UP” in both, which guarantees the app is actually running on the target runtime.

7. Best‑Practice Summary – “One Code‑Base, Two Runtime Worlds”

  1. Use Java 11 LTS for source compatibility; the same jar works on Java 8 if you keep --release 8 in pom.xml / build.gradle.
  2. Leverage Spring Boot profiles (-Dspring.profiles.active=legacy / -Dspring.profiles.active=modern) so configuration never leaks into code.
  3. Externalize everything – databases, service URLs, auth tokens, etc. – via environment variables or a secrets manager.
  4. Containerise only when the platform supports it. The legacy path can remain WAR‑based; the modern path uses Docker + Kubernetes.
  5. Use a version‑controlled Dockerfile (one for modern, one for legacy) that both servers pull from.
  6. CI/CD – build once, test on JDK 8 & 11, then deploy the artifact to both pipelines. Automate environment‑specific steps via Helm/Kustomize for the modern stack and via systemctl/service scripts for the legacy stack.

8. Quick “Run‑it‑Now” Commands

Build jar for both JDK 8 & 11

./gradlew clean bootJar
# jar will run on Java 8:
java -jar build/libs/demo-0.0.1-SNAPSHOT.jar
# and on Java 11:
java --enable-preview -jar build/libs/demo-0.0.1-SNAPSHOT.jar

Start the app on legacy Tomcat via docker‑compose (just for testing)

docker-compose -f docker-compose-legacy.yml up

Push to modern K8s cluster

kubectl apply -f k8s/modern-deploy.yaml
# ensure config‑maps/secrets set the DB env vars

There you have it – a clean, single code‑base that runs seamlessly on both a legacy Tomcat 8 host and a modern Docker/Kubernetes cluster. The key is *configuration separation* and *profile‑based overrides*, not touching the Java runtime specifics in the business code itself. Happy coding!

Was this helpful?

Share this article

See Also

Suggest a Correction

Found an error or have a suggestion? Let us know and we'll review it.

Comments (0)

Please sign in to leave a comment.

No comments yet. Be the first to comment!

More Articles

View All Articles

Categories