El Formulario uno tienes JTextfields ?

Debes obtener los valores de esos campos de cada uno y luego llenar el JComboBox.


Mira la linea 51 a 71, donde usamos los valores del JTextField para llenar el JComboBox,

* Linea 57, 58, 59 el método getText() contiene el valor de el input o JTextField

class Trabajador {
    private String nombre;
    private String apellido;
    private String correo;
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    public String getApellido() {
        return apellido;
    }
 
    public void setApellido(String apellido) {
        this.apellido = apellido;
    }
 
    public String getCorreo() {
        return correo;
    }
 
    public void setCorreo(String correo) {
        this.correo = correo;
    }
 
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append(this.nombre);
        return sb.toString();
    }
}
 

 
/**
 * @author rubn
 */
public class FillJComboBoxWithJTextFields extends JFrame {
 
    private JTextField textField = new JTextField();
    private JTextField textField2 = new JTextField();
    private JTextField textField3 = new JTextField();
 
    private JLabel labelNombre = new JLabel("Insertar Nombre", SwingConstants.LEFT);
    private JLabel labelApellido = new JLabel("Insertar Apellido", SwingConstants.LEFT);
    private JLabel labelCorreo = new JLabel("Insertar Correo", SwingConstants.LEFT);
 
    private JComboBox<Trabajador> jComboBox = new JComboBox<>();
    private JButton button = new JButton("Llenar JComboBox");
    private JButton limpiar = new JButton("Limpiar todo");
    private JPanel jPanel = new JPanel();
 
    public FillJComboBoxWithJTextFields() {
        jPanel.setLayout(new BoxLayout(jPanel, BoxLayout.Y_AXIS));
        super.add(jPanel);
        jPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
        jPanel.add(this.leftJLabel(this.labelNombre));
        jPanel.add(textField);
        jPanel.add(Box.createVerticalStrut(10));
        jPanel.add(this.leftJLabel(this.labelApellido));
        jPanel.add(textField2);
        jPanel.add(Box.createVerticalStrut(10));
        jPanel.add(this.leftJLabel(this.labelCorreo));
        jPanel.add(textField3);
        jPanel.add(Box.createVerticalStrut(10));
        jPanel.add(this.jComboBox);
        jPanel.add(Box.createVerticalStrut(10));
 
        JPanel jPanelHorizontal = new JPanel();
        jPanelHorizontal.add(this.button);
        jPanelHorizontal.add(this.limpiar);
        jPanel.add(jPanelHorizontal);
 
        Stream.of(button, limpiar)
                .forEach(buttons -> buttons.setBorderPainted(false));
 
        super.pack();
        super.setLocationRelativeTo(null);
        super.setVisible(true);
        super.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.initBehaviour();
    }
 
    /**
     * * Comportamiento del boton donde se extraen los valores de los JTextField
     * * También listener del botón de limpieza
     */
    private void initBehaviour() {
        this.button.addActionListener((ActionEvent event) -> {
            String nombre = textField.getText().trim();
            String apellido = textField2.getText().trim();
            String correo = textField3.getText().trim();
            if (Stream.of(nombre, apellido, correo)
                    .noneMatch(String::isEmpty)) {
                final Trabajador trabajador = new Trabajador();
                trabajador.setNombre(nombre);
                trabajador.setApellido(apellido);
                trabajador.setCorreo(correo);
                this.jComboBox.addItem(trabajador);
            } else {
                JOptionPane.showMessageDialog(this,"Llenar todos los inputs",
                        "Error", JOptionPane.ERROR_MESSAGE);
            }
        });
 
        this.limpiar.addActionListener((ActionEvent event) -> {
            this.jComboBox.removeAllItems();
            Stream.of(textField, textField2, textField3)
                    .forEach(text -> {
                        text.setText("");
                    });
        });
 
    }
 
    private JPanel leftJLabel(final JLabel jLabel) {
       final JPanel panel = new JPanel(new BorderLayout());
        panel.add(jLabel, BorderLayout.LINE_START);
        return panel;
    }
 
    public static void main(String[] args) {
        new Thread(FillJComboBoxWithJTextFields::new).start();
    }
}
 

El proceso es mas complejo, yo creo que es mejor que lo lleves a un servicio tecnico.

* Cosas como que le hagan un resplado a la ROM creo que seria lo primero.
* Tu podrias quizas intentar lograr conexion por medio de "adb"

Pero por lo mismo, que a pesar de la depre, usted se destaca por no caer en la droga.

recuerde eso siempre.

Claro de ahi su nombre.

Conocido desde los primeros llacimientos de este foro, dandole caña a los *************

Usa GeShI


Para escribir objetos de manera binaria con ObjectInput/Output Stream, esta diseñada para escribir solo una vez socio, sino tendrias que reimplemantar una clase tu mismo.

/**
 * @implSpec THREAD-SAFE
 *  @autor rub'n 
 */
@Value
@Builder
public class Persona implements Serializable {
    String nombre;
    String apellido;
    String correo;
}

/**
 * @autor rub'n
 */
@Slf4j
public class ConObjectIOStream {
 
    private static final String RUTA_FICHERO = "./temporal.tmp";
 
    private ConObjectIOStream() {
        throw new IllegalAccessError("Constructor privado");
    }
 
    /**
     * Para leer desde el fichero
     *
     * @return List<Persona>
     */
    private static List<Persona> readFromFile() {
        final List<Persona> listaPersona = new CopyOnWriteArrayList<>();
        final Path pathAlimento = Paths.get(RUTA_FICHERO);
        if(pathAlimento.toFile().exists()) {
            try (final BufferedInputStream bin = new BufferedInputStream(Files.newInputStream(pathAlimento));
                 final ObjectInputStream ob = new ObjectInputStream(bin)) {
 
                while (Boolean.TRUE) {
                    synchronized (ConObjectIOStream.class) { //en caso de que readFrom se invoque desde un Thread()
                        final Object object = ob.readObject();
                        if (object instanceof Persona) {
                            listaPersona.add((Persona) object);
                        }
                    }
                }
                ob.reset();
            } catch (IOException | ClassNotFoundException e) {
                //no hacer nada EOFException
                log.error("Error al leer {}", e);
            }
        } else {
            log.error("Error al leer del fichero {}", pathAlimento.toFile());
        }
 
        return List.copyOf(listaPersona)
                .stream()
                .sorted(Comparator.comparing(Persona::getNombre))
                .collect(Collectors.toList());
    }
 
    /**
     * Para escribir en el fichero
     */
    private static void writePersonToTempFile(final Persona ...persona) {
        final Path pathTem = Paths.get(RUTA_FICHERO);
        try (final OutputStream out = Files.newOutputStream(pathTem, StandardOpenOption.CREATE);
             final BufferedOutputStream bos = new BufferedOutputStream(out);
             final ObjectOutputStream ob = new ObjectOutputStream(bos)) {
 
            synchronized (ConObjectIOStream.class) {
                Arrays.stream(persona)
                        .forEach((Persona p) -> writeObject(ob, p));
            }
            ob.reset();
        } catch (IOException e) {
            log.error("Error al escribir en archivo {} ", e);
        }
    }
 
    private static void writeObject(final ObjectOutputStream ob, final Persona persona) {
        try {
            ob.writeObject(persona);
        } catch (IOException e) {
            log.error("Error al escribir objecto {} ", e);
        }
    }
 
    public static void main(String[] args) {
 
        final Persona persona1 = Persona.builder()
                .nombre("ruben")
                .apellido("La muerte")
                .correo("rrara@gmail.com")
                .build();
 
        final Persona persona2 = Persona.builder()
                .nombre("El loco")
                .apellido("La locura")
                .correo("crazyGuy@gmail.com")
                .build();
 
        /*
         * Para escribir
         */
        ConObjectIOStream.writePersonToTempFile(persona1, persona2);
 
        /*
         * Leer
         */
        ConObjectIOStream.readFromFile()
                .forEach((Persona persona) -> log.info("Persona {}", persona));
 
    }
 
}

Yo te comente por telegram que si estaba interesado. recuerdas que vimos el discourse de la gente mongo?

https://www.mongodb.com/community/forums/

* Perdoname tu aqui, te complique, la api itext tu le pasas la salida de tu pdf. la ruta mejor dicho.

Es posible que me compartas el proyecto asi por privado?

Ese error de esa dependencia no deberias de tenerla socio.

Intenta probar esta a ver que tal.

https://developer.android.com/reference/android/graphics/pdf/PdfRenderer.html

Okk bien eso es, si te trancas siempre empieza desde el inicio que seguro algo se escape socio.

Si te fijas ambas dependencias son números diferentes una más actual que otra.

Usa la 7.1.16

Prueba el ejemplo así como esta, y crea tu pdf con a penas una letra en el y ábrelo con el plugin que te pase de android.

Aplica la de Jack el destripador, "empecemos por partes"


* Que estas haciendo actualmente para leer desde la memoria externa?

@MaX2 Te estas volviendo loco

Con el api también puedes leer, escribir, crearlo etc.

Wtf, estas hablando como para atrás y palante como dice  en mi jodida tierra.