In the landscape of application security, there's often a tension between cryptographic correctness and implementation simplicity. Many developers reach for complex solutions when what they need is straightforward, authenticated encryption for tokens, cookies, or API keys. Fernet provides an elegant solution—a opinionated, high-level symmetric encryption format that is secure by default and easy to implement correctly. For Java applications, Fernet offers a batteries-included approach to token-based security.
What are Fernet Tokens?
Fernet is a specification for symmetric authenticated encryption, originally designed for the Python cryptography library but now available in multiple languages. A Fernet token contains:
- Version (1 byte): Currently always 0x80
- Timestamp (8 bytes): Creation time in seconds since epoch
- IV (16 bytes): Initialization vector for AES encryption
- Ciphertext (variable): AES-128 encrypted payload
- HMAC (32 bytes): SHA256 authentication tag
Key features of Fernet:
- Authenticated Encryption: Provides confidentiality, integrity, and authenticity
- Time-limited: Built-in expiration support
- Self-contained: All metadata is embedded in the token
- Opinionated: Uses secure defaults (AES-128-CBC + HMAC-SHA256)
Why Fernet for Java Applications?
- Simplicity: No need to worry about IV generation, authentication, or encoding
- Security: Well-vetted cryptographic primitives and mode combinations
- Portability: Tokens are interoperable across different programming languages
- Stateless: Perfect for distributed systems without shared session storage
- Compact: Base64-encoded tokens are URL-safe and easy to transmit
Implementing Fernet in Java
1. Basic Fernet Implementation
import javax.crypto.Cipher;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.time.Instant;
import java.util.Arrays;
import java.util.Base64;
/**
* Fernet token implementation based on the Fernet specification
* (https://github.com/fernet/spec/blob/master/Spec.md)
*/
public class Fernet {
private static final int VERSION = 0x80;
private static final int TIMESTAMP_SIZE = 8;
private static final int IV_SIZE = 16;
private static final int HMAC_SIZE = 32;
private static final int MIN_TOKEN_SIZE = 1 + TIMESTAMP_SIZE + IV_SIZE + HMAC_SIZE;
private final SecretKey signingKey;
private final SecretKey encryptionKey;
private final SecureRandom secureRandom;
public Fernet(byte[] key) {
if (key.length != 32) {
throw new IllegalArgumentException("Fernet key must be 32 bytes");
}
// Fernet key: first 16 bytes for AES-128, last 16 bytes for HMAC-SHA256
byte[] encKeyBytes = Arrays.copyOfRange(key, 0, 16);
byte[] signKeyBytes = Arrays.copyOfRange(key, 16, 32);
this.encryptionKey = new SecretKeySpec(encKeyBytes, "AES");
this.signingKey = new SecretKeySpec(signKeyBytes, "HmacSHA256");
this.secureRandom = new SecureRandom();
}
/**
* Generate a new random Fernet key
*/
public static byte[] generateKey() {
byte[] key = new byte[32];
new SecureRandom().nextBytes(key);
return key;
}
/**
* Create a Fernet token from data
*/
public String encrypt(byte[] data) {
return encrypt(data, Instant.now().getEpochSecond());
}
/**
* Create a Fernet token with custom timestamp
*/
public String encrypt(byte[] data, long timestamp) {
try {
// Version (1 byte)
byte[] token = new byte[1 + TIMESTAMP_SIZE + IV_SIZE + data.length + HMAC_SIZE];
token[0] = (byte) VERSION;
// Timestamp (8 bytes, big-endian)
for (int i = 0; i < TIMESTAMP_SIZE; i++) {
token[1 + i] = (byte) (timestamp >> (56 - i * 8));
}
// Generate random IV
byte[] iv = new byte[IV_SIZE];
secureRandom.nextBytes(iv);
System.arraycopy(iv, 0, token, 1 + TIMESTAMP_SIZE, IV_SIZE);
// Encrypt data with AES-128-CBC
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, encryptionKey, new IvParameterSpec(iv));
byte[] ciphertext = cipher.doFinal(data);
// Verify ciphertext length matches expectation
if (ciphertext.length != data.length + 16) { // PKCS#5 padding adds 1-16 bytes
throw new IllegalStateException("Unexpected ciphertext length");
}
// Copy ciphertext
System.arraycopy(ciphertext, 0, token, 1 + TIMESTAMP_SIZE + IV_SIZE, ciphertext.length);
// Calculate HMAC
Mac hmac = Mac.getInstance("HmacSHA256");
hmac.init(signingKey);
byte[] hmacValue = hmac.doFinal(token, 0, token.length - HMAC_SIZE);
// Append HMAC
System.arraycopy(hmacValue, 0, token, token.length - HMAC_SIZE, HMAC_SIZE);
// Base64 encode
return Base64.getUrlEncoder().withoutPadding().encodeToString(token);
} catch (Exception e) {
throw new FernetException("Failed to encrypt data", e);
}
}
/**
* Decrypt and verify a Fernet token
*/
public byte[] decrypt(String token) {
return decrypt(token, Long.MAX_VALUE);
}
/**
* Decrypt and verify a Fernet token with time-to-live validation
*/
public byte[] decrypt(String token, long maxAgeSeconds) {
try {
// Decode from Base64
byte[] tokenBytes = Base64.getUrlDecoder().decode(token);
// Minimum length check
if (tokenBytes.length < MIN_TOKEN_SIZE) {
throw new FernetException("Token too short");
}
// Verify version
if ((tokenBytes[0] & 0xFF) != VERSION) {
throw new FernetException("Invalid token version");
}
// Verify HMAC first (prevents timing attacks on ciphertext)
int hmacStart = tokenBytes.length - HMAC_SIZE;
byte[] providedHmac = Arrays.copyOfRange(tokenBytes, hmacStart, tokenBytes.length);
Mac hmac = Mac.getInstance("HmacSHA256");
hmac.init(signingKey);
byte[] calculatedHmac = hmac.doFinal(tokenBytes, 0, hmacStart);
if (!constantTimeEquals(providedHmac, calculatedHmac)) {
throw new FernetException("Invalid HMAC - token may be tampered");
}
// Extract timestamp
long timestamp = 0;
for (int i = 0; i < TIMESTAMP_SIZE; i++) {
timestamp = (timestamp << 8) | (tokenBytes[1 + i] & 0xFF);
}
// Check expiration
long now = Instant.now().getEpochSecond();
if (timestamp > now) {
throw new FernetException("Token from future");
}
if (now - timestamp > maxAgeSeconds) {
throw new FernetException("Token expired");
}
// Extract IV and ciphertext
byte[] iv = Arrays.copyOfRange(tokenBytes, 1 + TIMESTAMP_SIZE,
1 + TIMESTAMP_SIZE + IV_SIZE);
byte[] ciphertext = Arrays.copyOfRange(tokenBytes, 1 + TIMESTAMP_SIZE + IV_SIZE, hmacStart);
// Decrypt
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, encryptionKey, new IvParameterSpec(iv));
return cipher.doFinal(ciphertext);
} catch (FernetException e) {
throw e;
} catch (Exception e) {
throw new FernetException("Failed to decrypt token", e);
}
}
private boolean constantTimeEquals(byte[] a, byte[] b) {
if (a.length != b.length) return false;
int result = 0;
for (int i = 0; i < a.length; i++) {
result |= a[i] ^ b[i];
}
return result == 0;
}
public static class FernetException extends RuntimeException {
public FernetException(String message) { super(message); }
public FernetException(String message, Throwable cause) { super(message, cause); }
}
}
2. Enhanced Fernet with Convenience Methods
public class FernetTokenService {
private final Fernet fernet;
private final long defaultMaxAgeSeconds;
public FernetTokenService(byte[] key, long defaultMaxAgeSeconds) {
this.fernet = new Fernet(key);
this.defaultMaxAgeSeconds = defaultMaxAgeSeconds;
}
/**
* Create a token from a string
*/
public String createToken(String data) {
return fernet.encrypt(data.getBytes(StandardCharsets.UTF_8));
}
/**
* Create a token with custom expiration
*/
public String createToken(String data, long expiresInSeconds) {
long timestamp = Instant.now().getEpochSecond() + expiresInSeconds;
return fernet.encrypt(data.getBytes(StandardCharsets.UTF_8), timestamp);
}
/**
* Create a token from an object (JSON serialized)
*/
public String createToken(Object obj, ObjectMapper mapper) throws JsonProcessingException {
String json = mapper.writeValueAsString(obj);
return createToken(json);
}
/**
* Decrypt a token to string
*/
public String decryptToken(String token) {
byte[] data = fernet.decrypt(token, defaultMaxAgeSeconds);
return new String(data, StandardCharsets.UTF_8);
}
/**
* Decrypt a token to an object
*/
public <T> T decryptToken(String token, Class<T> type, ObjectMapper mapper)
throws IOException {
String json = decryptToken(token);
return mapper.readValue(json, type);
}
/**
* Verify token validity without decrypting
*/
public boolean isValid(String token) {
try {
fernet.decrypt(token, defaultMaxAgeSeconds);
return true;
} catch (Exception e) {
return false;
}
}
/**
* Get token creation time
*/
public Instant getCreationTime(String token) {
try {
byte[] tokenBytes = Base64.getUrlDecoder().decode(token);
// Extract timestamp
long timestamp = 0;
for (int i = 0; i < 8; i++) {
timestamp = (timestamp << 8) | (tokenBytes[1 + i] & 0xFF);
}
return Instant.ofEpochSecond(timestamp);
} catch (Exception e) {
throw new Fernet.FernetException("Failed to extract timestamp", e);
}
}
}
Practical Applications
1. Session Tokens
@Service
public class FernetSessionManager {
private final FernetTokenService tokenService;
private final UserRepository userRepository;
public FernetSessionManager(@Value("${fernet.key}") String base64Key) {
byte[] key = Base64.getDecoder().decode(base64Key);
this.tokenService = new FernetTokenService(key, 86400); // 24 hours
}
public String createSessionToken(User user) {
SessionData sessionData = SessionData.builder()
.userId(user.getId())
.username(user.getUsername())
.roles(user.getRoles())
.createdAt(Instant.now())
.build();
return tokenService.createToken(sessionData,
ObjectMapperFactory.create());
}
public Optional<User> validateSessionToken(String token) {
try {
SessionData sessionData = tokenService.decryptToken(
token, SessionData.class, ObjectMapperFactory.create());
// Check if user still exists and is active
return userRepository.findById(sessionData.getUserId())
.filter(User::isActive);
} catch (Exception e) {
return Optional.empty();
}
}
@Data
@Builder
public static class SessionData {
private String userId;
private String username;
private List<String> roles;
private Instant createdAt;
}
}
2. API Key Management
@Service
public class FernetApiKeyService {
private final FernetTokenService tokenService;
private final ApiKeyRepository keyRepository;
public FernetApiKeyService(@Value("${fernet.key}") String base64Key) {
byte[] key = Base64.getDecoder().decode(base64Key);
this.tokenService = new FernetTokenService(key, 31536000); // 1 year
}
public String generateApiKey(String clientId, List<String> permissions) {
ApiKeyData keyData = ApiKeyData.builder()
.clientId(clientId)
.permissions(permissions)
.keyId(generateKeyId())
.build();
String token = tokenService.createToken(keyData,
ObjectMapperFactory.create());
// Store metadata (not the full key)
keyRepository.save(new ApiKeyMetadata(
keyData.getKeyId(),
clientId,
permissions,
Instant.now()
));
return token;
}
public Optional<ApiKeyData> validateApiKey(String apiKey) {
try {
ApiKeyData keyData = tokenService.decryptToken(
apiKey, ApiKeyData.class, ObjectMapperFactory.create());
// Verify key exists and not revoked
Optional<ApiKeyMetadata> metadata = keyRepository
.findById(keyData.getKeyId());
if (metadata.isPresent() && !metadata.get().isRevoked()) {
return Optional.of(keyData);
}
} catch (Exception e) {
// Invalid key
}
return Optional.empty();
}
private String generateKeyId() {
byte[] random = new byte[8];
new SecureRandom().nextBytes(random);
return Base64.getUrlEncoder().withoutPadding().encodeToString(random);
}
@Data
@Builder
public static class ApiKeyData {
private String keyId;
private String clientId;
private List<String> permissions;
}
}
3. Secure Cookie Implementation
@Component
public class FernetCookieManager {
private final FernetTokenService tokenService;
public FernetCookieManager(@Value("${fernet.key}") String base64Key) {
byte[] key = Base64.getDecoder().decode(base64Key);
this.tokenService = new FernetTokenService(key, 3600); // 1 hour
}
public ResponseCookie createSecureCookie(String name, String value) {
String encryptedValue = tokenService.createToken(value);
return ResponseCookie.from(name, encryptedValue)
.httpOnly(true)
.secure(true)
.sameSite("Strict")
.path("/")
.maxAge(Duration.ofHours(1))
.build();
}
public Optional<String> readSecureCookie(String cookieValue) {
try {
return Optional.of(tokenService.decryptToken(cookieValue));
} catch (Exception e) {
return Optional.empty();
}
}
public ResponseCookie createUserCookie(UserContext user) {
UserData userData = UserData.builder()
.userId(user.getUserId())
.displayName(user.getDisplayName())
.preferences(user.getPreferences())
.build();
String encrypted = tokenService.createToken(userData,
ObjectMapperFactory.create());
return ResponseCookie.from("user_session", encrypted)
.httpOnly(true)
.secure(true)
.sameSite("Lax")
.path("/")
.maxAge(Duration.ofHours(24))
.build();
}
}
4. One-Time Tokens (Password Reset, Email Verification)
@Service
public class OneTimeTokenService {
private final FernetTokenService tokenService;
private final Set<String> usedTokens = Collections.synchronizedSet(new HashSet<>());
public OneTimeTokenService(@Value("${fernet.key}") String base64Key) {
byte[] key = Base64.getDecoder().decode(base64Key);
this.tokenService = new FernetTokenService(key, 3600); // 1 hour
}
public String createPasswordResetToken(String userId, String email) {
TokenData tokenData = TokenData.builder()
.type("password-reset")
.userId(userId)
.email(email)
.nonce(generateNonce())
.build();
return tokenService.createToken(tokenData,
ObjectMapperFactory.create());
}
public Optional<TokenData> consumeToken(String token) {
try {
// Check if already used
if (usedTokens.contains(token)) {
return Optional.empty();
}
TokenData tokenData = tokenService.decryptToken(
token, TokenData.class, ObjectMapperFactory.create());
// Mark as used
usedTokens.add(token);
// Clean up old tokens periodically
if (usedTokens.size() > 10000) {
usedTokens.clear();
}
return Optional.of(tokenData);
} catch (Exception e) {
return Optional.empty();
}
}
private String generateNonce() {
byte[] nonce = new byte[16];
new SecureRandom().nextBytes(nonce);
return Base64.getUrlEncoder().withoutPadding().encodeToString(nonce);
}
@Data
@Builder
public static class TokenData {
private String type;
private String userId;
private String email;
private String nonce;
}
}
Spring Boot Integration
1. Auto-configuration
@Configuration
@ConditionalOnClass(Fernet.class)
@EnableConfigurationProperties(FernetProperties.class)
public class FernetAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public FernetTokenService fernetTokenService(FernetProperties properties) {
byte[] key = Base64.getDecoder().decode(properties.getKey());
return new FernetTokenService(key, properties.getDefaultMaxAge());
}
@Bean
@ConditionalOnMissingBean
public FernetCookieManager fernetCookieManager(FernetTokenService tokenService) {
return new FernetCookieManager(tokenService);
}
@Bean
@ConditionalOnMissingBean
public FernetSessionManager fernetSessionManager(
FernetTokenService tokenService,
UserRepository userRepository) {
return new FernetSessionManager(tokenService, userRepository);
}
}
2. Configuration Properties
@ConfigurationProperties(prefix = "fernet")
@Data
public class FernetProperties {
/**
* Base64-encoded Fernet key (must be 32 bytes when decoded)
*/
private String key;
/**
* Default maximum age in seconds for tokens
*/
private long defaultMaxAge = 3600;
/**
* Whether to enable Fernet auto-configuration
*/
private boolean enabled = true;
}
3. application.yml Configuration
fernet:
# Generate with: Fernet.generateKey() then Base64 encode
key: "xJ7hR3qL9mN2pK5vB8cE1wY4sG6tA8uD="
default-max-age: 86400 # 24 hours
enabled: true
# Usage in different contexts
app:
session:
fernet-key: ${fernet.key}
session-timeout: 3600
api-keys:
fernet-key: ${fernet.key}
key-validity: 31536000 # 1 year
cookies:
fernet-key: ${fernet.key}
cookie-timeout: 7200 # 2 hours
Security Considerations
1. Key Management
@Component
public class FernetKeyManager {
private final Map<String, byte[]> keyRing = new ConcurrentHashMap<>();
private volatile String currentKeyId;
@PostConstruct
public void initialize() {
// Load keys from secure storage (HSM, KMS, etc.)
rotateKey();
}
public synchronized void rotateKey() {
String newKeyId = UUID.randomUUID().toString();
byte[] newKey = Fernet.generateKey();
// Store key securely
storeKey(newKeyId, newKey);
// Update current key
currentKeyId = newKeyId;
keyRing.put(newKeyId, newKey);
}
public byte[] getCurrentKey() {
return keyRing.get(currentKeyId);
}
public byte[] getKey(String keyId) {
return keyRing.get(keyId);
}
public boolean verifyWithKeyRing(String token) {
// Try all keys for decryption (for key rotation support)
for (Map.Entry<String, byte[]> entry : keyRing.entrySet()) {
try {
Fernet fernet = new Fernet(entry.getValue());
fernet.decrypt(token);
return true;
} catch (Exception e) {
// Continue trying
}
}
return false;
}
}
2. Token Validation Interceptor
@Component
public class FernetTokenInterceptor implements HandlerInterceptor {
@Autowired
private FernetTokenService tokenService;
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler) {
String token = extractToken(request);
if (token == null) {
response.setStatus(HttpStatus.UNAUTHORIZED.value());
return false;
}
try {
// Validate token
String data = tokenService.decryptToken(token);
// Store validated data in request
request.setAttribute("tokenData", data);
return true;
} catch (Exception e) {
response.setStatus(HttpStatus.UNAUTHORIZED.value());
return false;
}
}
private String extractToken(HttpServletRequest request) {
String authHeader = request.getHeader("Authorization");
if (authHeader != null && authHeader.startsWith("Bearer ")) {
return authHeader.substring(7);
}
// Check cookie
Cookie[] cookies = request.getCookies();
if (cookies != null) {
for (Cookie cookie : cookies) {
if ("auth_token".equals(cookie.getName())) {
return cookie.getValue();
}
}
}
return request.getParameter("token");
}
}
Testing
@SpringBootTest
class FernetTest {
@Test
void testBasicEncryptionDecryption() {
byte[] key = Fernet.generateKey();
Fernet fernet = new Fernet(key);
String original = "Hello, Fernet!";
String token = fernet.encrypt(original.getBytes());
byte[] decrypted = fernet.decrypt(token);
String result = new String(decrypted);
assertEquals(original, result);
}
@Test
void testTokenExpiration() {
byte[] key = Fernet.generateKey();
Fernet fernet = new Fernet(key);
String data = "Sensitive data";
String token = fernet.encrypt(data.getBytes());
// Should work within time limit
assertDoesNotThrow(() -> fernet.decrypt(token, 3600));
// Wait a bit (can't actually wait in test, so we mock)
// Instead, test with custom timestamp
long pastTimestamp = Instant.now().getEpochSecond() - 7200;
String oldToken = fernet.encrypt(data.getBytes(), pastTimestamp);
assertThrows(Fernet.FernetException.class,
() -> fernet.decrypt(oldToken, 3600));
}
@Test
void testTamperDetection() {
byte[] key = Fernet.generateKey();
Fernet fernet = new Fernet(key);
String token = fernet.encrypt("test".getBytes());
// Tamper with token
byte[] tokenBytes = Base64.getUrlDecoder().decode(token);
tokenBytes[tokenBytes.length - 1] ^= 0x01; // Flip a bit in HMAC
String tamperedToken = Base64.getUrlEncoder()
.withoutPadding().encodeToString(tokenBytes);
assertThrows(Fernet.FernetException.class,
() -> fernet.decrypt(tamperedToken));
}
}
Best Practices
- Key Security: Store Fernet keys in secure key management systems (HSM, KMS)
- Key Rotation: Implement key rotation with multiple active keys
- Token Size: Be aware that tokens include overhead (~50 bytes + data)
- Expiration: Always set reasonable expiration times
- One-Time Use: For sensitive operations, implement one-time token consumption
- Transport Security: Always use HTTPS when transmitting tokens
- Validation: Always validate tokens before trusting their contents
Performance Benchmark
@Component
public class FernetBenchmark {
private static final int ITERATIONS = 10000;
public void runBenchmark() {
byte[] key = Fernet.generateKey();
Fernet fernet = new Fernet(key);
byte[] data = "Sample payload data for benchmarking".getBytes();
// Warmup
for (int i = 0; i < 1000; i++) {
String token = fernet.encrypt(data);
fernet.decrypt(token);
}
// Benchmark encryption
long start = System.nanoTime();
for (int i = 0; i < ITERATIONS; i++) {
fernet.encrypt(data);
}
long encryptTime = System.nanoTime() - start;
// Benchmark decryption
String token = fernet.encrypt(data);
start = System.nanoTime();
for (int i = 0; i < ITERATIONS; i++) {
fernet.decrypt(token);
}
long decryptTime = System.nanoTime() - start;
System.out.printf("Fernet Performance (%d iterations):%n", ITERATIONS);
System.out.printf(" Encrypt: %.2f µs/op%n", encryptTime / ITERATIONS / 1000.0);
System.out.printf(" Decrypt: %.2f µs/op%n", decryptTime / ITERATIONS / 1000.0);
}
}
Conclusion
Fernet tokens provide Java applications with a simple, secure, and standardized approach to symmetric authenticated encryption. By handling all the cryptographic details—IV generation, authentication, encoding, and expiration—Fernet allows developers to focus on application logic rather than crypto implementation details.
Key advantages of Fernet in Java:
- Secure by default with well-tested cryptographic primitives
- Self-contained tokens with all metadata included
- Language interoperability with implementations in many languages
- Built-in expiration for automatic token lifecycle management
- Compact format suitable for cookies, headers, and URLs
For applications needing secure token handling—session management, API keys, one-time tokens, or encrypted cookies—Fernet offers an ideal balance of security, simplicity, and functionality. By adopting Fernet, Java developers can implement strong cryptographic protections without the complexity and risk of custom crypto implementations.
Java Programming Intermediate Topics – Modifiers, Loops, Math, Methods & Projects (Related to Java Programming)
Access Modifiers in Java:
Access modifiers control how classes, variables, and methods are accessed from different parts of a program. Java provides four main access levels—public, private, protected, and default—which help protect data and control visibility in object-oriented programming.
Read more: https://macronepal.com/blog/access-modifiers-in-java-a-complete-guide/
Static Variables in Java:
Static variables belong to the class rather than individual objects. They are shared among all instances of the class and are useful for storing values that remain common across multiple objects.
Read more: https://macronepal.com/blog/static-variables-in-java-a-complete-guide/
Method Parameters in Java:
Method parameters allow values to be passed into methods so that operations can be performed using supplied data. They help make methods flexible and reusable in different parts of a program.
Read more: https://macronepal.com/blog/method-parameters-in-java-a-complete-guide/
Random Numbers in Java:
This topic explains how to generate random numbers in Java for tasks such as simulations, games, and random selections. Random numbers help create unpredictable results in programs.
Read more: https://macronepal.com/blog/random-numbers-in-java-a-complete-guide/
Math Class in Java:
The Math class provides built-in methods for performing mathematical calculations such as powers, square roots, rounding, and other advanced calculations used in Java programs.
Read more: https://macronepal.com/blog/math-class-in-java-a-complete-guide/
Boolean Operations in Java:
Boolean operations use true and false values to perform logical comparisons. They are commonly used in conditions and decision-making statements to control program flow.
Read more: https://macronepal.com/blog/boolean-operations-in-java-a-complete-guide/
Nested Loops in Java:
Nested loops are loops placed inside other loops to perform repeated operations within repeated tasks. They are useful for pattern printing, tables, and working with multi-level data.
Read more: https://macronepal.com/blog/nested-loops-in-java-a-complete-guide/
Do-While Loop in Java:
The do-while loop allows a block of code to run at least once before checking the condition. It is useful when the program must execute a task before verifying whether it should continue.
Read more: https://macronepal.com/blog/do-while-loop-in-java-a-complete-guide/
Simple Calculator Project in Java:
This project demonstrates how to create a basic calculator program using Java. It combines input handling, arithmetic operations, and conditional logic to perform simple mathematical calculations.
Read more: https://macronepal.com/blog/simple-calculator-project-in-java/