repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P105_RecordAndEmbeddables/src/main/java/com/bookstore/service/BookstoreService.java | Chapter04/P105_RecordAndEmbeddables/src/main/java/com/bookstore/service/BookstoreService.java | package com.bookstore.service;
import com.bookstore.dto.AuthorDto;
import java.util.List;
import com.bookstore.repository.AuthorRepository;
import org.springframework.stereotype.Service;
@Service
public class BookstoreService {
private final AuthorRepository authorRepository;
public BookstoreService(AuthorRepository authorRepository) {
this.authorRepository = authorRepository;
}
public List<AuthorDto> fetchByGenre() {
return authorRepository.findByGenre("Anthology");
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P105_RecordAndEmbeddables/src/main/java/com/bookstore/repository/AuthorRepository.java | Chapter04/P105_RecordAndEmbeddables/src/main/java/com/bookstore/repository/AuthorRepository.java | package com.bookstore.repository;
import com.bookstore.dto.AuthorDto;
import java.util.List;
import com.bookstore.entity.Author;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Repository
public interface AuthorRepository extends JpaRepository<Author, Long> {
@Transactional(readOnly = true)
List<AuthorDto> findByGenre(String genre);
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P105_RecordAndEmbeddables/src/main/java/com/bookstore/entity/Author.java | Chapter04/P105_RecordAndEmbeddables/src/main/java/com/bookstore/entity/Author.java | package com.bookstore.entity;
import com.bookstore.embeddable.Contact;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import java.io.Serializable;
@Entity
public class Author implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Embedded
private Contact contact;
private int age;
private String name;
private String genre;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGenre() {
return genre;
}
public void setGenre(String genre) {
this.genre = genre;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Contact getContact() {
return contact;
}
public void setContact(Contact contact) {
this.contact = contact;
}
@Override
public String toString() {
return "Author{" + "id=" + id + ", age=" + age
+ ", name=" + name + ", genre=" + genre + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P105_RecordAndEmbeddables/src/main/java/com/bookstore/embeddable/Contact.java | Chapter04/P105_RecordAndEmbeddables/src/main/java/com/bookstore/embeddable/Contact.java | package com.bookstore.embeddable;
import jakarta.persistence.Embeddable;
@Embeddable
public record Contact(String email, String twitter, String phone) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/MelonRecord.java | Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/MelonRecord.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public record MelonRecord(String type, float weight) implements Serializable {
public MelonRecord {
Objects.requireNonNull(type, "The melon's type cannot be null");
if (weight < 1000 || weight > 10000) {
throw new IllegalArgumentException(
"The melon's weight must be between 1000 and 10000 grams");
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/Melon.java | Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
Objects.requireNonNull(type, "The melon's type cannot be null");
if (weight < 1000 || weight > 10000) {
throw new IllegalArgumentException(
"The melon's weight must be between 1000 and 10000 grams");
}
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 89 * hash + Objects.hashCode(this.type);
hash = 89 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/MelonContainer.java | Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/MelonContainer.java | package modern.challenge;
import java.io.Serializable;
import java.time.LocalDate;
import java.util.Objects;
public class MelonContainer implements Serializable {
private final LocalDate expiration;
private final String batch;
private final Melon melon;
public MelonContainer(LocalDate expiration, String batch, Melon melon) {
Objects.requireNonNull(expiration, "The expiration date cannot be null");
Objects.requireNonNull(batch, "The batch cannot be null");
Objects.requireNonNull(melon, "The melon cannot be null");
if (!batch.startsWith("ML")) {
throw new IllegalArgumentException("The batch format should be: MLxxxxxxxx");
}
if (expiration.isBefore(LocalDate.now())) {
throw new IllegalArgumentException("The expiration date cannot be before the current date");
}
this.expiration = expiration;
this.batch = batch;
this.melon = melon;
}
public LocalDate getExpiration() {
return expiration;
}
public String getBatch() {
return batch;
}
public Melon getMelon() {
return melon;
}
@Override
public int hashCode() {
int hash = 7;
hash = 97 * hash + Objects.hashCode(this.expiration);
hash = 97 * hash + Objects.hashCode(this.batch);
hash = 97 * hash + Objects.hashCode(this.melon);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final MelonContainer other = (MelonContainer) obj;
if (!Objects.equals(this.batch, other.batch)) {
return false;
}
if (!Objects.equals(this.expiration, other.expiration)) {
return false;
}
return Objects.equals(this.melon, other.melon);
}
@Override
public String toString() {
return "MelonContainer{" + "expiration=" + expiration
+ ", batch=" + batch + ", melon=" + melon + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/Main.java | Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.time.LocalDate;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
MelonContainer gacContainer = new MelonContainer(
LocalDate.now().plusDays(15), "ML9000SQA0", new Melon("Gac", 5000)
);
try ( ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("object.data"))) {
oos.writeObject(gacContainer);
}
MelonContainer desGacContainer;
try ( ObjectInputStream ios = new ObjectInputStream(
new FileInputStream("object.data"))) {
desGacContainer = (MelonContainer) ios.readObject();
}
System.out.println(desGacContainer);
MelonContainer maliciousDesGacContainer;
try ( ObjectInputStream ios = new ObjectInputStream(
new FileInputStream("object_malicious.data"))) {
maliciousDesGacContainer = (MelonContainer) ios.readObject();
}
System.out.println(maliciousDesGacContainer);
System.out.println();
MelonContainerRecord gacContainerR = new MelonContainerRecord(
LocalDate.now().plusDays(15), "ML9000SQA0", new Melon("Gac", 5000)
);
try ( ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("object_record.data"))) {
oos.writeObject(gacContainerR);
}
MelonContainerRecord desGacContainerR;
try ( ObjectInputStream ios = new ObjectInputStream(
new FileInputStream("object_record.data"))) {
desGacContainerR = (MelonContainerRecord) ios.readObject();
}
System.out.println(desGacContainerR);
/* this will cause the exception of malicious data
MelonContainerRecord maliciousDesGacContainerR;
try ( ObjectInputStream ios = new ObjectInputStream(
new FileInputStream("object_record_malicious.data"))) {
maliciousDesGacContainerR = (MelonContainerRecord) ios.readObject();
}
System.out.println(maliciousDesGacContainerR);
*/
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/MelonContainerRecord.java | Chapter04/P94_RecordSerialization/src/main/java/modern/challenge/MelonContainerRecord.java | package modern.challenge;
import java.io.Serializable;
import java.time.LocalDate;
import java.util.Objects;
public record MelonContainerRecord(LocalDate expiration, String batch, Melon melon) implements Serializable {
public MelonContainerRecord {
Objects.requireNonNull(expiration, "The expiration date cannot be null");
Objects.requireNonNull(batch, "The batch cannot be null");
Objects.requireNonNull(melon, "The melon cannot be null");
if (!batch.startsWith("ML")) {
throw new IllegalArgumentException("The batch format should be: MLxxxxxxxx");
}
if (expiration.isBefore(LocalDate.now())) {
throw new IllegalArgumentException("The expiration date cannot be before the current date");
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P88_SimpleRecord/src/main/java/modern/challenge/MelonRecord.java | Chapter04/P88_SimpleRecord/src/main/java/modern/challenge/MelonRecord.java | package modern.challenge;
public record MelonRecord(String type, float weight) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P88_SimpleRecord/src/main/java/modern/challenge/Melon.java | Chapter04/P88_SimpleRecord/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.util.Objects;
public class Melon {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter04/P88_SimpleRecord/src/main/java/modern/challenge/Main.java | Chapter04/P88_SimpleRecord/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
Melon melon1 = new Melon("Cantaloupe", 2600);
MelonRecord melon2 = new MelonRecord("Cantaloupe", 2600);
MelonRecord melon3 = new MelonRecord("Cantaloupe", 2600);
System.out.println(melon1);
System.out.println(melon1.getType());
System.out.println(melon1.getWeight());
System.out.println();
System.out.println(melon2.type());
System.out.println(melon2.weight());
System.out.println(melon2.equals(melon3));
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P135_PatternBasedStreamSpecificFilter/src/main/java/modern/challenge/Melon.java | Chapter06/P135_PatternBasedStreamSpecificFilter/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P135_PatternBasedStreamSpecificFilter/src/main/java/modern/challenge/Main.java | Chapter06/P135_PatternBasedStreamSpecificFilter/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.io.ObjectInputFilter;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/* create a pattern-based filter and set it for a specific stream */
ObjectInputFilter melonFilter = ObjectInputFilter.Config.createFilter("!modern.challenge.Melon;");
Melon melon = new Melon("Gac", 2500);
byte[] melonSer = Converters.objectToBytes(melon);
System.out.println("Serialization: " + Arrays.toString(melonSer));
System.out.println();
// pass null for no filter, Converters.bytesToObject(melonSer, null)
Melon melonDeser = (Melon) Converters.bytesToObject(melonSer, melonFilter);
System.out.println("Deserialization: " + melonDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P135_PatternBasedStreamSpecificFilter/src/main/java/modern/challenge/Converters.java | Chapter06/P135_PatternBasedStreamSpecificFilter/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes, ObjectInputFilter filter)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
// set the filter
ois.setObjectInputFilter(filter);
return ois.readObject();
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Filters.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Filters.java | package modern.challenge;
import java.io.ObjectInputFilter;
public final class Filters {
private Filters() {
throw new AssertionError("Cannot be instantiated");
}
public static ObjectInputFilter allowMelonFilter() {
ObjectInputFilter filter = ObjectInputFilter.allowFilter(
clazz -> Melon.class.isAssignableFrom(clazz),
ObjectInputFilter.Status.REJECTED);
return filter;
}
public static ObjectInputFilter rejectMuskmelonFilter() {
ObjectInputFilter filter = ObjectInputFilter.rejectFilter(
clazz -> Muskmelon.class.isAssignableFrom(clazz),
ObjectInputFilter.Status.UNDECIDED);
return filter;
}
public static ObjectInputFilter packageFilter() {
return ObjectInputFilter.Config.createFilter(
"modern.challenge.*;!*");
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Muskmelon.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Muskmelon.java | package modern.challenge;
import java.io.Serializable;
public class Muskmelon extends Melon implements Serializable {
public Muskmelon(String type, float weight) {
super(type, weight);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Melon.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/HoneyDew.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/HoneyDew.java | package modern.challenge;
import java.io.Serializable;
public class HoneyDew extends Muskmelon implements Serializable {
public HoneyDew(String type, float weight) {
super(type, weight);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Pumpkin.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Pumpkin.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Pumpkin implements Serializable {
private final String type;
private final float weight;
public Pumpkin(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Pumpkin other = (Pumpkin) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Pumpkin{" + "type=" + type + ", weight=" + weight + '}';
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/MelonFilterFactory.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/MelonFilterFactory.java | package modern.challenge;
import java.io.ObjectInputFilter;
import java.util.function.BinaryOperator;
public class MelonFilterFactory implements BinaryOperator<ObjectInputFilter> {
@Override
public ObjectInputFilter apply(ObjectInputFilter current, ObjectInputFilter next) {
System.out.println();
System.out.println("Current filter: " + current);
System.out.println("Requested filter: " + next);
if (current == null && next != null) {
return ObjectInputFilter.merge(next, Filters.packageFilter());
}
return ObjectInputFilter.merge(next, current);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Persian.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Persian.java | package modern.challenge;
import java.io.Serializable;
public class Persian extends Muskmelon implements Serializable {
public Persian(String type, float weight) {
super(type, weight);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Cantaloupe.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Cantaloupe.java | package modern.challenge;
import java.io.Serializable;
public class Cantaloupe extends Melon implements Serializable {
public Cantaloupe(String type, float weight) {
super(type, weight);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Main.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.io.ObjectInputFilter;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// Set a filter factory
MelonFilterFactory filterFactory = new MelonFilterFactory();
ObjectInputFilter.Config.setSerialFilterFactory(filterFactory);
ObjectInputFilter.Config.setSerialFilter(Filters.allowMelonFilter());
Pumpkin pumpkin = new Pumpkin("Pumpkin", 2000);
Melon melon = new Melon("Melon", 2400);
Muskmelon muskmelon = new Muskmelon("Muskmelon", 1500);
Cantaloupe cantaloupe = new Cantaloupe("Cantaloupe", 5000);
HoneyDew honeyDew = new HoneyDew("HoneyDew", 4500);
Persian persian = new Persian("Persian", 1230);
byte[] pumpkinSer = Converters.objectToBytes(pumpkin);
byte[] melonSer = Converters.objectToBytes(melon);
byte[] muskmelonSer = Converters.objectToBytes(muskmelon);
byte[] cantaloupeSer = Converters.objectToBytes(cantaloupe);
byte[] honeyDewSer = Converters.objectToBytes(honeyDew);
byte[] persianSer = Converters.objectToBytes(persian);
System.out.println("Serialization (pumpkin): " + Arrays.toString(pumpkinSer));
System.out.println("Serialization (melon): " + Arrays.toString(melonSer));
System.out.println("Serialization (muskmelon): " + Arrays.toString(muskmelonSer));
System.out.println("Serialization (cantaloupe): " + Arrays.toString(cantaloupeSer));
System.out.println("Serialization (honeyDew): " + Arrays.toString(honeyDewSer));
System.out.println("Serialization (persian): " + Arrays.toString(persianSer));
System.out.println();
// Pumpkin pumpkinDeser = (Pumpkin) Converters.bytesToObject(pumpkinSer, Filters.rejectMuskmelonFilter());
// System.out.println("Deserialization (pumpkin): " + pumpkinDeser);
Melon melonDeser = (Melon) Converters.bytesToObject(melonSer, Filters.rejectMuskmelonFilter());
System.out.println("Deserialization (melon): " + melonDeser);
// Muskmelon muskmelonDeser = (Muskmelon) Converters.bytesToObject(muskmelonSer, Filters.rejectMuskmelonFilter());
// System.out.println("Deserialization (muskmelon): " + muskmelonDeser);
Cantaloupe cantaloupeDeser = (Cantaloupe) Converters.bytesToObject(cantaloupeSer, Filters.rejectMuskmelonFilter());
System.out.println("Deserialization (cantaloupe): " + cantaloupeDeser);
// HoneyDew honeyDewDeser = (HoneyDew) Converters.bytesToObject(honeyDewSer, Filters.rejectMuskmelonFilter());
// System.out.println("Deserialization (honeyDew): " + honeyDewDeser);
// Persian persianDeser = (Persian) Converters.bytesToObject(persianSer, Filters.rejectMuskmelonFilter());
// System.out.println("Deserialization (honeyDew): " + persianDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Converters.java | Chapter06/P142_JDK17CustomFilterFactory/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes, ObjectInputFilter filter)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
// set the filter
ois.setObjectInputFilter(filter);
return ois.readObject();
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Filters.java | Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Filters.java | package modern.challenge;
import java.io.ObjectInputFilter;
public final class Filters {
private Filters() {
throw new AssertionError("Cannot be instantiated");
}
public static ObjectInputFilter allowMelonFilter() {
ObjectInputFilter filter = ObjectInputFilter.allowFilter(
clazz -> Melon.class.isAssignableFrom(clazz),
ObjectInputFilter.Status.REJECTED);
return filter;
}
public static ObjectInputFilter rejectMuskmelonFilter() {
ObjectInputFilter filter = ObjectInputFilter.rejectFilter(
clazz -> Muskmelon.class.isAssignableFrom(clazz),
ObjectInputFilter.Status.UNDECIDED);
return filter;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Muskmelon.java | Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Muskmelon.java | package modern.challenge;
import java.io.Serializable;
public class Muskmelon extends Melon implements Serializable {
public Muskmelon(String type, float weight) {
super(type, weight);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Melon.java | Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/HoneyDew.java | Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/HoneyDew.java | package modern.challenge;
import java.io.Serializable;
public class HoneyDew extends Muskmelon implements Serializable {
public HoneyDew(String type, float weight) {
super(type, weight);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Pumpkin.java | Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Pumpkin.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Pumpkin implements Serializable {
private final String type;
private final float weight;
public Pumpkin(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Pumpkin other = (Pumpkin) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Pumpkin{" + "type=" + type + ", weight=" + weight + '}';
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Persian.java | Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Persian.java | package modern.challenge;
import java.io.Serializable;
public class Persian extends Muskmelon implements Serializable {
public Persian(String type, float weight) {
super(type, weight);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Cantaloupe.java | Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Cantaloupe.java | package modern.challenge;
import java.io.Serializable;
public class Cantaloupe extends Melon implements Serializable {
public Cantaloupe(String type, float weight) {
super(type, weight);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Main.java | Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Pumpkin pumpkin = new Pumpkin("Pumpkin", 2000);
Melon melon = new Melon("Melon", 2400);
Muskmelon muskmelon = new Muskmelon("Muskmelon", 1500);
Cantaloupe cantaloupe = new Cantaloupe("Cantaloupe", 5000);
HoneyDew honeyDew = new HoneyDew("HoneyDew", 4500);
Persian persian = new Persian("Persian", 1230);
byte[] pumpkinSer = Converters.objectToBytes(pumpkin);
byte[] melonSer = Converters.objectToBytes(melon);
byte[] muskmelonSer = Converters.objectToBytes(muskmelon);
byte[] cantaloupeSer = Converters.objectToBytes(cantaloupe);
byte[] honeyDewSer = Converters.objectToBytes(honeyDew);
byte[] persianSer = Converters.objectToBytes(persian);
System.out.println("Serialization (pumpkin): " + Arrays.toString(pumpkinSer));
System.out.println("Serialization (melon): " + Arrays.toString(melonSer));
System.out.println("Serialization (muskmelon): " + Arrays.toString(muskmelonSer));
System.out.println("Serialization (cantaloupe): " + Arrays.toString(cantaloupeSer));
System.out.println("Serialization (honeyDew): " + Arrays.toString(honeyDewSer));
System.out.println("Serialization (persian): " + Arrays.toString(persianSer));
System.out.println();
// pass the filters since Melon is Melon and is not Muskmelon
Melon melonDeser = (Melon) Converters.bytesToObject(
melonSer, Filters.allowMelonFilter(), Filters.rejectMuskmelonFilter());
System.out.println("Deserialization (melon): " + melonDeser);
// Pumpkin pumpkinDeser = (Pumpkin) Converters.bytesToObject(
// pumpkinSer, Filters.allowMelonFilter(), Filters.rejectMuskmelonFilter());
// System.out.println("Deserialization (pumpkin): " + pumpkinDeser);
// Muskmelon muskmelonDeser = (Muskmelon) Converters.bytesToObject(
// muskmelonSer, Filters.allowMelonFilter(), Filters.rejectMuskmelonFilter());
// System.out.println("Deserialization (muskmelon): " + muskmelonDeser);
// pass the filters since Cantaloupe is Melon and is not Muskmelons
Cantaloupe cantaloupeDeser = (Cantaloupe) Converters.bytesToObject(
cantaloupeSer, Filters.allowMelonFilter(), Filters.rejectMuskmelonFilter());
System.out.println("Deserialization (cantaloupe): " + cantaloupeDeser);
// HoneyDew honeyDewDeser = (HoneyDew) Converters.bytesToObject(
// honeyDewSer, Filters.allowMelonFilter(), Filters.rejectMuskmelonFilter());
// System.out.println("Deserialization (honeyDew): " + honeyDewDeser);
// Persian persianDeser = (Persian) Converters.bytesToObject(
// persianSer, Filters.allowMelonFilter(), Filters.rejectMuskmelonFilter());
// System.out.println("Deserialization (honeyDew): " + persianDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Converters.java | Chapter06/P141_JDK17CustomFilter/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes,
ObjectInputFilter allowFilter, ObjectInputFilter rejectFilter)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
// set the filters
ObjectInputFilter filters = ObjectInputFilter.merge(allowFilter, rejectFilter);
ois.setObjectInputFilter(filters);
return ois.readObject();
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P132_ObjectToStringSer/src/main/java/modern/challenge/Melon.java | Chapter06/P132_ObjectToStringSer/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P132_ObjectToStringSer/src/main/java/modern/challenge/Main.java | Chapter06/P132_ObjectToStringSer/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Melon melon = new Melon("Gac", 2500);
String melonSer = Converters.objectToString(melon);
System.out.println("Serialization: " + melonSer);
System.out.println();
Melon melonDeser = (Melon) Converters.stringToObject(melonSer);
System.out.println("Deserialization: " + melonDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P132_ObjectToStringSer/src/main/java/modern/challenge/Converters.java | Chapter06/P132_ObjectToStringSer/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Base64;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static String objectToString(Serializable obj) throws IOException {
try ( ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
return Base64.getEncoder().encodeToString(baos.toByteArray());
}
}
public static Object stringToObject(String obj)
throws IOException, ClassNotFoundException {
byte[] data = Base64.getDecoder().decode(obj);
try ( ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(data))) {
return ois.readObject();
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P136_CustomClassFilter/src/main/java/modern/challenge/MelonFilter.java | Chapter06/P136_CustomClassFilter/src/main/java/modern/challenge/MelonFilter.java | package modern.challenge;
import java.io.ObjectInputFilter;
import java.io.ObjectInputFilter.FilterInfo;
import java.io.ObjectInputFilter.Status;
public final class MelonFilter implements ObjectInputFilter {
@Override
public Status checkInput(FilterInfo filterInfo) {
Class<?> clazz = filterInfo.serialClass();
if (clazz != null) {
// or, clazz.getName().equals("modern.challenge.Melon")
return !(clazz.getPackage().getName().equals("modern.challenge")
&& clazz.getSimpleName().equals("Melon"))
? Status.ALLOWED : Status.REJECTED;
}
return Status.UNDECIDED;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P136_CustomClassFilter/src/main/java/modern/challenge/Melon.java | Chapter06/P136_CustomClassFilter/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P136_CustomClassFilter/src/main/java/modern/challenge/Main.java | Chapter06/P136_CustomClassFilter/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.io.ObjectInputFilter;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/* create a custom class filter and set it for all the streams of this application */
// ObjectInputFilter.Config.setSerialFilter(new MelonFilter());
Melon melon = new Melon("Gac", 2500);
byte[] melonSer = Converters.objectToBytes(melon);
System.out.println("Serialization: " + Arrays.toString(melonSer));
System.out.println();
Melon melonDeser = (Melon) Converters.bytesToObject(melonSer, new MelonFilter());
System.out.println("Deserialization: " + melonDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P136_CustomClassFilter/src/main/java/modern/challenge/Converters.java | Chapter06/P136_CustomClassFilter/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes, ObjectInputFilter filter)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
// set the filter
ois.setObjectInputFilter(filter);
return ois.readObject();
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P140_DeserializationDoS/src/main/java/modern/challenge/Main.java | Chapter06/P140_DeserializationDoS/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.io.ObjectInputFilter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ArrayList<Object> startList = new ArrayList<>();
List<Object> list1 = startList;
List<Object> list2 = new ArrayList<>();
for (int i = 0; i < 101; i++) {
List<Object> sublist1 = new ArrayList<>();
List<Object> sublist2 = new ArrayList<>();
sublist1.add("value: " + i);
list1.add(sublist1);
list1.add(sublist2);
list2.add(sublist1);
list2.add(sublist2);
list1 = sublist1;
list2 = sublist2;
}
// create a filter to prvent DoS
ObjectInputFilter filter = ObjectInputFilter.
Config.createFilter("maxdepth=10;java.base/*;!*");
byte[] startListSer = Converters.objectToBytes(startList);
System.out.println("Serialization: " + Arrays.toString(startListSer));
System.out.println();
ArrayList startListDeser = (ArrayList) Converters.bytesToObject(startListSer, filter);
System.out.println("Deserialization: " + startListDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P140_DeserializationDoS/src/main/java/modern/challenge/Converters.java | Chapter06/P140_DeserializationDoS/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes, ObjectInputFilter filter)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
System.out.println("Deserializing ...");
ois.setObjectInputFilter(filter);
return ois.readObject();
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P133_ObjectToXML/src/main/java/modern/challenge/Melon.java | Chapter06/P133_ObjectToXML/src/main/java/modern/challenge/Melon.java | package modern.challenge;
// import java.io.Serializable;
import java.util.Objects;
public class Melon { //implements Serializable { // this is optional
private String type;
private float weight;
// this is needed for XMLEncoder and XmlMapper
public Melon() {}
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
// setters are needed by the XMLEncoder
public void setType(String type) {
this.type = type;
}
public void setWeight(float weight) {
this.weight = weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P133_ObjectToXML/src/main/java/modern/challenge/Main.java | Chapter06/P133_ObjectToXML/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
Melon melon = new Melon("Gac", 2500);
System.out.println();
// use XMLEncoder/XMLDecoder
System.out.println();
String melonSerXMLE = Converters.objectToXML(melon);
System.out.println("Serialization (XMLEncoder): " + melonSerXMLE);
Melon melonDeserXMLD = (Melon) Converters.XMLToObject(melonSerXMLE);
System.out.println("Deserialization (XMLDecoder): " + melonDeserXMLD);
System.out.println();
// use Jackson XmlMapper
System.out.println();
String melonSerXMLM = Converters.objectToXMLJackson(melon);
System.out.println("Serialization (XmlMapper): " + melonSerXMLM);
System.out.println();
Melon melonDeserXMLM = Converters.XMLToObjectJackson(melonSerXMLM, Melon.class);
System.out.println("Deserialization (XmlMapper): " + melonDeserXMLM);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P133_ObjectToXML/src/main/java/modern/challenge/Converters.java | Chapter06/P133_ObjectToXML/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static String objectToXML(Object obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(baos))) {
encoder.writeObject(obj);
}
baos.close();
return new String(baos.toByteArray());
}
public static Object XMLToObject(String xml) throws IOException {
try ( InputStream is = new ByteArrayInputStream(xml.getBytes());
XMLDecoder decoder = new XMLDecoder(is)) {
return decoder.readObject();
}
}
public static String objectToXMLJackson(Object obj)
throws JsonProcessingException {
XmlMapper xmlMapper = new XmlMapper();
if (xmlMapper.canSerialize(obj.getClass())) {
return xmlMapper.writeValueAsString(obj);
}
return "";
}
public static <T> T XMLToObjectJackson(String xml, Class<T> clazz)
throws JsonProcessingException {
XmlMapper xmlMapper = new XmlMapper();
return xmlMapper.readValue(xml, clazz);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P143_MonitoringDeserializationJfr/src/main/java/modern/challenge/Melon.java | Chapter06/P143_MonitoringDeserializationJfr/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P143_MonitoringDeserializationJfr/src/main/java/modern/challenge/Main.java | Chapter06/P143_MonitoringDeserializationJfr/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Melon melon = new Melon("Gac", 2500);
byte[] melonSer = Converters.objectToBytes(melon);
System.out.println("Serialization: " + Arrays.toString(melonSer));
System.out.println();
Melon melonDeser = (Melon) Converters.bytesToObject(melonSer);
System.out.println("Deserialization: " + melonDeser);
System.out.println();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P143_MonitoringDeserializationJfr/src/main/java/modern/challenge/Converters.java | Chapter06/P143_MonitoringDeserializationJfr/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
return ois.readObject();
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P135_PatternBasedStreamGlobalFilter/src/main/java/modern/challenge/Melon.java | Chapter06/P135_PatternBasedStreamGlobalFilter/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P135_PatternBasedStreamGlobalFilter/src/main/java/modern/challenge/Main.java | Chapter06/P135_PatternBasedStreamGlobalFilter/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.io.ObjectInputFilter;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/* create a pattern-based filter and set it for all the streams of this application */
ObjectInputFilter melonFilter = ObjectInputFilter.Config.createFilter("!modern.challenge.Melon;");
ObjectInputFilter.Config.setSerialFilter(melonFilter);
Melon melon = new Melon("Gac", 2500);
byte[] melonSer = Converters.objectToBytes(melon);
System.out.println("Serialization: " + Arrays.toString(melonSer));
System.out.println();
Melon melonDeser = (Melon) Converters.bytesToObject(melonSer);
System.out.println("Deserialization: " + melonDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P135_PatternBasedStreamGlobalFilter/src/main/java/modern/challenge/Converters.java | Chapter06/P135_PatternBasedStreamGlobalFilter/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
return ois.readObject();
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P139_DeserializationStackOverflowError/src/main/java/modern/challenge/Main.java | Chapter06/P139_DeserializationStackOverflowError/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.io.ObjectInputFilter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 'mapOfSets' is the object to serialize/deserialize
HashMap<Set, Integer> mapOfSets = new HashMap<>();
Set<Set> set = new HashSet<>();
mapOfSets.put(set, 1);
set.add(set);
// create a filter to avoid StackOverflowError
ObjectInputFilter filter = ObjectInputFilter.
Config.createFilter("maxdepth=2;java.base/*;!*");
byte[] mapSer = Converters.objectToBytes(mapOfSets);
System.out.println("Serialization: " + Arrays.toString(mapSer));
System.out.println();
HashMap mapDeser = (HashMap) Converters.bytesToObject(mapSer, filter);
System.out.println("Deserialization: " + mapDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P139_DeserializationStackOverflowError/src/main/java/modern/challenge/Converters.java | Chapter06/P139_DeserializationStackOverflowError/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes, ObjectInputFilter filter)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
ois.setObjectInputFilter(filter);
return ois.readObject();
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P138_CustomLambdaFilter/src/main/java/modern/challenge/Melon.java | Chapter06/P138_CustomLambdaFilter/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P138_CustomLambdaFilter/src/main/java/modern/challenge/Main.java | Chapter06/P138_CustomLambdaFilter/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.io.ObjectInputFilter.Status;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/* create a custom lambda filter and set it for all the streams of this application */
/*
ObjectInputFilter.Config
.setSerialFilter(f -> ((f.serialClass() != null)
// or, filter.serialClass().getName().equals("modern.challenge.Melon")
&& f.serialClass().getPackage().getName().equals("modern.challenge")
&& f.serialClass().getSimpleName().equals("Melon"))
? Status.REJECTED : Status.UNDECIDED);
*/
Melon melon = new Melon("Gac", 2500);
byte[] melonSer = Converters.objectToBytes(melon);
System.out.println("Serialization: " + Arrays.toString(melonSer));
System.out.println();
Melon melonDeser = (Melon) Converters.bytesToObject(melonSer,
f -> ((f.serialClass() != null)
// or, filter.serialClass().getName().equals("modern.challenge.Melon")
&& f.serialClass().getPackage().getName().equals("modern.challenge")
&& f.serialClass().getSimpleName().equals("Melon"))
? Status.REJECTED : Status.UNDECIDED);
System.out.println("Deserialization: " + melonDeser);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P138_CustomLambdaFilter/src/main/java/modern/challenge/Converters.java | Chapter06/P138_CustomLambdaFilter/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
try ( ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
return baos.toByteArray();
}
}
public static Object bytesToObject(byte[] bytes, ObjectInputFilter filter)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
// set the filter
ois.setObjectInputFilter(filter);
return ois.readObject();
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter1/src/main/java/modern/challenge/Filters.java | Chapter06/P137_CustomMethodFilter1/src/main/java/modern/challenge/Filters.java | package modern.challenge;
import java.io.ObjectInputFilter;
import java.io.ObjectInputFilter.FilterInfo;
import java.io.ObjectInputFilter.Status;
public final class Filters {
private Filters() {
throw new AssertionError("Cannot be instantiated");
}
public static ObjectInputFilter.Status melonFilter(FilterInfo info) {
Class<?> clazz = info.serialClass();
if (clazz != null) {
// or, clazz.getName().equals("modern.challenge.Melon")
return !(clazz.getPackage().getName().equals("modern.challenge")
&& clazz.getSimpleName().equals("Melon"))
? Status.ALLOWED : Status.REJECTED;
}
return Status.UNDECIDED;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter1/src/main/java/modern/challenge/Melon.java | Chapter06/P137_CustomMethodFilter1/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter1/src/main/java/modern/challenge/Main.java | Chapter06/P137_CustomMethodFilter1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/* create a custom method filter and set it for all the streams of this application */
// ObjectInputFilter.Config.setSerialFilter(Filters::melonFilter);
Melon melon = new Melon("Gac", 2500);
byte[] melonSer = Converters.objectToBytes(melon);
System.out.println("Serialization: " + Arrays.toString(melonSer));
System.out.println();
Melon melonDeser = (Melon) Converters.bytesToObject(melonSer, Filters::melonFilter);
System.out.println("Deserialization: " + melonDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter1/src/main/java/modern/challenge/Converters.java | Chapter06/P137_CustomMethodFilter1/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes, ObjectInputFilter filter)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
// set the filter
ois.setObjectInputFilter(filter);
return ois.readObject();
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Muskmelons.java | Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Muskmelons.java | package modern.challenge;
import java.io.Serializable;
public class Muskmelons extends Melon implements Serializable {
public Muskmelons(String type, float weight) {
super(type, weight);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Filters.java | Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Filters.java | package modern.challenge;
import java.io.ObjectInputFilter;
import java.io.ObjectInputFilter.FilterInfo;
import java.io.ObjectInputFilter.Status;
public final class Filters {
private Filters() {
throw new AssertionError("Cannot be instantiated");
}
public static ObjectInputFilter.Status melonFilter(FilterInfo info) {
Class<?> clazz = info.serialClass();
if (clazz != null) {
return (Melon.class.isAssignableFrom(clazz))
? ObjectInputFilter.Status.REJECTED
: ObjectInputFilter.Status.ALLOWED;
}
return Status.UNDECIDED;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Melon.java | Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Pumpkin.java | Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Pumpkin.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Pumpkin implements Serializable {
private final String type;
private final float weight;
public Pumpkin(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Pumpkin other = (Pumpkin) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Pumpkin{" + "type=" + type + ", weight=" + weight + '}';
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Cantaloupe.java | Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Cantaloupe.java | package modern.challenge;
import java.io.Serializable;
public class Cantaloupe extends Melon implements Serializable {
public Cantaloupe(String type, float weight) {
super(type, weight);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Main.java | Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.io.ObjectInputFilter;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/* create a custom method filter and set it for all the streams of this application */
ObjectInputFilter.Config.setSerialFilter(Filters::melonFilter);
Pumpkin pumpkin = new Pumpkin("Pumpkin", 2000);
Melon melon = new Melon("Gac", 2500);
Cantaloupe cantaloupe = new Cantaloupe("Cantaloupe", 5000);
Muskmelons muskmelons = new Muskmelons("Muskmelons", 1500);
byte[] pumpkinSer = Converters.objectToBytes(pumpkin); // this is not a melon
byte[] melonSer = Converters.objectToBytes(melon);
byte[] cantaloupeSer = Converters.objectToBytes(cantaloupe);
byte[] muskmelonsSer = Converters.objectToBytes(muskmelons);
System.out.println("Serialization (pumpkin): " + Arrays.toString(pumpkinSer));
System.out.println("Serialization (melon): " + Arrays.toString(melonSer));
System.out.println("Serialization (cantaloupe): " + Arrays.toString(cantaloupeSer));
System.out.println("Serialization (muskmelons): " + Arrays.toString(muskmelonsSer));
System.out.println();
Pumpkin pumpkinDeser = (Pumpkin) Converters.bytesToObject(pumpkinSer);
System.out.println("Deserialization (pumpkin): " + pumpkinDeser);
// filter status: REJECTED since this is a Melon
// Melon melonDeser = (Melon) Converters.bytesToObject(melonSer);
// System.out.println("Deserialization (melon): " + melonDeser);
// filter status: REJECTED since this is a Melon
// Cantaloupe cantaloupeDeser = (Cantaloupe) Converters.bytesToObject(cantaloupeSer);
// System.out.println("Deserialization (cantaloupe): " + cantaloupeDeser);
// filter status: REJECTED since this is a Melon
// Muskmelons muskmelonsDeser = (Muskmelons) Converters.bytesToObject(muskmelonsSer);
// System.out.println("Deserialization (muskmelons): " + muskmelonsDeser);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Converters.java | Chapter06/P137_CustomMethodFilter2/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try ( ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
}
baos.close();
return baos.toByteArray();
}
public static Object bytesToObject(byte[] bytes)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
return ois.readObject();
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P131_ObjectToByteArraySer/src/main/java/modern/challenge/Melon.java | Chapter06/P131_ObjectToByteArraySer/src/main/java/modern/challenge/Melon.java | package modern.challenge;
import java.io.Serializable;
import java.util.Objects;
public class Melon implements Serializable {
private final String type;
private final float weight;
public Melon(String type, float weight) {
this.type = type;
this.weight = weight;
}
public String getType() {
return type;
}
public float getWeight() {
return weight;
}
@Override
public int hashCode() {
int hash = 3;
hash = 97 * hash + Objects.hashCode(this.type);
hash = 97 * hash + Float.floatToIntBits(this.weight);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Melon other = (Melon) obj;
if (this.weight != other.weight) {
return false;
}
if (!Objects.equals(this.type, other.type)) {
return false;
}
return true;
}
@Override
public String toString() {
return "Melon{" + "type=" + type + ", weight=" + weight + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P131_ObjectToByteArraySer/src/main/java/modern/challenge/Main.java | Chapter06/P131_ObjectToByteArraySer/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.lang3.SerializationUtils;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Melon melon = new Melon("Gac", 2500);
byte[] melonSer = Converters.objectToBytes(melon);
System.out.println("Serialization: " + Arrays.toString(melonSer));
System.out.println();
Melon melonDeser = (Melon) Converters.bytesToObject(melonSer);
System.out.println("Deserialization: " + melonDeser);
System.out.println();
// using Apache Commons Lang
byte[] melonSerACL = SerializationUtils.serialize(melon);
System.out.println("Serialization (ACL): " + Arrays.toString(melonSerACL));
System.out.println();
Melon melonDeserACL = SerializationUtils.deserialize(melonSerACL);
System.out.println("Deserialization (ACL): " + melonDeserACL);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter06/P131_ObjectToByteArraySer/src/main/java/modern/challenge/Converters.java | Chapter06/P131_ObjectToByteArraySer/src/main/java/modern/challenge/Converters.java | package modern.challenge;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public final class Converters {
private Converters() {
throw new AssertionError("Cannot be instantiated");
}
public static byte[] objectToBytes(Serializable obj) throws IOException {
try ( ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream ois = new ObjectOutputStream(baos)) {
ois.writeObject(obj);
return baos.toByteArray();
}
}
public static Object bytesToObject(byte[] bytes)
throws IOException, ClassNotFoundException {
try ( InputStream is = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(is)) {
return ois.readObject();
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/PaymentService.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/PaymentService.java | package modern.challenge;
public class PaymentService {
class InvoiceCalculation {
final PaymentService paymentService;
InvoiceCalculation(PaymentService PaymentService.this) {
paymentService = PaymentService.this;
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Delivered.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Delivered.java | package modern.challenge;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.TYPE_USE)
public @interface Delivered {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Person.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Person.java | package modern.challenge;
public class Person {
// public String getAddress() { return ""; }
// public String getAddress(Person this) { return ""; } // These two methods are semantically the same
public String getAddress(Person this, String prevAddr) { return ""; } // These two methods are semantically the same
public String getAddress(@ValidAddress Person this) { return ""; }
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/ValidAddress.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/ValidAddress.java | package modern.challenge;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.TYPE_USE)
public @interface ValidAddress {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Cashed.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Cashed.java | package modern.challenge;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.TYPE_USE)
public @interface Cashed {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Truck.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Truck.java | package modern.challenge;
public class Truck {
public void revision1(Truck this) {
Truck thisTruck = this;
System.out.println("Truck: " + thisTruck);
}
public void revision2() {
Truck thisTruck = this;
System.out.println("Truck: " + thisTruck);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Parcel.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Parcel.java | package modern.challenge;
public class Parcel {
public void order(@New Parcel this) {}
public void shipping(@Ordered Parcel this) {}
public void deliver(@Shipped Parcel this) {}
public void cashit(@Delivered Parcel this) {}
public void done(@Cashed Parcel this) {}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Ordered.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Ordered.java | package modern.challenge;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.TYPE_USE)
public @interface Ordered {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Main.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
Truck truck = new Truck();
truck.revision1();
truck.revision2();
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Shipped.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/Shipped.java | package modern.challenge;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.TYPE_USE)
public @interface Shipped {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/New.java | Chapter02/P49_ReceiverParameter/src/main/java/modern/challenge/New.java | package modern.challenge;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.TYPE_USE)
public @interface New {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P52_Common5NPE/src/main/java/modern/challenge/ChainSaw.java | Chapter02/P52_Common5NPE/src/main/java/modern/challenge/ChainSaw.java | package modern.challenge;
import java.util.List;
public final class ChainSaw {
private static final List<String> MODELS
= List.of("T300", "T450", "T700", "T800", "T900");
private final String model;
private final String power;
private final int speed;
public boolean started;
private ChainSaw(String model, String power, int speed) {
this.model = model;
this.power = power;
this.speed = speed;
}
public static ChainSaw initChainSaw(String model) {
for (String m : MODELS) {
if (model.endsWith(m)) {
return new ChainSaw(model, null, (int) (Math.random() * 100));
}
}
return null;
}
public int performance(ChainSaw[] css) {
int score = 0;
for (ChainSaw cs : css) {
score += Integer.compare(this.speed, cs.speed);
}
return score;
}
public void start() {
if (!started) {
System.out.println("Started ...");
started = true;
}
}
public void stop() {
if (started) {
System.out.println("Stopped ...");
started = false;
}
}
public String getPower() {
return power;
}
@Override
public String toString() {
return "ChainSaw{" + "model=" + model
+ ", speed=" + speed + ", started=" + started + '}';
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P52_Common5NPE/src/main/java/modern/challenge/Main.java | Chapter02/P52_Common5NPE/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
// 1 - NPE when calling an instance method via a null object
ChainSaw cs = ChainSaw.initChainSaw("QW-T650"); // 'cs' is null
cs.start();
// 2 - NPE when accessing (or, modifying) field of a null object
// ChainSaw cs = ChainSaw.initChainSaw("QW-T650"); // 'cs' is null
// boolean isStarted = cs.started;
// 3 - NPE when null is passed in method argument
// ChainSaw cs = ChainSaw.initChainSaw(null); // the passed null can be the result of calling an external service
// 4 - NPE when accessing index value of null array (or, collection)
/*
ChainSaw myChainSaw = ChainSaw.initChainSaw("QWE-T800");
ChainSaw[] friendsChainSaw = new ChainSaw[]{
ChainSaw.initChainSaw("Q22-T450"),
ChainSaw.initChainSaw("QRT-T300"),
ChainSaw.initChainSaw("Q-T900"),
null, // ops!
ChainSaw.initChainSaw("QMM-T850"), // this model is not supported
ChainSaw.initChainSaw("ASR-T900")
};
int score = myChainSaw.performance(friendsChainSaw);
*/
// 5 - NPE when accessing a field via a getter
// ChainSaw cs = ChainSaw.initChainSaw("T5A-T800");
// String power = cs.getPower();
// System.out.println(power.concat(" Watts"));
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P64_GuardedPatternsSwitch1JDK17/src/main/java/modern/challenge/House.java | Chapter02/P64_GuardedPatternsSwitch1JDK17/src/main/java/modern/challenge/House.java | package modern.challenge;
class Heater {}
class Stove extends Heater {}
class Chimney extends Heater {
private final boolean electric;
public Chimney(boolean electric) {
this.electric = electric;
}
public boolean isElectric() {
return electric;
}
}
public class House {
private static String turnOnTheHeat(Heater heater) {
return switch (heater) {
case Stove stove -> "Make a fire in the stove";
case Chimney chimney && chimney.isElectric() -> "Plug in the chimney";
case Chimney chimney -> "Make a fire in the chimney";
default -> "No heater available!";
};
}
public static void main(String[] args) {
System.out.println(turnOnTheHeat(new Stove()));
System.out.println(turnOnTheHeat(new Chimney(true)));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P39_CheckIndexSubRangeZeroLength/src/main/java/modern/challenge/Pipes.java | Chapter02/P39_CheckIndexSubRangeZeroLength/src/main/java/modern/challenge/Pipes.java | package modern.challenge;
import java.util.Objects;
public final class Pipes {
private Pipes() {
throw new AssertionError("Cannot be instantiated");
}
public static boolean isPressureSupportedV1(int avgPresure, int unitsOfPressure, int maxPressure) {
if(avgPresure < 0 || unitsOfPressure < 0 || maxPressure < 0
|| (avgPresure + unitsOfPressure) > maxPressure) {
throw new IndexOutOfBoundsException("One or more parameters are out of bounds");
}
// the secret algorithm
return (avgPresure + unitsOfPressure) < (maxPressure - maxPressure/4);
}
public static boolean isPressureSupportedV2(int avgPresure, int unitsOfPressure, int maxPressure) {
Objects.checkFromIndexSize(avgPresure, unitsOfPressure, maxPressure);
// the secret algorithm
return (avgPresure + unitsOfPressure) < (maxPressure - maxPressure/4);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P39_CheckIndexSubRangeZeroLength/src/main/java/modern/challenge/NumberConverter.java | Chapter02/P39_CheckIndexSubRangeZeroLength/src/main/java/modern/challenge/NumberConverter.java | package modern.challenge;
import java.util.Objects;
public final class NumberConverter {
private NumberConverter() {
throw new AssertionError("Cannot be instantiated");
}
public static int toLeIntV1(byte[] arr, int offset) {
if (offset < 0
|| Integer.BYTES < 0 // not necessary
|| arr.length < 0 // not necessary
|| (offset + Integer.BYTES) > arr.length) {
throw new IndexOutOfBoundsException();
}
int leint = arr[offset + 3];
for (int i = 2; i >= 0; i--) {
leint = (leint << 8) | (arr[offset + i] & 0xff);
}
return leint;
}
public static int toLeIntV2(byte[] arr, int offset) {
Objects.checkFromIndexSize(offset, Integer.BYTES, arr.length);
int leint = arr[offset + 3];
for (int i = 2; i >= 0; i--) {
leint = (leint << 8) | (arr[offset + i] & 0xff);
}
return leint;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P39_CheckIndexSubRangeZeroLength/src/main/java/modern/challenge/Main.java | Chapter02/P39_CheckIndexSubRangeZeroLength/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.math.BigInteger;
public class Main {
public static void main(String[] args) throws IOException {
boolean result1 = Pipes.isPressureSupportedV1(2, 5, 8);
boolean result2 = Pipes.isPressureSupportedV2(2, 5, 12);
System.out.println("Pressure supported (V1): " + result1);
System.out.println("Pressure supported (V2): " + result2);
// expected result, 365779719
int x1 = NumberConverter.toLeIntV1(BigInteger.valueOf(123456789).toByteArray(), 0);
int x2 = NumberConverter.toLeIntV1(BigInteger.valueOf(123456789).toByteArray(), 0);
System.out.println("x1 = " + x1);
System.out.println("x2 = " + x2);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P45_InnerClassesAndStatics/src/main/java/modern/challenge/NewConnection.java | Chapter02/P45_InnerClassesAndStatics/src/main/java/modern/challenge/NewConnection.java | package modern.challenge;
public class NewConnection { // singleton
private NewConnection() {
}
public static NewConnection get() {
class LazyConnection { // holder
static final NewConnection INSTANCE = new NewConnection();
static {
System.out.println("Initializing new connection ..." + INSTANCE);
}
}
return LazyConnection.INSTANCE;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P45_InnerClassesAndStatics/src/main/java/modern/challenge/Main.java | Chapter02/P45_InnerClassesAndStatics/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
A a = new A();
A.B b1 = a.new B();
A.B b2 = a.new B();
A.B b3 = a.new B();
System.out.println();
OldConnection oldConn1 = OldConnection.get();
OldConnection oldConn2 = OldConnection.get();
OldConnection oldConn3 = OldConnection.get();
System.out.println();
NewConnection newConn1 = NewConnection.get();
NewConnection newConn2 = NewConnection.get();
NewConnection newConn3 = NewConnection.get();
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P45_InnerClassesAndStatics/src/main/java/modern/challenge/OldConnection.java | Chapter02/P45_InnerClassesAndStatics/src/main/java/modern/challenge/OldConnection.java | package modern.challenge;
public class OldConnection { // singleton
private OldConnection() {
}
private static class LazyConnection { // holder
static final OldConnection INSTANCE = new OldConnection();
static {
System.out.println("Initializing old connection ..." + INSTANCE);
}
}
public static OldConnection get() {
return LazyConnection.INSTANCE;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P45_InnerClassesAndStatics/src/main/java/modern/challenge/A.java | Chapter02/P45_InnerClassesAndStatics/src/main/java/modern/challenge/A.java | package modern.challenge;
public class A {
public class B {
{
System.out.println("Non-static initializer ...");
}
static {
System.out.println("Static initializer ...");
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P38_Emoji/src/main/java/modern/challenge/Charsets.java | Chapter02/P38_Emoji/src/main/java/modern/challenge/Charsets.java | package modern.challenge;
import java.util.List;
import java.util.regex.Pattern;
import static java.util.stream.Collectors.toList;
import java.util.stream.IntStream;
public class Charsets {
private Charsets() {
throw new AssertionError("Cannot be instantiated");
}
public static boolean containsEmojiV1(String str) {
if (str == null) {
throw new IllegalArgumentException("The given string cannot be null");
}
return str.codePoints().anyMatch(Character::isEmoji);
}
public static boolean containsEmojiV2(String str) {
if (str == null) {
throw new IllegalArgumentException("The given string cannot be null");
}
// using snake-regex you can write {IsEmoji_Modifier_Base}, {IsEmoji_Presentation}, and so on
return Pattern.compile("\\p{IsEmoji}").matcher(str).find();
}
public static List<String> getAllEmoji() {
return IntStream.range(0, Integer.MAX_VALUE)
.filter(Character::isEmoji)
.mapToObj(Character::toChars)
.map(String::valueOf)
.collect(toList());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P38_Emoji/src/main/java/modern/challenge/Main.java | Chapter02/P38_Emoji/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
public class Main {
public static final String STR_NO_EMOJI = "?I love you so much!";
public static final String STR_WITH_EMOJI = "๐ I love ๐ you ำ so much ๐ ๐ ๐ผ๐ผ๐ผ!";
public static void main(String[] args) {
System.out.println(Charsets.containsEmojiV1(STR_NO_EMOJI));
System.out.println(Charsets.containsEmojiV1(STR_WITH_EMOJI));
System.out.println(Charsets.containsEmojiV2(STR_NO_EMOJI));
System.out.println(Charsets.containsEmojiV2(STR_WITH_EMOJI));
List<String> allEmoji = Charsets.getAllEmoji();
System.out.println("There are " + allEmoji.size() + " emoji \n");
System.out.println(allEmoji);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P64_GuardedPatternsSwitch2/src/main/java/modern/challenge/Assess.java | Chapter02/P64_GuardedPatternsSwitch2/src/main/java/modern/challenge/Assess.java | package modern.challenge;
import static modern.challenge.FuelType.GASOLINE;
import static modern.challenge.FuelType.HYDROGEN;
import static modern.challenge.FuelType.KEROSENE;
enum FuelType { GASOLINE, HYDROGEN, KEROSENE }
class Vehicle {
private final int gallon;
private final FuelType fuel;
public Vehicle(int gallon, FuelType fuel) {
this.gallon = gallon;
this.fuel = fuel;
}
public int getGallon() {
return gallon;
}
public FuelType getFuel() {
return fuel;
}
}
public class Assess {
private static String theVehicle(Vehicle vehicle) {
return switch (vehicle) {
case Vehicle v when (v.getFuel().equals(GASOLINE)
&& v.getGallon() < 120) -> "probably a car/van";
case Vehicle v when (v.getFuel().equals(GASOLINE)
&& v.getGallon() > 120) -> "probably a big rig";
case Vehicle v when (v.getFuel().equals(HYDROGEN)
&& v.getGallon() < 300_000) -> "probably an aircraft";
case Vehicle v when (v.getFuel().equals(HYDROGEN)
&& v.getGallon() > 300_000) -> "probably a rocket";
case Vehicle v when (v.getFuel().equals(KEROSENE)
&& v.getGallon() > 2_000 && v.getGallon() < 6_000)
-> "probably a narrow-body aircraft";
case Vehicle v when (v.getFuel().equals(KEROSENE)
&& v.getGallon() > 6_000 && v.getGallon() < 55_000)
-> "probably a large (B747-400) aircraft";
default -> "no clue";
};
}
public static void main(String[] args) {
System.out.println(theVehicle(new Vehicle(500, GASOLINE)));
System.out.println(theVehicle(new Vehicle(2000, HYDROGEN)));
System.out.println(theVehicle(new Vehicle(20000, KEROSENE)));
System.out.println(theVehicle(new Vehicle(20, KEROSENE)));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P59_BindingVariableScopeInstanceof/src/main/java/modern/challenge/Usb.java | Chapter02/P59_BindingVariableScopeInstanceof/src/main/java/modern/challenge/Usb.java | package modern.challenge;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class Usb {
public static String save(Object o) throws IOException {
// 'file' is created ONLY if 'instanceof' returns true
if (o instanceof File file
// this is evaluated ONLY if 'file' was created
&& file.length() > 0 && file.length() < 1000) {
return "Saving a file of size: " + String.format("%,d bytes", file.length());
}
if (o instanceof Path path && Files.size(path) > 0 && Files.size(path) < 1000) {
return "Saving a file of size: " + String.format("%,d bytes", Files.size(path));
}
if (!(o instanceof String str)) {
// str is not available here
return "I cannot save the given object";
} else {
return "Saving a string of size: " + String.format("%,d bytes", str.length());
}
}
// works with early returns
public static int getStringLength(Object o) {
if (!(o instanceof String str)) {
return 0;
}
return str.length();
}
// no overlap risks, but DON'T DO THIS!
private static String strNumber(Object o) {
if (o instanceof Integer nr) {
return String.valueOf(nr.intValue());
} else if (o instanceof Long nr) {
return String.valueOf(nr.longValue());
} else {
// nr is out of scope here
return "Probably a float number";
}
}
// DON'T DO THIS!
private static final String str = " I am a string with leading and trailing spaces ";
public static String convert(Object o) {
if (o instanceof String str) { // local variable (binding variable) hides a field
return str.strip(); // refers to binding variable, str
} else {
return str.strip(); // refers to field, str
}
}
// Reassigning binding variable is not possible in JDK 14/15,
// but it is starting with JDK 16+
// HOWEVER, DON'T DO THIS!
static String dummy = "";
private static int getLength(Object o) {
if(o instanceof String str) {
str = dummy; // reassigning binding variable
return str.length(); // returns the length of 'dummy' not the passed 'str'
}
return 0;
}
public static void main(String[] args) throws IOException {
System.out.println(save(Paths.get("pom.xml")));
System.out.println(save(new File("pom.xml")));
System.out.println(save("This is a plain string"));
System.out.println("The string 'text' has a length of: " + getLength("text"));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P51_CommonStringMistake/src/main/java/modern/challenge/Main.java | Chapter02/P51_CommonStringMistake/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
String str = "start";
str = stopItWrong(str);
System.out.println("Stop it (wrong): " + str);
str = stopItGood1(str); // or, stopItGood2(str)
System.out.println("Stop it (good): " + str);
}
public static String stopItWrong(String str) {
str.replace(str, "stop");
return str;
}
public static String stopItGood1(String str) {
str = str.replace(str, "stop");
return str;
}
public static String stopItGood2(String str) {
return str.replace(str, "stop");
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P56_ClassicInstanceof/src/main/java/modern/challenge/Main.java | Chapter02/P56_ClassicInstanceof/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.ArrayList;
import java.util.List;
public class Main {
interface Furniture {};
static class Plywood {};
static class Wardrobe extends Plywood implements Furniture {};
public static void main(String[] args) {
Wardrobe wardrobe = new Wardrobe();
System.out.println("wardrobe instanceof Wardrobe ? "
+ (wardrobe instanceof Wardrobe));
Plywood plywood = new Plywood();
System.out.println("plywood instanceof Plywood ? "
+ (plywood instanceof Plywood));
System.out.println("wardrobe instanceof Plywood ? "
+ (wardrobe instanceof Plywood));
System.out.println("wardrobe instanceof Furniture ? "
+ (wardrobe instanceof Furniture));
System.out.println("plywood instanceof Furniture ? "
+ (plywood instanceof Furniture));
System.out.println("String instanceof Object ? "
+ (String.valueOf("foo") instanceof Object));
System.out.println("null instanceof Object ? "
+ (null instanceof Object));
List plywoods = List.of(new Plywood());
System.out.println("plywoods instanceof List ? "
+ (plywoods instanceof List));
int[] ints = new int[] {1, 2, 3};
System.out.println("ints instanceof int[] ? "
+ (ints instanceof int[]));
listOf(1, 2, 3);
listOf(List.of(1,2,3));
}
public static <T> void listOf(T... t) {
List<T> list = List.of(t);
System.out.println("list instanceof List ? " + (list instanceof List));
System.out.println("list instanceof List<?> ? " + (list instanceof List<?>));
System.out.println("list instanceof List<T> ? " + (list instanceof List<T>));
// compile-time error
// System.out.println("list instanceof List<Integer> ? " + (list instanceof List<Integer>));
}
public static <T> void listOf(List<T> list) {
System.out.println("list instanceof ArrayList<T> ? " + (list instanceof ArrayList<T>));
System.out.println("list instanceof ArrayList<?> ? " + (list instanceof ArrayList<?>));
// compile-time error
// System.out.println("list instanceof ArrayList<Integer> ? " + (list instanceof ArrayList<Integer>));
System.out.println("list instanceof List<T> ? " + (list instanceof List<T>));
System.out.println("list instanceof List<?> ? " + (list instanceof List<?>));
// compile-time error
// System.out.println("list instanceof List<String> ? " + (list instanceof List<String>));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P65_TypePatternSwitchDominance/src/main/java/modern/challenge/Main.java | Chapter02/P65_TypePatternSwitchDominance/src/main/java/modern/challenge/Main.java |
package modern.challenge;
import java.util.Arrays;
import static modern.challenge.Main.Hero.HULK;
import static modern.challenge.Main.Hero.IRON_MAN;
public class Main {
static abstract class Pill {}
static class Nurofen extends Pill {}
static class Ibuprofen extends Pill {}
static class Piafen extends Pill {}
private static String headache(Pill o) {
return switch(o) {
case Nurofen nurofen -> "Get Nurofen ...";
case Ibuprofen ibuprofen -> "Get Ibuprofen ...";
case Piafen piafen -> "Get Piafen ...";
default -> "Sorry, we cannot solve your headache!";
};
}
static abstract class Drink {}
static class Small extends Drink {}
static class Medium extends Small {}
static class Large extends Medium {}
static class Extra extends Medium {}
static class Huge extends Extra {}
static class Jumbo extends Extra {}
private static String buyDrink(Drink o) {
return switch(o) {
case Jumbo j: yield "We can give a Jumbo ...";
case Huge h: yield "We can give a Huge ...";
case Extra e: yield "We can give a Extra ...";
case Large l: yield "We can give a Large ...";
case Medium m: yield "We can give a Medium ...";
case Small s: yield "We can give a Small ...";
default: yield "Sorry, we don't have this drink!";
};
}
private static int oneHundredDividedBy(Integer value) {
return switch(value) {
case 0 -> 0;
case Integer i -> 100/i;
};
}
enum Hero { CAPTAIN_AMERICA, IRON_MAN, HULK }
private static String callMyMarvelHero(Hero hero) {
return switch(hero) {
case HULK -> "Sorry, we cannot call this guy!";
case Hero h -> "Calling " + h;
};
}
private static int oneHundredDividedByPositive(Integer value) {
return switch(value) {
case 0 -> 0;
case Integer i when i > 0 -> 100/i;
case Integer i -> (-1) * 100/i;
};
}
public static void main(String[] args) {
Arrays.asList(new Nurofen(), new Ibuprofen(), new Piafen()).stream()
.map(Main::headache)
.forEach(System.out::println);
System.out.println();
Arrays.asList(new Jumbo(), new Huge(), new Extra(), new Large(), new Medium(), new Small()).stream()
.map(Main::buyDrink)
.forEach(System.out::println);
System.out.println();
System.out.println(oneHundredDividedBy(10));
System.out.println(oneHundredDividedBy(0));
System.out.println();
System.out.println(callMyMarvelHero(IRON_MAN));
System.out.println(callMyMarvelHero(HULK));
System.out.println();
System.out.println(oneHundredDividedByPositive(10));
System.out.println(oneHundredDividedByPositive(0));
System.out.println(oneHundredDividedByPositive(-10));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter02/P52_WorkingAroundNPE/src/main/java/modern/challenge/ChainSaw.java | Chapter02/P52_WorkingAroundNPE/src/main/java/modern/challenge/ChainSaw.java | package modern.challenge;
import java.util.List;
public final class ChainSaw {
private static final String UNKNOWN_POWER = "UNKNOWN";
private static final List<String> MODELS
= List.of("T300", "T450", "T700", "T800", "T900");
private final String model;
private final String power;
private final int speed;
public boolean started;
private ChainSaw(String model, String power, int speed) {
this.model = model;
this.power = power;
this.speed = speed;
}
public static ChainSaw initChainSaw(String model) {
if (model == null || model.isBlank()) {
throw new IllegalArgumentException("The given model cannot be null/empty");
}
for (String m : MODELS) {
if (model.endsWith(m)) { // m.endsWith(model) will not fix NPE as in equals() case
// TO DO (JIRA ####): replace UNKNOWN_POWER with code
return new ChainSaw(model, UNKNOWN_POWER, (int) (Math.random() * 100));
}
}
throw new UnsupportedOperationException("Model " + model + " is not supported");
}
public int performance(ChainSaw[] css) {
if (css == null) {
throw new IllegalArgumentException("The given models cannot be null");
}
int score = 0;
for (ChainSaw cs : css) {
if (cs != null) {
score += Integer.compare(this.speed, cs.speed);
}
}
return score;
}
public void start() {
if (!started) {
System.out.println("Started ...");
started = true;
}
}
public void stop() {
if (started) {
System.out.println("Stopped ...");
started = false;
}
}
public String getPower() {
return power;
}
@Override
public String toString() {
return "ChainSaw{" + "model=" + model
+ ", speed=" + speed + ", started=" + started + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.