json – Problemas de seguridad al serializar lambdas en Java

Estoy practicando con la serialización de objetos en Java y un colega me dijo que los objetos serializables no se usan en la vida real y que mejor serializase los objetos a JSON o XML cuando se me ocurrió esto:

Quiero precargar algunos FileFilters para usarlos en un JFileChooser y quiero que el comportamiento de esos filtros sea algo más que extensiones.

El código funciona correctamente pero he leido que puede haber problemas de seguridad al leer código ejecutable de un archivo. ¿Es cierto en este caso? ¿Se pueden evitar de alguna forma?

Como Predicate no es serializable, tuve que implementar mi propio Predicate:

import java.io.File;
import java.io.Serializable;

public interface MyPredicate extends Serializable {
  boolean isValid(File file);
}

La clase que define cómo van a ser los filtros (aunque se llame List y use internamente un Map, luego podría cambiar).

import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;


public class FileFilterList implements Serializable {
  private Map<String, MyPredicate> filters;

  public FileFilterList() {
    this.filters = new HashMap<>();
  }

  public FileFilterList addFilter(String string, MyPredicate predicate) {
    this.filters.put(string, predicate);
    return this;
  }

  public Iterator<Map.Entry<String, MyPredicate>> getIterator() {
    return this.filters.entrySet().iterator();
  }
}

Programita que guarda tres filtros como ejemplo:

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SaveFileFilter {
  public static void main(String() args) throws IOException {
    FileFilterList filterList = new FileFilterList();
    filterList
            .addFilter("txt, Text files", f -> f.isDirectory() || f.getName().endsWith(".txt"))
            .addFilter("Big txt, Big txt files (>1Kb)", f -> f.isDirectory() || (f.getName().endsWith(".txt") || f.length() > 1024))
            .addFilter("Small txt, Small txt file (<=1Kb)", f -> f.isDirectory() || (f.getName().endsWith(".txt") || f.length() <= 1024));
    try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("filters.obj"))) {
      oos.writeObject(filterList);
    } catch (IOException ioe) {
      System.err.println("Sorry, there wa a problem saving filters");
      ioe.printStackTrace();
      throw ioe;
    }
  }
}

Este sería el programa que realmente usa el fichero de filtros

import javax.swing.*;
import javax.swing.filechooser.FileFilter;
import java.io.*;

public class FileFilterUse {
  public static void main(String() args) throws IOException, ClassNotFoundException {
    JFileChooser fileChooser = new JFileChooser();
    try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("filters.obj"))) {
      FileFilterList filterList = (FileFilterList) ois.readObject();
      filterList.getIterator().forEachRemaining(
              (entry) -> fileChooser.addChoosableFileFilter(new FileFilter() {
                @Override
                public boolean accept(File f) {
                  return entry.getValue().isValid(f);
                }

                @Override
                public String getDescription() {
                  return entry.getKey();
                }
              }));
      fileChooser.showOpenDialog(null);
    } catch (IOException ioe) {
      System.err.println("There was a problem reading filters file");
      ioe.printStackTrace();
      throw ioe;
    } catch (ClassNotFoundException cnf) {
      System.err.println("File format is not correct");
      cnf.printStackTrace();
      throw cnf;
    }
  }
}

¿Es posible conseguir este comportamiento serializando a JSON o XML?
Gracias.