Por supuesto, vale perfectamente leerlo a puro código. Yo entre ambas formas, prefiero trabajar con JAXB, por un lado porque la conversión es automática y transparente para mí, y por otro lado porque siempre es bueno trabajar con entidades 

Saludos y gracias por compartir el código.

Destornilla la tapa de atrás de tu portátil, es a menudo una tapita cuadrada donde debajo se encuentran los módulos de RAM. Retira un módulo de RAM, de manera que puedas ver dos pines y una etiqueta que diga xxx o jump. Una vez identificados, conecta tu portátil a la corriente, coloca un desarmador sobre ambos pines, de modo que los una y por último enciende el portátil aún manteniendo el desarmador sobre los pines. Ésto lo que hará es un pequeño corto circuito que restablecerá el bios. Al terminar apagas el portátil, desconectas de la toma de corriente, colocas los módulos de memoria que has sacado y vuelves a poner la tapa.


Saludos.

• Primero que todo, ten lógica común.
• No creas todo lo que ves en internet.
• Instala un buen antivirus (NO crackeado, si no cuentas con $, usa uno gratuito).
• Lee, investiga y aprende sobre informática en general.
• Aprende a desinfectar equipos (indentificar síntomas, utilizar herramientas, etc).
• Si no utilizas nada en Windows que no pueda ser utilizado en GNU/Linux, mejor instálate una distro. Para empezar, Linux Mint o Ubuntu.

Saludos.

Creo que la segunda serie de palabras no debes añadirla a la primera. Por ejemplo algo así:

var palabras = modificar.split(" ");
palabras.each do |palabra|
    if texto.include? palabra # si el texto contiene la palabra
        texto.gstub! palabra, "CONFIDENCIAL" # se reemplaza por CONFIDENCIAL
    end
end

Recorres las palabras a verificar y compruebas si el texto la contiene (texto.include? palabra). Si es verdadero reemplazas todas las apariciones de dicha palabra por CONFIDENCIAL (texto.gstub! palabra, "CONFIDENCIAL").

No manejo Ruby, pero inténtalo.


Saludos.

No se tú, pero yo tu código lo veo bastante ilegible. Por ejemplo, para sumar dos matrices, lo haría así:

public Integer[][] sum(Integer[][] values) {
	Integer[][] sum = new Integer[mat.length][math[0].length];
	for(int row=0; row<mat.length; row++) {
		sum[row][col] = 0;
		for(int col=0; col<mat[row].length; col++) {
			sum[row][col] = mat[row][col] + values[row][col];
		}
	}
	return sum;
}

Cabe alcarar que no puedes redimensionar un array. Lo que puedes es crear un array temporal y luego asignarlo (referencia) al original. Si quiseras redimensionar, tendrías que usar List.

Sobre los errores, ¿te muestra algunos el compilador, o lo que quieres es que vean si tu código está bien hecho?


Saludos.

Simplemente haz un cambio:

String province = event.getSelectedItem();
populationList.removeAll();
ProvinceService service = new ProvinceService();
// obtienes las poblaciones (yo te habia hecho un metodo, ¿recuerdas?)
for(Set<Popuplation> populations : service.getPopulations(provice)) {
	for(Population population : populations) {
		populationList.add(population.toString());
	}
}

EDIT: Recién veo tu respuesta anterior ^^.

Hola jPallo1,

Por favor encierra tus códigos entre etiquetas GeSHi. En el editor, en la parte superior derecha hay un Combo llamado GeSHi, despliégalo y selecciona el lenguaje deseado, en éste caso Java para las clases y XML para los mapeados. Otra cosa, en lugar de los mapeos .hbm.xml utiliza anotaciones y si es posible utiliza JPA, te provee una capa de abstracción para trabajar más cómodamente.

Respecto a tu pregunta, dices que ambas entidades están relacionadas, pero no veo en ningún lado la relación en los XML. Haz lo de las etiquetas para poder ver tu código mejor.


Un saludo.

Intenta ésto:

provincesList.addItemListener(new ItemListener() {
	public void itemStateChanged(ItemEvent event) {
		Province province = (Province) event.getItem();
		populationList.removeAll(); // remueve todo el contenido
		// itera el Set de poblaciones de la provincia elegida
		for(Set<Population> populations : province.getPopulations()) {
			for(Population population : populations) {
				// Population debe de sobreescribir toString()
				populationList.add(population.toString());
			}
		}
	}
}

También lo puedes hacer desde el controlador. Para las predicciones es la misma idea.


Saludos.

Cálculos paso por paso:

• Conteo (cantidad de números)
• Suma (suma de los números)
• Media (promedio de la suma)
• Diferencias^2: ( (Numero - media) ^ 2)
• Varianza (diferencia / conteo)
• Desviación estándar (Raíz de la varianza)

#include <iostream>
#include <math.h>
 
using namespace std;
 
int main()
{
   int data[5][10] ={
	   {100,90,80,70,60,50,40,60,70,100},
	   {100,95,65,75,100,99,90,89,79,60},
	   {100,45,100,90,78,65,100,100,90,76},
	   {100,90,90,99,82,73,64,68,70,80},
	   {85,90.5,98.3,99,69.8,98.7,89.9,95.4,89,100}
	};
	double sum[5]; // cantidad de filas = cantidad de alumnos
	double avg[5];
	double variance[5];
	double deviation[5];
 
	// sumatorias
	for(int row=0; row<5; row++) {
		sum[row] = 0;
		for(int col=0; col<10; col++) {
			// sumatoria de las notas de cada alumno
			sum[row] += data[row][col];
		}
	}
 
	// promedios
	for(int index=0; index<5; index++) {
		avg[index] = sum[index] / (10.0f);
	}
 
	// varianzas
	for(int row=0; row<5; row++) {
		variance[row] = 0;
		for(int col=0; col<10; col++) {
			double range = pow(data[row][col] - avg[row], 2);
			variance[row] += range;
		}
		variance[row] = variance[row] / 10;
	}
 
	// desviaciones
	for(int index=0; index<5; index++) {
		deviation[index] = sqrt(variance[index]);
	}
 
	// imprime las desviaciones
	for(int index=0; index<5; index++) {
		cout << "La desviación del alumno es: " << deviation[index];
		cout << "\n";
	}
 
	return 0;
}

Hola  samirllorente,

Puedes leer tu fichero XML mediante JAXB, que es el API de Java para manejo de ficheros XML. Lo único que necesitarás es crear clases (entidades) que representen a cada etiqueta. Un ejemplo aplicado a tu XML:

Ésta clase es el Root, es decir, la etiqueta que engloba todo (<Gestion></Gestion>):

Management

package com.company.model.entities;
 
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 *
 * @author gus
 */
@XmlRootElement(name="Gestion")
@XmlAccessorType(XmlAccessType.FIELD)
public class Management {
    @XmlElement(name="Velocidad")
    private Double velocity;
    @XmlElement(name="Process")
    private List<Process> processes;
 
    public Management() {
 
    }
    public Management(Double velocity, List<Process> processes) {
    	this.velocity = velocity;
    	this.processes = processes;
    }
    public Double getVelocity() {
        return velocity;
    }
    public void setVelocity(Double velocity) {
        this.velocity = velocity;
    }
    public List<Process> getProcesses() {
        return processes;
    }
    public void setProcesses(List<Process> processes) {
        this.processes = processes;
    }
 
}

Como puedes darte cuenta hay un par de anotaciones interesantes:

• @XmlRootElement: Indica que es el elemento padre de una jerarquía.
• @XmlElement: Indica que es un elemento XML (un tag).
• @XmlAccessorType, @XmlAccessType.FIELD: La primera se usa para establecer el tipo de acceso. La segunda indica que se accederá a los valores por propiedades (y no por getters/setters).

El atributo name de las anotaciones se usa para especificar el valor que deben tener las propiedades (tags) en el XML.

Ahora veamos las entidades Process y Activity:

Process

package com.company.model.entities;
 
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 *
 * @author gus
 */
@XmlAccessorType(XmlAccessType.FIELD)
public class Process {
    @XmlElement(name="Pid")
    private Short pid;
    @XmlElement(name="Name")
    private String name;
    @XmlElement(name="Quantum")
    private Short quantum; // ¿quántico?
    @XmlElement(name="Actividad")
    private Activity activity;
 
    public Process() {
 
    }
    public Process(Short pid, String name, Short quantum, Activity activity) {
        this.pid = pid;
        this.name = name;
        this.quantum = quantum;
        this.activity = activity;
    }
    public Short getPid() {
        return pid;
    }
    public void setPid(Short pid) {
        this.pid = pid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Short getQuantum() {
        return quantum;
    }
    public void setQuantum(Short quantum) {
        this.quantum = quantum;
    }
    public Activity getActivity() {
        return activity;
    }
    public void setActivity(Activity activity) {
        this.activity = activity;
    }
 
}

Activity

package com.company.model.entities;
 
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 *
 * @author gus
 */
@XmlAccessorType(XmlAccessType.FIELD)
public class Activity {
    @XmlElement(name="Archivo_fuente")
    private String source;
    @XmlElement(name="Archivo_destino")
    private String target;
 
    public Activity() {
 
    }
    public Activity(String source, String target) {
        this.source = source;
        this.target = target;
    }
    public String getSource() {
        return source;
    }
    public void setSource(String source) {
        this.source = source;
    }
    public String getTarget() {
        return target;
    }
    public void setTarget(String target) {
        this.target = target;
    }
 
}

Como puedes ver, algunas etiquetas se repiten, en concreto XmlAccessorType y es para indicar que los valores se accederán por medio de las propiedades.

NOTA: Para leer un archivo XML es importante que el atributo name de las propiedades sean idénticas al nombre del tag en el XML. De lo contrario, la conversión fallará.

Ahora, veamos quien hace "la magia". Cabe aclarar que se hace un uso mínimo de Generics para que la clase se adapte a cualquier entidad:.

MarshallerUtil

package com.company.model.jaxb;
import java.io.File;
 
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
 
 
 
public class MarshallerUtil<T> {
	private static JAXBContext jaxbContext;
	private final Class<T> clazz;
 
	public MarshallerUtil(Class<T> aClazz) throws JAXBException {
		this.clazz = aClazz;
		jaxbContext = JAXBContext.newInstance(clazz);
	}
 
	public void marshal(T entity, File output) throws JAXBException {
		Marshaller marshaller = jaxbContext.createMarshaller();
		marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
		marshaller.marshal(entity, output);
	}
 
	public T unmarshal(File input) throws JAXBException {
		Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
		return (T) unmarshaller.unmarshal(input);
	}
 
}

Donde:

• T: Es el tipo de clase (entidad) que será trabajada por el Marshaller (transformador).
• marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);: Formatea el XML.
• marshaller.marshall(entity, file): Recibe la entidad a convertir a XML y el destino (ruta) en un objeto File.
• marshaller.unmarshal(file): Recibe la ruta del XML a convertir. Con el cast hacia T decimos que el XML se convierta a la entidad con la que se está trabajando (T = MarshallerUtil<CLASE_DE_ENTIDAD>).
  
  Por último, hagamos una prueba:
  
  Main
  
  

package com.company.main;
 
import com.company.model.entities.Activity;
import com.company.model.entities.Management;
import com.company.model.entities.Process;
import com.company.model.jaxb.MarshallerUtil;
import com.sun.istack.internal.logging.Logger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.xml.bind.JAXBException;
 
 
public class Main {
 
	public static void main(String[] args) {
            Logger logger = Logger.getLogger(Main.class);
            try {
                /*Management management = new Management();
                List<Process> processes = new ArrayList<>();
                Collections.addAll(processes,
                        new Process(new Short("1"), "Proceso 1", new Short("1"),
                            new Activity("/home/gus/Documentos/origen.txt", "home/gus/Documentos")),
                        new Process(new Short("2"), "Proceso 2", new Short("4"),
                            new Activity("/home/gus/Documentos/origen.xml", "home/gus/Documentos")),
                        new Process(new Short("3"), "Proceso 3", new Short("3"),
                            new Activity("/home/gus/Documentos/origen.sh", "home/gus/Documentos"))
                );
                management.setVelocity(100.05d);
                management.setProcesses(processes);
                MarshallerUtil<Management> marshaller = new MarshallerUtil(Management.class);
                marshaller.marshal(management, new java.io.File("/home/gus/Documentos/prueba1.xml"));*/
 
                MarshallerUtil<Management> marshaller = new MarshallerUtil(Management.class);
                Management management = marshaller
                        .unmarshal(new java.io.File("/home/gus/Documentos/prueba.xml"));
                System.out.println(management.getVelocity());
                for(Process process : management.getProcesses()) {
                    System.out.println(process.getPid());
                    System.out.println(process.getName());
                    System.out.println(process.getQuantum());
                    System.out.println(process.getActivity().getSource());
                    System.out.println(process.getActivity().getTarget());
                    System.out.println();
                }
            } catch (JAXBException e) {
                logger.warning(e.getMessage());
            }
 
	}
 
}

La parte comentada es la forma para convertir una entidad a un fichero XML.

Resultado:



¡Saludos!