Hola, gracias por responder, lo que intento es leer el archivo linea por linea , rescatar dos campos de la estructura 2, y los demás campos de la estructura 3( el archivo corresponde a un detalle de pago de proveedores la estructura 2 identifica al proveedor y la 3 los doc que se pagan ) para armar un resulset con esos datos concatenados, el problema es que las lineas no tienen un caracter o espacio uniforme que corte los campos, y debido a mi corta experiencia en programación , no logro dar con una rutina que me haga toda esta tarea.
El archivo lo dejé en : https://onedrive.live.com/?cid=96957CBF27FD83C0&id=96957CBF27FD83C0%21105

Hola, estuve revisando lo que me indicas y claro, si yo pongo solo una condicion IF, me muestra perfectamente , por ejemplo las lineas que comienzan con 02, pero se pierde al poner el segundo if con otra estructura de substring .
Lo que yo busco y te pido disculpas si es que no me he explicado bien, es que me muestre algo como lo que sigue donde RUT y DIGITO se leen al pasar por una linea que comienza con 02 y se agregan o concatenan mientras lea la linea que comienza con 03 para armar una tabla con una sola estructura. espero se entienda

RUT DIGITO TIPO TIPODOC DOC CUOTA MONTO

Guenas.

Hace algún tiempo prepare una clase para simular struct de C.
Básicamente lo que facilita es precisamente leer y escribir datos de longitud fija.
Utiliza como almacenamiento un ByteBuffer.

Os pondré el código por si os resulta útil.


package util.struct;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.util.Arrays;
import java.util.LinkedHashMap;

/**
*
* @author vidalram
*/
public class Struct {
private TIPO tipo;
private NATIVO nativo;
private ByteOrder byteOrder=ByteOrder.BIG_ENDIAN;
private int capacidad;
private boolean materializado=false;
private String nombre;
private ByteBuffer buffer=null;
private final LinkedHashMap<String, Struct> listaDatos =new LinkedHashMap<String, Struct>();
private Struct[] elementos=new Struct[0];
private byte clearByte=0;

/**
* Tipo de estructura
*/
public static enum TIPO {
SIMPLE,
GRUPO,
ARRAY,
NATIVO;
}

/**
* En el caso de estructuras nativas indica el tipo
*/
public static enum NATIVO {
SHORT(2),
INT(4),
LONG(8),
FLOAT(4),
DOUBLE(8);

private final int size;
NATIVO(int size) {
this.size=size;
}

private int getNumBytes() {
return size;
}
}

/**
* Crea una estructura con un nombre y una determinada capacidad.
* Se utiliza para generar los elementos simples
*
* @param nombre String
* @param capacidad int
*/
public Struct(String nombre, int capacidad) {
this.tipo= TIPO.SIMPLE;
this.nombre=nombre.toUpperCase().trim();
this.capacidad = capacidad;
}

/**
* Crea un estructura que forma un array de elementos de un tipo de estructura
*
* @param elemento Estructura
* @param size int
*/
public Struct(Struct elemento, int size) {
this(elemento.nombre);
this.tipo= TIPO.ARRAY;
elementos=new Struct[size];
// capacidad=size*elemento.capacidad;
for(int nn=0;nn<size;nn++) {
elementos[nn]=elemento.copia();
}
}

/**
* Crea una estructura sin ninguna capacidad determinada.
* La capacidad se calculara a medida que se le añadan subestructuras
*
* @param nombre String
*/
public Struct(String nombre) {
this.tipo= TIPO.GRUPO;
this.nombre=nombre.toUpperCase().trim();
}

/**
* Crea una estructura para almacenar un tipo nativo.
* La capacidad se calculara a medida que se le añadan subestructuras
*
* @param nombre String
* @param tipoNativo NATIVO
* @param ordenBytes
*/
public Struct(String nombre, NATIVO tipoNativo, ByteOrder ordenBytes) {
this.tipo= TIPO.NATIVO;
this.nativo=tipoNativo;
this.capacidad=tipoNativo.getNumBytes();
this.nombre=nombre.toUpperCase().trim();
this.byteOrder=ordenBytes;
}

/**
* Crea una estructura para almacenar un tipo nativo.
* La capacidad se calculara a medida que se le añadan subestructuras
*
* @param tipoNativo NATIVO
* @param nombre String
*/
public Struct(String nombre, NATIVO tipoNativo) {
this(nombre, tipoNativo,ByteOrder.BIG_ENDIAN);
}

/**
* Devuelve el nombre de la estructura
*
* @return String
*/
public String getNombre() {
return nombre;
}

/**
* Devuelve true si la estructura esta materializada.
* Una vez una estructura esta materializada ya no es posible alterarla
* estructuralmente.
*
* @return boolean
*/
public boolean isMaterializado() {
return materializado;
}

/**
* Devuelve el ByteBuffer asociado a una estructura
*
* @return ByteBuffer
*/
public ByteBuffer getBuffer() {
return buffer;
}

/**
* Devuelve el byte usado para hacer un clear.
* Por defecto 0
*
* @return byte
*/
public byte getClearByte() {
return clearByte;
}

/**
* Actualiza el byte usado para hacer un clear.
*
* @param clearByte byte
* @return
*/
public Struct setClearByte(byte clearByte) {
this.clearByte = clearByte;
return this;
}

/**
* Altera la capacidad en bytes de un elemento simple
*
* @param capacidad int
* @return Estructura
*/
public Struct setCapacidad(int capacidad) {
if(materializado) {
throw new IllegalStateException("Estructura ya materializada "+nombre);
}
if(tipo!=TIPO.SIMPLE) {
throw new UnsupportedOperationException("Solo se puede en tipo SIMPLE");
}
this.capacidad = capacidad;
return this;
}

/**
* Añade una determinada estructura a otra existente.
* Devuelve una referencia a la propia estructura
*
* @param dato Estructura
* @return Estructura
*/
public Struct addDato(Struct dato) {
if(materializado) {
throw new IllegalStateException("Solo antes de materializar");
}
if(!(tipo== TIPO.GRUPO)) {
throw new UnsupportedOperationException("Solo se puede añadir a tipo GRUPO");
}
listaDatos.put(dato.nombre,dato);
return this;
}

/**
* Calcula la capacidad de la estructura superior y crea los buffers correspondientes
* Si el parametro es true los buffers seran directos
*
* @param directo
*/
public void materializar(boolean directo) {
if(materializado) {
throw new IllegalStateException("Estructura ya materializada "+nombre);
}
capacidad=obtenerCapacidad();
if(directo) {
buffer=ByteBuffer.allocateDirect(capacidad);
} else {
buffer=ByteBuffer.allocate(capacidad);
}
buffer.order(byteOrder);
int pos=0;
if(tipo== TIPO.GRUPO) {
for(Struct hijo:listaDatos.values()) {
hijo.materializar(this, pos);
pos+=hijo.obtenerCapacidad();
}
} else if (tipo==TIPO.ARRAY) {
for(Struct elemento:elementos) {
elemento.materializar(this, pos);
pos+=elemento.obtenerCapacidad();
}
}
materializado=true;
clear();
}

/**
* Escribe la estructura sobre un canal
*
* @param canal
* @throws IOException
*/
public void write(WritableByteChannel canal) throws IOException {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
canal.write(buffer);
}

/**
* Lee un canal sobre la estructura
*
* @param canal
* @return int
* @throws IOException
*/
public int read(ReadableByteChannel canal) throws IOException {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
int retorno=canal.read(buffer);
return retorno;
}

/**
* Devuelve una determinada estructura referenciada por su nombre.
* Si se quiere obtener una subestructura de una subestructura se utiliza
* un punto para separar los nombres.
* En el caso de arrays se usara el numero en lugar del nombre.
*
* @param nombre String
* @return Estructura
*/
public Struct getSubEstructura(String nombre) {
Struct retorno;
if(!(tipo== TIPO.ARRAY||tipo== TIPO.GRUPO)) {
throw new UnsupportedOperationException("Solo se puede usar en tipos ARRAY o GRUPO. Incorrecto en "+nombre);
}
nombre=nombre.toUpperCase().trim();
String[] partes=nombre.split("\\.");
// Comprobaremos si el nombre contiene referencia a elementos
String act=partes[0];
if(act.matches("\\d*")) {
retorno=elementos[Integer.parseInt(act)];
} else {
retorno=listaDatos.get(partes[0]);
}
if(partes.length>1) {
StringBuilder subNom=new StringBuilder(partes[1]);
for(int nn=2;nn<partes.length;nn++) {
subNom.append('.').append(partes[nn]);
}
retorno=retorno.getSubEstructura(subNom.toString());
}
return retorno;
}

/**
* Devuelve la estructura elemento de un array dado su indice
*
* @param index int
* @return Estructura
*/
public Struct getElemento(int index) {
if(tipo!= TIPO.ARRAY) {
throw new UnsupportedOperationException("Solo se puede usar en tipo ARRAY");
}
return elementos[index];
}

/**
* Devuelve el numero de elementos que contiene el array
*
* @return int
*/
public int getNumElementos() {
if(tipo!= TIPO.ARRAY) {
throw new UnsupportedOperationException("Solo se puede usar en tipo ARRAY");
}
return elementos.length;
}

/**
* Devuelve el contenido de una estructura en forma de short
*
* @return String
*/
public short getShort() {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
return buffer.getShort();
}

/**
* Actualiza el buffer con un short en formato nativo
*
* @param valor
* @return Struct
*/
public Struct setShort(short valor) {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
buffer.putShort(valor);
return this;
}

/**
* Devuelve el contenido de una estructura en forma de int
*
* @return String
*/
public int getInt() {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
return buffer.getInt();
}

/**
* Actualiza el buffer con un int en formato nativo
*
* @param valor
* @return Struct
*/
public Struct setInt(int valor) {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
buffer.putInt(valor);
return this;
}


/**
* Devuelve el contenido de una estructura en forma de String
*
* @return String
*/
public String getString() {
byte[] dato=getBytes();
return dato==null?null:new String(dato);
}

/**
* Actualiza el contenido de una estructura
* Devuelve una referencia a la propia estructura
*
* @param valor String
* @return Estructura
*/
public Struct setString(String valor) {
if(valor==null) return this;
byte[] dato=valor.getBytes();
return setBytes(dato);
}

/**
* Actualiza el contenido de una estructura ajustando a la derecha del buffer
* Devuelve una referencia a la propia estructura
*
* @param valor String
* @return Estructura
*/
public Struct setStringRight(String valor) {
if(valor==null) return this;
byte[] dato=valor.getBytes();
return setBytesRight(dato);
}

/**
* Devuelve el contenido de una subestructura a partir de su nombre
*
* @param nombre String
* @return String
*/
public String getString(String nombre) {
Struct dato=getSubEstructura(nombre);
return dato.getString();
}

/**
* Actualiza el contenido de una subestructura referenciada por su nombre
* Devuelve una referencia a la propia estructura
*
* @param nombre String
* @param valor String
* @return Estructura
*/
public Struct setString(String nombre, String valor) {
Struct dato=getSubEstructura(nombre);
return dato.setString(valor);
}

/**
* Actualiza el contenido de una subestructura referenciada por su nombre
* ajustando a la derecha del buffer.
* Devuelve una referencia a la propia estructura
*
* @param nombre String
* @param valor String
* @return Estructura
*/
public Struct setStringRight(String nombre, String valor) {
Struct dato=getSubEstructura(nombre);
return dato.setStringRight(valor);
}

/**
* Rellena una estructura con bytes clearByte correspondientes a cada una de sus
* substructuras de forma recursiva.
*
* @return Estructura
*/
public Struct clearAll() {
if(tipo==TIPO.SIMPLE||tipo==TIPO.NATIVO) {
clear();
} else if(tipo==TIPO.GRUPO) {
for(Struct elem:listaDatos.values()) {
elem.clearAll();
}
} else if(tipo==TIPO.ARRAY) {
for(Struct elem:elementos) {
elem.clearAll();
}
}
return this;
}

/**
* Rellena una estructura referenciada por su nombre con bytes clearByte
* correspondientes a cada una de sus substructuras de forma recursiva.
*
* @param nombre
* @return Estructura
*/
public Struct clearAll(String nombre) {
Struct dato=getSubEstructura(nombre);
dato.clearAll();
return this;
}

/**
* Rellena una estructura con bytes clearByte.
* El byte clearByte se aplicara a todas las subestructuras que contenga.
*
* Devuelve una referencia a la propia estructura.
*
* @return Estructura
*/
public Struct clear() {
return fill((byte)clearByte);
}

/**
* Rellena una estructura referenciada por su nombre con bytes clearByte.
* El byte clearByte se aplicara a todas las subestructuras que contenga.
*
* Devuelve una referencia a la propia estructura.
*
* @param nombre
* @return Estructura
*/
public Struct clear(String nombre) {
Struct dato=getSubEstructura(nombre);
return dato.clear();
}


/**
* Rellena una estructura con un determinado byte
* Devuelve una referencia a la propia estructura
*
* @param relleno byte
* @return Estructura
*/
public Struct fill(byte relleno) {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
byte[] bytes=new byte[capacidad];
Arrays.fill(bytes, relleno);
buffer.clear();
buffer.put(bytes);
return this;
}

/**
* Rellena una estructura con un determinado char
* Devuelve una referencia a la propia estructura
*
* @param relleno char
* @return Estructura
*/
public Struct fill(char relleno) {
return fill((byte) relleno);
}

/**
* Rellena una estructura referenciada por su nombre con un determinado byte
* Devuelve una referencia a la propia estructura
*
* @param nombre String
* @param relleno byte
* @return Estructura
*/
public Struct fill(String nombre, byte relleno) {
Struct dato=getSubEstructura(nombre);
return dato.fill(relleno);
}

/**
* Actualiza el contenido de una estructura
* Devuelve una referencia a la propia estructura
*
* @param valor byte
* @return Estructura
*/
public Struct setByte(byte valor) {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
buffer.put(valor);
return this;
}

/**
* Devuelve el contenido de una estructura en forma de bytes
*
* @return byte[]
*/
public byte[] getBytes() {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
byte[] dato=new byte[buffer.limit()];
buffer.get(dato);
return dato;
}

/**
* Actualiza el contenido de una estructura
* Devuelve una referencia a la propia estructura
*
* @param bytes byte[]
* @return Estructura
*/
public Struct setBytes(byte[] bytes) {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
buffer.put(bytes);
return this;
}

/**
* Actualiza el contenido de una estructura ajustando a la derecha
* Devuelve una referencia a la propia estructura
*
* @param bytes byte[]
* @return Estructura
*/
public Struct setBytesRight(byte[] bytes) {
if(!materializado) {
throw new IllegalStateException("Solo se puede aplicar a estructuras materializadas");
}
buffer.clear();
buffer.position(buffer.capacity()-bytes.length);
buffer.put(bytes);
return this;
}

/**
* Devuelve el contenido de una subestructura a partir de su nombre
*
* @param nombre
* @return byte[]
*/
public byte[] getBytes(String nombre) {
Struct dato=getSubEstructura(nombre);
return dato.getBytes();
}

/**
* Actualiza el contenido de una subestructura referenciada por su nombre
* Devuelve una referencia a la propia estructura
*
* @param nombre
* @param bytes byte[]
* @return Estructura
*/
public Struct setBytes(String nombre, byte[] bytes) {
Struct dato=getSubEstructura(nombre);
dato.setBytes(bytes);
return dato;
}

/**
* Actualiza el contenido de una subestructura referenciada por su nombre
* ajustando a la derecha
* Devuelve una referencia a la propia estructura
*
* @param nombre String
* @param bytes byte[]
* @return Estructura
*/
public Struct setBytesRight(String nombre, byte[] bytes) {
Struct dato=getSubEstructura(nombre);
dato.setBytesRight(bytes);
return dato;
}



/**
* Obtiene la capacidad de una determinada estructura
* Actualiza el campo capacidad
*
* @return
*/
public int obtenerCapacidad() {
int retorno=0;
if(tipo== TIPO.GRUPO) {
for(Struct hijo:listaDatos.values()) {
retorno+=hijo.obtenerCapacidad();
}
} else if (tipo==TIPO.ARRAY) {
for(Struct elemento:elementos) {
retorno+=elemento.obtenerCapacidad();
}
} else {
retorno=capacidad;
}
return retorno;
}

/**
* Devuelve una copia no materializada de la estructura actual
*
* @return Estructura
*/
private Struct copia() {
Struct retorno=null;
if(tipo== TIPO.GRUPO) {
retorno=new Struct(nombre);
for(Struct dato:listaDatos.values()) {
retorno.addDato(dato.copia());
}
} else if (tipo==TIPO.ARRAY) {
retorno=new Struct(elementos[0],elementos.length);
} else if (tipo==TIPO.SIMPLE){
retorno=new Struct(nombre, capacidad);
} else if (tipo==TIPO.NATIVO) {
retorno=new Struct(nombre, nativo);
}
retorno.setClearByte(clearByte);
return retorno;
}

/**
* Devuelve un String con la representacion de la estructura
*
* @param lvl
* @return Estructura
*/
public String toString(int lvl) {
StringBuilder retorno=new StringBuilder();
if(tipo== TIPO.GRUPO) {
retorno.append(new char[lvl]).append(nombre).append(":\n");
for(Struct dato:listaDatos.values()) {
retorno.append(dato.toString(lvl+1));
}
} else if (tipo==TIPO.ARRAY) {
//retorno.append(new char[lvl]).append(nombre).append("[").append(elementos.length).append("]:\n");
int index=0;
for(Struct dato:elementos) {
String res=dato.toString(lvl, index);
retorno.append(res);
index++;
}
} else if (tipo==TIPO.SIMPLE){
retorno.append(new char[lvl]).append(nombre).append(":");
if(isMaterializado()) {
retorno.append(getString());
}
retorno.append("\n");
} else if (tipo==TIPO.NATIVO) {
retorno.append(new char[lvl]).append(nombre).append(":");
if(isMaterializado()) {
retorno.append(getString());
}
retorno.append("\n");
}
return retorno.toString();
}

private String toString(int lvl, int index) {
StringBuilder retorno=new StringBuilder();
if(tipo== TIPO.GRUPO) {
retorno.append(new char[lvl]).append(nombre).append("[").append(index).append("]").append(":\n");
for(Struct dato:listaDatos.values()) {
retorno.append(dato.toString(lvl+1));
}
} else if (tipo==TIPO.ARRAY) {
retorno.append(new char[lvl]).append(nombre).append("[").append(index).append("]").append("[").append(elementos.length).append("]").append(":\n");
for(Struct dato:elementos) {
String res=dato.toString(lvl+1);
retorno.append(res);
}
} else if (tipo==TIPO.SIMPLE){
retorno.append(new char[lvl]).append(nombre).append("[").append(index).append("]").append(":");
if(isMaterializado()) {
retorno.append(getString());
}
retorno.append("\n");
} else if (tipo==TIPO.NATIVO) {
retorno.append(new char[lvl]).append("[").append(index).append("]").append(":");
if(isMaterializado()) {
retorno.append(getString());
}
retorno.append("\n");
}
return retorno.toString();
}

/**
* Usado internamente para materializar subestructuras
*
* @param padre
* @param posicion
*/
private void materializar(Struct padre, int posicion) {
if(materializado) {
throw new IllegalStateException("Estructura ya materializada "+nombre);
}
ByteBuffer bufPadre=padre.buffer;
int posAct=bufPadre.position();
int limAct=bufPadre.limit();
bufPadre.position(posicion).limit(posicion+obtenerCapacidad());
buffer=bufPadre.slice();
buffer.order(byteOrder);
bufPadre.position(posAct).limit(limAct);

int pos=0;
if(tipo==TIPO.GRUPO) {
for(Struct hijo:listaDatos.values()) {
hijo.materializar(this, pos);
pos+=hijo.obtenerCapacidad();
}
} else if (tipo==TIPO.ARRAY) {
for(Struct elemento:elementos) {
elemento.materializar(this, pos);
pos+=elemento.obtenerCapacidad();
}
}
materializado=true;
}

}

Guenas.

Lo siguiente es un ejemplo se uso


package util.struct;

/**
*
* @author vidalram
*/
public class Prueba {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {

Struct registro=new Struct("REGISTRO");
Struct identificacion=new Struct("IDENTIFICACION");
Struct nombre=new Struct("NOMBRE",15).setClearByte((byte) 'N');
Struct apellidos=new Struct("APELLIDOS",25).setClearByte((byte) 'A');
identificacion.addDato(nombre).addDato(apellidos);
Struct localizacion=new Struct("LOCALIZACION");
Struct direccion=new Struct("DIRECCION",25).setClearByte((byte) ' ');
Struct poblacion=new Struct("POBLACION",20).setClearByte((byte) ' ');
Struct provincia=new Struct("PROVINCIA",15).setClearByte((byte) ' ');
Struct telefono=new Struct("TELEFONO",10).setClearByte((byte) ' ');
localizacion.addDato(direccion);
localizacion.addDato(poblacion);
localizacion.addDato(provincia);
localizacion.addDato(telefono);
Struct localizaciones=new Struct(localizacion, 3);
Struct edad=new Struct("EDAD", Struct.NATIVO.SHORT);
registro.addDato(identificacion).addDato(edad).addDato(localizaciones);
registro.setClearByte((byte) 32);
registro.materializar(false);


registro.clearAll();
nombre.setString("Ramon");
edad.setShort((short)60);
apellidos.setString("Vidal Morell");
localizaciones.setString("0.DIRECCION", "C/ La piedra 12");
localizaciones.setString("0.POBLACION", "San Pepito de arriba");
localizaciones.setString("0.PROVINCIA", "Zaragoza");
localizaciones.setString("0.TELEFONO", "123456789");

localizaciones.setString("1.DIRECCION", "C/ La nube 34");
localizaciones.setString("1.POBLACION", "San Jose de abajo");
localizaciones.setString("1.PROVINCIA", "Madrid");
localizaciones.setString("1.TELEFONO", "234567890");

localizaciones.setString("2.DIRECCION", "C/ Pescaderia 56");
localizaciones.setString("2.POBLACION", "Villapeces");
localizaciones.setString("2.PROVINCIA", "Murcia");
localizaciones.setString("2.TELEFONO", "345678901");


System.out.println(registro.getString());

System.out.println(registro.toString(0));


}
}