Develop Reference

Pass int array from one method to another as argument

I am trying to do a school work and I'm having problem passing an int array from a method to another as an argument.
My code is:
import java.util.Scanner;
public class Eac4P1_002 {
Scanner scanner = new Scanner(System.in);
//Método main
public static void main (String[] args){
Eac4P1_002 programa = new Eac4P1_002();
programa.inicio();
}
//Método principal
public void inicio() {
presentacion();
intro();
resultado();
}
//Presentación
public void presentacion(){
System.out.println("Hola, bienvenid# al ejercicio 2!\n"
+ "El programa os pedirá la edad de dos clases, "
+ "en enteros y comprueba si los valores de la segunda clase "
+ "son más grandes que los de la primera.");
}
//Inserción de datos
public void intro(){
System.out.println("De que medida necesitas que sean las clases?");
int medida = scanner.nextInt();
int clase1 [] = new int[medida];
int clase2 [] = new int[medida];
int contador = 0;
int posicion = 1;
System.out.println("Ahora deberás introducir el valor de cada "
+ "posición de la clase inicial.");
while (contador < clase1.length){
System.out.print("Escribe el valor de la posición "+posicion+": ");
clase1[contador] = scanner.nextInt();
contador++;
posicion++;
scanner.nextLine();
}
System.out.println("A continuación debes entrar los valores de la"
+ "segunda clase.");
contador = 0; posicion = 1;
while (contador < clase2.length){
System.out.print("Escribe el valor de la posición "+posicion+": ");
clase2[contador] = scanner.nextInt();
contador++;
posicion++;
scanner.nextLine();
}
}
public void resultado(int[]clase1, int[] clase2){
System.out.println("Analisis de los datos coleccionados.\n");
System.out.println("Colección 1:");
for(int i=0; i < clase1.length; i++ ){
System.out.print(clase1[i]);
}
}
}
I am getting an error in main method when calling resultado();
Is there something I do wrong? I just want to able to use the arrays created in intro() method in resultado() method.

I have refactored your code for you, to split classes read to two methods.
From introGetClase1() and introGetClase2() methods, the int[] required for resultado() method is returned.
Arguments are passed to resultado() method
import java.util.Scanner;
public class Eac4P1_002 {
Scanner scanner = new Scanner(System.in);
//Método main
public static void main (String[] args){
Eac4P1_002 programa = new Eac4P1_002();
programa.inicio();
}
//Método principal
public void inicio() {
presentacion();
System.out.println("De que medida necesitas que sean las clases 1?");
int medida = scanner.nextInt();
int[] clase1 = introGetClase1(medida);
int[] clase2 = introGetClase2(medida);
resultado(clase1, clase2);
}
//Presentación
public void presentacion(){
System.out.println("Hola, bienvenid# al ejercicio 2!\n"
+ "El programa os pedirá la edad de dos clases, "
+ "en enteros y comprueba si los valores de la segunda clase "
+ "son más grandes que los de la primera.");
}
//Inserción de datos
public int[] introGetClase1(int medida){
int clase1 [] = new int[medida];
int contador = 0;
int posicion = 1;
System.out.println("Ahora deberás introducir el valor de cada "
+ "posición de la clase inicial.");
while (contador < clase1.length){
System.out.print("Escribe el valor de la posición "+posicion+": ");
clase1[contador] = scanner.nextInt();
contador++;
posicion++;
scanner.nextLine();
}
return clase1;
}
//Inserción de datos
public int[] introGetClase2(int medida){
int clase2 [] = new int[medida];
int contador = 0;
int posicion = 1;
while (contador < clase2.length){
System.out.print("Escribe el valor de la posición (clases 2)"+posicion+": ");
clase2[contador] = scanner.nextInt();
contador++;
posicion++;
scanner.nextLine();
}
return clase2;
}
public void resultado(int[]clase1, int[] clase2){
System.out.println("Analisis de los datos coleccionados.\n");
System.out.println("Colección 1:");
for(int i=0; i < clase1.length; i++ ){
System.out.print(clase1[i]);
}
}
}

If you want to use an array created in intro() as an input into resultado() consider adding a return value. public void intro() could be public int[] intro().
public int[] intro(){
System.out.println("De que medida necesitas que sean las clases?");
int medida = scanner.nextInt();
int clase1 [] = new int[medida];
int contador = 0;
int posicion = 1;
System.out.println("Ahora deberás introducir el valor de cada "
+ "posición de la clase inicial.");
while (contador < clase1.length){
System.out.print("Escribe el valor de la posición "+posicion+": ");
clase1[contador] = scanner.nextInt();
contador++;
posicion++;
scanner.nextLine();
}
return clase1;
}
Each time the method is called it will create a new array and return that array. So you could use it twice as input into resultado().
resultado( intro() , intro() );

because you are not passing anything when you call resultado(). that method requires an int array passed.
For example:
//Método principal
public void inicio() {
presentacion();
intro();
int[] ar1 = {1,2,3,4,};
int[] ar2 = {2,3,4,5};
resultado(ar1, ar2);
}

your resultado(int[]clase1, int[] clase2) need two parameters.
int[] class1 = {1,2,3,4,5};
int[] class2 = {6,7,8,9,10}
resultado(class1,class2);

How do I access two arrays with different sizes at the same time? [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 6 years ago.
Improve this question
I have beeen looking at six arrays that I have, one of them is smaller than than the others. I want to print the in this form:
El sustantivo
I. Elige el uso correcto del sustantivo entrada.
A. Uno vez entrada al parque no se resistió.
B. La entrada al parque, no la resistió.
C. Entrada la noche, el niño comenzó a llorar.
D. Con cada golpe, entrada me encuentro.
II. Escoge la forma correcta en femenino de tigre
A. La tigresa tiene buenas garras.
B. La trigresa tiene buenas garras.
C. La triga tiene buenas garras.
D. La tigera tiene buenas garras.
III. Cambiar al plural: El árbol de bambú es la planta que crece más rápido en todo el planeta.
A. Los arboles bambúses son las plantas que crecen más rápido en todo el planeta.
B. Las bambús son las plantas que crecen más rápido en todo el planeta.
C. Los arboles de bambú son las plantas que crecen más rápido en todo el planeta.
D. Los arbols de bambúes son las plantas que crecen más rápido en todo el planeta.
I have this, but no good result.
public class FileArrays {
private static String[] keys = new String[60];
public static void main(String[] args) {
// System.out.println("Al final la vida sigue igual");
System.out.println();
//String fileName = "filearrays.txt";
Scanner fileScanner = new Scanner(fileName);
try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
int a, b, c, d, e, f;
String line;
int lineNumber = 0;
while ((line = br.readLine()) != null) {
/*
* System.out.print("\""); System.out.print(line);
* System.out.print("\",");
*/
// System.out.println();
lineNumber++;
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println();
for (int i = 0; i < pregs.length; i++) {
/*
* System.out.print("\""); System.out.print(keys[i]);
* System.out.print("\",");
*/
}
temas();
pregunta();
}
private static void temas() {
for(int i = 0; i < temas.length; i++){
System.out.println(temas[i]);
}
}
private static void pregunta() {
for (int i = 0; i < pregs.length; i++) {
System.out.println("\t" + pregs[i]);
System.out.println("\t\t" + resp1[i]);
System.out.println("\t\t" + resp2[i]);
System.out.println("\t\t" + resp3[i]);
System.out.println("\t\t" + resp4[i]);
System.out.println();
}
}
}

I do not understand your requirement.
Are the array elements somehow connected to each other other than by the array index?
By which criteria do you start the sections marked with the roman numbers?
[edit]
possible solution:
class Topic{
private final String topic;
private finaltopicName Collection<Question> questions;
Topic(String topic, Collection<Question> ... questions){
this.topic=topic;
this.questions=Arrays.asList(questions);
}
}
class Question{
private final String question;
private final Collection<String> answers;
Question(String question, Collection<String>... answers){
this.question=question;
this.answers=Arrays.asList(answers);
}

I found my answer. What I wanted to do was to go though an array that involved another array smaller in size. So what I did was to get the bigger array, and compare if the index pass some indexes, if that happened then the smaller array was going to increase one so that I do not get arrayoutofbound exception.
Here is my solution for your who voted me down, but you did not know the answer losers.
private static void calendar() {
int p = 0;
for(int i = 0; i < arrayBigger.length; i++){
if(i % 3 == 0 || i == 0){
System.out.println(smallerArray[p]);
p = p + 1;
}
System.out.println("\t" + pregs[i]);
System.out.println("\t\t" +resp1[i]);
System.out.println("\t\t" + resp2[i]);
System.out.println("\t\t" + resp3[i]);
System.out.println("\t\t" + resp4[i]);
}
}

Transfer an instance of a Java class into a xml file

I am trying to draw a graph using java, to do this I got all the infos of my graph into an instance of a class in my main program. To draw the graph I need to transfer this infos into a xml file like this.
My graph is much simpler than the example of the link, my problem is: I have no idea how to transfer my instance of the class to this format.
Below the codes I have (the codes are correct, i just need a way to transfer the atributes of the instance of the class "atividade" to the xml format of the link:
Atividade Class:
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package trabalho_m3;
import java.util.Arrays;
public class Atividade {
private int idAtividade;
private String nomeAtividade;
private float tempoDuracao, tInicioCedo, tTerminoCedo, tTerminoTarde, tInicioTarde, folga;
private int qtdPredecessores, qtdSucessores;
private Atividade predecessores[], sucessores[];
private int cnt_aux1 = 0, cnt_aux2 = 0;
public Atividade(int id, String nome, float duracao, int nPre, int nSuc){
this.idAtividade = id;
this.nomeAtividade = nome;
this.tempoDuracao = duracao;
this.qtdPredecessores = nPre;
this.qtdSucessores = nSuc;
this.predecessores = new Atividade[this.qtdPredecessores];
this.sucessores = new Atividade[this.qtdSucessores];
}
/*
* Método que calcula o TEMPO DE INÍCIO CEDO(Tes), assim como
* o TEMPO DE TÉRMINO CEDO(Tef) das atividades do projeto.
*/
public void calcular_Tes_Tef(){
// Cálculo do Tempo de Início Cedo da atividade (Tes).
if(this.qtdPredecessores == 0){
this.tInicioCedo = 0;
} else {
this.tInicioCedo = this.maxTefPredecessores(this.predecessores);
}
// Cálculo do Tempo de Término Cedo da atividade (Tef).
this.tTerminoCedo = (this.tInicioCedo + this.tempoDuracao);
}
/*
* Método que calcula o TEMPO DE TÉRMINO TARDE(Tlf), assim como
* o TEMPO DE INÍCIO TARDE(Tls) das atividades do projeto.
*/
public void calcular_Tlf_Tls(){
// Cálculo do Tempo de Término Tarde da atividade (Tlf).
if(this.qtdSucessores == 0){
this.tTerminoTarde = this.tTerminoCedo;
} else {
this.tTerminoTarde = this.minTlsSucessores(this.sucessores);
}
// Cálculo do Tempo de Início Tarde da atividade (Tls).
this.tInicioTarde = (this.tTerminoTarde - this.tempoDuracao);
}
/*
* Método calcula a FOLGA(R) das atividades do projeto.
*/
public void calcular_R(){
// Cálculo da Folga (R).
this.folga = (this.tTerminoTarde - this.tTerminoCedo);
}
/*
* Método encontra o valor MÁXIMO do Tef entre os predecessores
* de uma atividade.
*
* MAX{Tef(K)}; onde K representa as atividades precedentes.
*/
public float maxTefPredecessores(Atividade predecessores[]){
float maxTef = predecessores[0].tTerminoCedo;
for(int i = 1; i < predecessores.length; i++){
if(maxTef < predecessores[i].tTerminoCedo){
maxTef = predecessores[i].tTerminoCedo;
}
}
return maxTef;
}
/*
* Método encontra o valor MÍNIMO do Tls entre os sucessores
* de uma atividade.
*
* MIN{Tls(K)}; onde K representa as atividades sucessoras.
*/
public float minTlsSucessores(Atividade sucessores[]){
float minTls = sucessores[0].tInicioTarde;
for(int i = 1; i < sucessores.length; i++){
if(sucessores[i].tInicioTarde < minTls){
minTls = sucessores[i].tInicioTarde;
}
}
return minTls;
}
/*
* Vincula a uma dada atividade suas precedencias, incluindo
* seus precedentes no Array predecessores[].
*/
public void setarAtividadePredecessora(Atividade atividadePre){
if(cnt_aux1 == this.qtdPredecessores){
System.out.println("A atividade " + this.nomeAtividade + " nao suporta mais pre-requisitos!");
} else {
this.predecessores[this.cnt_aux1] = atividadePre;
this.cnt_aux1++;
}
}
/*
* Vincula a uma dada atividade seus sucessores.
*/
public void setarAtividadeSucessora(Atividade atividadeSuc){
if(cnt_aux2 == this.qtdSucessores){
System.out.println("A atividade " + this.nomeAtividade + " nao suporta mais atividades sucessoras!");
} else {
this.sucessores[this.cnt_aux2] = atividadeSuc;
this.cnt_aux2++;
}
}
// Retorna o NOME de uma atividade.
public String getNome(){
return this.nomeAtividade;
}
// Retorna a FOLGA(R) de uma atividade.
public float getFolga(){
return this.folga;
}
public float getPredecessores(){
return this.qtdPredecessores;
}
public float getId(){
return this.idAtividade;
}
public float getSucessores(){
return this.qtdSucessores;
}
/*
* Imprime todas as informações de uma atividade:
* Id, Nome, Precedencias, Sucessores, t, Tes, Tef, Tlf, Tls, R.
*/
public void informacoesAtividade(){
System.out.println();
System.out.println("Id: " + this.idAtividade);
System.out.println("Nome: " + this.nomeAtividade);
if(this.qtdPredecessores == 0){
System.out.println("Precedencia: --");
} else {
System.out.print("Precedencia: ");
for(int i = 0; i < this.predecessores.length; i++){
System.out.print(predecessores[i].nomeAtividade + " ");
}
System.out.println();
}
if(this.qtdSucessores == 0){
System.out.println("Sucessores: --");
} else {
System.out.print("Sucessores: ");
for(int j = 0; j < this.sucessores.length; j++){
System.out.print(sucessores[j].nomeAtividade + " ");
}
System.out.println();
}
System.out.println();
System.out.println("t: " + this.tempoDuracao);
System.out.println("Tes: " + this.tInicioCedo);
System.out.println("Tef: " + this.tTerminoCedo);
System.out.println("Tlf: " + this.tTerminoTarde);
System.out.println("Tls: " + this.tInicioTarde);
System.out.println("R: " + this.folga);
System.out.println();
}
}
Main:
package trabalho_m3;
import java.io.IOException;
import java.util.Scanner;
public class TRABALHO_M3 {
public static void Tes_Tef(Atividade[] Ativ){
for(int i = 0; i < Ativ.length; i++){
Ativ[i].calcular_Tes_Tef();
}
}
public static void Tlf_Tls(Atividade[] Ativ){
for(int i = (Ativ.length - 1); i >= 0; i--){
Ativ[i].calcular_Tlf_Tls();
}
}
public static void R(Atividade[] Ativ){
for(int i = 0; i < Ativ.length; i++){
Ativ[i].calcular_R();
}
}
public static void atividadeInfo(Atividade[] Ativ){
for(int i = 0; i < Ativ.length; i++){
Ativ[i].informacoesAtividade();
}
}
public static void caminhoCritico(Atividade[] Ativ){
System.out.print("Caminho Critico: ");
for(int i = 0; i < Ativ.length; i++){
if(Ativ[i].getFolga() == 0.0){
System.out.print(Ativ[i].getNome() + " ");
}
}
System.out.println();
}
public static void main(String[] args) throws IOException {
int qtd = 0;
int aux;
String rotulo;
float peso;
int predecessores, sucessores;
Scanner s = new Scanner(System.in);
System.out.println("Informe a quantidade de atividades: ");
qtd = s.nextInt();
Atividade atividades[] = new Atividade[qtd];
for (int i = 0; i < qtd; i++){
System.out.println("Informe o rótulo da atividade["+(i+1)+"]: ");
rotulo = s.next();
System.out.println("Informe a duracao da atividade["+(i+1)+"]: ");
peso = s.nextFloat();
System.out.println("Informe a quantidade de predecessores da atividade["+(i+1)+"]: ");
predecessores = s.nextInt();
System.out.println("Informe a quantidade de sucessores da atividade["+(i+1)+"]: ");
sucessores = s.nextInt();
atividades[i] = new Atividade(i,rotulo,peso,predecessores,sucessores);
System.out.println("Pressione Enter para continuar...");
System.in.read();
}
for (int i = 0; i < qtd; i++){
for (int b = 0; b < qtd; b++){
System.out.println("Atividade "+atividades[b].getNome()+" - ID = "+atividades[b].getId());
}
System.out.println("Pressione Enter para continuar...");
System.in.read();
if (atividades[i].getPredecessores() > 0 ) {
System.out.println("Atividades Predecessoras de "+atividades[i].getNome());
for (int k=0; k<atividades[i].getPredecessores(); k++){
System.out.println("Informe o ID da atividade predecessora de numero "+(k+1)+" ...");
aux = s.nextInt();
atividades[i].setarAtividadePredecessora(atividades[aux]);
System.out.println("Pressione Enter para continuar...");
System.in.read();
Runtime.getRuntime().exec("clear");
}
} else {
System.out.println("A atividade ["+atividades[i].getNome()+"] não possui predecessores");
System.out.println("Pressione Enter para continuar...");
System.in.read();
}
for (int b = 0; b < qtd; b++){
System.out.println("Atividade "+atividades[b].getNome()+" - ID = "+atividades[b].getId());
}
System.out.println("Pressione Enter para continuar...");
System.in.read();
if (atividades[i].getSucessores() > 0 ) {
System.out.println("Atividades Sucessoras de "+atividades[i].getNome());
for (int k=0; k<atividades[i].getSucessores(); k++){
System.out.println("Informe o id da atividade sucessora de numero "+(k+1)+" ...");
aux = s.nextInt();
atividades[i].setarAtividadeSucessora(atividades[aux]);
System.out.println("Pressione Enter para continuar...");
System.in.read();
}
} else {
System.out.println("A atividade ["+atividades[i].getNome()+"] não possui sucessores");
System.out.println("Pressione Enter para continuar...");
System.in.read();
}
}
Tes_Tef(atividades);
Tlf_Tls(atividades);
atividadeInfo(atividades);
R(atividades);
caminhoCritico(atividades);
}
}
OBS .: I need to transfer to a xml file because the lib i am going to use to draw the graph needs it. I am going to use the prefuse lib.

If all you need is to draw the graph with prefuse, you do not need to create a xml file for that. You can a prefuse graph object and add nodes, edges directly to it. Here is a simple example with 2 nodes, 1 edge, and a property value on 1 node:
Graph graph = new Graph();
graph.getNodeTable().addColumn("duration", double.class);
Node n1 = graph.addNode();
n1.setDouble("duration", 20.0);
Node n2 = graph.addNode();
Edge e = graph.addEdge(n1, n2);
You would need to iterate over all nodes and edge of your custom class.

Huge Array sorting through CORBA and RMI?

As a task I got to develop an app so a client sends a 1 million numbers array to a CORBA server. So the server would distribute the sorting task to a few slaves.
I honestly don't like CORBA at all, and requirements would accept RMI, so I went for embedding RMI inside the CORBA server. I can get CORBA server seize RMI so far, however, I'm not getting the array sorted.
I'll decribe parts of the programm and the relationship among them.
CORBA SERVER
import sorting.*;
public class Servidor {
public static void main(String[] args) {
try {
// 1. Inicializar ORB
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
// 2.1 Obtener POA raiz
POA raizPOA = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
// 2.2 Activar el POA manager
raizPOA.the_POAManager().activate();
// 3.1 Crear instancia de la implementación (servant)
propiedadesImplementacion servant = new propiedadesImplementacion();
// 3.2 Registrar en el POA y obtener referencia al objeto (IOR)
org.omg.CORBA.Object sortingCORBA = raizPOA.servant_to_reference(servant);
// 4.1 Obtener el initial naming context
org.omg.CORBA.Object ncCorba = orb.resolve_initial_references("NameService");
NamingContextExt nc = NamingContextExtHelper.narrow(ncCorba);
// 4.2 Asociar un nombre (en el primer nivel)
nc.rebind(nc.to_name("Proyecto"), sortingCORBA);
// 5 Quedar a la espera de peticiones
System.out.println("Proceso servidor en espera ... ");
Runtime.getRuntime().exec("rmiregistry");
Thread.sleep(1000);
ObjetoRemoto or = new ObjetoRemoto();
Naming.rebind("//localhost/ObjetoRemoto", or);
System.out.println("Conexión establecida");
orb.run();
} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
System.exit(1);
}
}
}
CORBA method Implementation
public class propiedadesImplementacion extends ServidorProyectoPOA {
public propiedadesImplementacion() {
}
public int[] ordenar(int [] a) {
int[] sub1 = Arrays.copyOfRange(a,0,199999);
int[] sub2 = Arrays.copyOfRange(a,200000,399999);
int[] sub3 = Arrays.copyOfRange(a,400000,599999);
int[] sub4 = Arrays.copyOfRange(a,600000,799999);
int[] sub5 = Arrays.copyOfRange(a,800000,999999);
try {
Registry registry = LocateRegistry.getRegistry("localhost");
InterfazRMI i = (InterfazRMI )registry.lookup("objetoRemoto");
sub1 = i.ordenarRMI(sub1);
sub2 = i.ordenarRMI(sub2);
sub3 = i.ordenarRMI(sub3);
sub4 = i.ordenarRMI(sub4);
sub5 = i.ordenarRMI(sub5);
sub2 = merge(sub1, sub2);
sub3 = merge(sub2, sub3);
sub4 = merge(sub3, sub4);
sub5 = merge(sub4, sub5);
Arrays.sort(sub5);
}
catch (Exception e) {}
return sub5;
}
private int[] merge(int[] a, int[] b) {
int aLen = a.length;
int bLen = b.length;
int[] c= new int[aLen+bLen];
System.arraycopy(a, 0, c, 0, aLen);
System.arraycopy(b, 0, c, aLen, bLen);
return c;
}
}
CORBA CLIENT
import sorting.*;
public class Cliente {
public static void main(String[] args) {
try {
// 1. Inicializar ORB
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
// 2.1 Obtener instancia del servidor de nombres (initial naming context)
org.omg.CORBA.Object ncCorba = orb.resolve_initial_references("NameService");
NamingContextExt nc = NamingContextExtHelper.narrow(ncCorba);
// 2.2 Construir el nombre del objeto y obtener ref. desde servidor de nombres
org.omg.CORBA.Object clienteCorba = nc.resolve(nc.to_name("Proyecto"));
// 2.4 Convertir el objeto CORBA al tipo Propiedades (narrow)
ServidorProyecto sp = ServidorProyectoHelper.narrow(clienteCorba);
// 3 Invocar métodos remotos
int [] a = new int[1000000];
Random r = new Random();
for (int i=0; i<1000000; i++) {
a[i] = r.nextInt(1000000)+1;
// System.out.print(a[i] + " ");
}
a = sp.ordenar(a);
for (int i=0; i<1000000; i++) {
System.out.print(a[i] + " ");
}
}
catch (Exception e) {
System.out.println("Error:" + e.getMessage());
System.exit(1);
}
}
}
So, client is simply producing an array (in this case for testing) and calling the ordenar(int[]) method, that method actually calls some methods registered by RMI which was launched before by server. Array I'm getting back is not exactly sorted. Is the problem in the CORBA-RMI structure or right in sorting implementation?

Java Object creation through loop

So I create objects MyFrame, and stores them in a MyFrame array. The problem is when the loop is done, all the objects in the array are equal to the last object created.
Here's the code:
MyFrame [] response = new MyFrame[8];
for(int i = 0; i<numberSplit; i++){
response[i] = new MyFrame("","", infoS[i],"");
}
Here the full class if you run the main you will see that's in splitInfo and if I manually print each element in the array upon creation it works :
import java.io.*;
import java.util.*;
public class MyFrame {
// Variable qui donne une valeur fixe aux fanions.
private static BitSet [] frame = new BitSet [6];
private static BitSet flag_1 = new BitSet(8);
private static BitSet address = new BitSet(8);
private static BitSet control = new BitSet(8);
private static BitSet fcs = new BitSet(16);
private static String info = null;
// Constructeur pour créer des trames
public MyFrame (BitSet address, BitSet control, String info, BitSet fcs){
this.frame = frame;
flag_1.set(1,7);
this.frame[0] = flag_1;
this.frame[1] = address;
this.frame[2] = control;
this.frame[3] = stringToBitSet(info);
this.frame[4] = fcs;
this.frame[5] = flag_1;
}
public MyFrame (String address, String control, String info, String fcs){
this.frame = frame;
flag_1.set(1,7);
this.frame[0] = flag_1;
this.frame[1] = stringToBitSet(address);
this.frame[2] = stringToBitSet(control);
this.frame[3] = stringToBitSet(info);
this.frame[4] = stringToBitSet(fcs);
this.frame[5] = flag_1;
}
// Constructeur qui prend comme entree une trame en String et la longueur du champ
// d'information
public MyFrame (String frameS, int infoL){
int endIL = 24+infoL;
this.frame = frame;
this.frame[0] = stringToBitSet(frameS.substring(0,7));
this.frame[1] = stringToBitSet(frameS.substring(8,16));
this.frame[2] = stringToBitSet(frameS.substring(16,24));
this.frame[3] = stringToBitSet(frameS.substring(24,endIL));
this.frame[4] = stringToBitSet(frameS.substring(endIL,endIL+16));
this.frame[5] = stringToBitSet(frameS.substring(endIL+16,endIL+24));
}
// Constructeur-copieur
public MyFrame (MyFrame frm){
this.frame[0] = (BitSet)frm.frame[0].clone();
this.frame[1] = (BitSet)frm.frame[1].clone();
this.frame[2] = (BitSet)frm.frame[2].clone();
this.frame[3] = (BitSet)frm.frame[3].clone();
this.frame[4] = (BitSet)frm.frame[4].clone();
this.frame[5] = (BitSet)frm.frame[5].clone();
}
// GETTERS
public BitSet getAddress(){
return this.frame[1];
}
public BitSet getCtrl(){
return this.frame[2];
}
public BitSet getInfo(){
return this.frame[3];
}
public BitSet getFCS(){
return this.frame[4];
}
public BitSet getFlag(){
return this.frame[5];
}
public void setAddress(String add){
this.frame[1] =stringToBitSet(add);
}
// Convertit un BitSet en String.
public static String bitSetToString(BitSet bs, int length){
String result ="";
String tempString="";
for(int i=0; i < length; i++){
boolean temp = bs.get(i);
if (temp){
tempString = "1";
}else{
tempString = "0";
}
result = result.concat(tempString);
}
return result;
}
//Convertit un String en BitSet.
public static BitSet stringToBitSet(String bits){
int length = bits.length();
BitSet result = new BitSet (length);
for(int i=0; i < length; i++){
if (bits.charAt(i) == '1'){
result.set(i);
}
}
return result;
}
// puisqu'on utilise le PrintWriter on prend la trame et on la transpose en une grande String
// prend la longueur du champ info en parametre puisqu'il est variable
public String toString(int infoL){
String result = "";
result = result.concat(bitSetToString(this.frame[0],8));
result = result.concat(bitSetToString(this.frame[1],8));
result = result.concat(bitSetToString(this.frame[2],8));
result = result.concat(bitSetToString(this.frame[3],infoL));
result = result.concat(bitSetToString(this.frame[4],16));
result = result.concat(bitSetToString(this.frame[5],8));
return result;
}
// print
public static void print (MyFrame trame, int infoL) {
System.out.println("Fanion : "+bitSetToString(trame.frame[0],8));
System.out.println("Addresse : " +bitSetToString(trame.frame[1],8));
System.out.println("Control : "+bitSetToString(trame.frame[2],8));
System.out.println("Info : "+bitSetToString(trame.frame[3],infoL));
System.out.println("FCS : "+bitSetToString(trame.frame[4],16));
System.out.println("Fanion : "+bitSetToString(trame.frame[5],8));
}
// Methode qui prend une trame en parametre et retourne une trame reponse
public MyFrame [] processFrame(){
MyFrame [] response = new MyFrame [8];
BitSet control = this.getCtrl();
String ctrlS = MyFrame.bitSetToString(control,8);
BufferedReader userIn = new BufferedReader(new InputStreamReader(System.in)) ;
String address, info;
// Determine quel type de trame la trame est
if(!control.get(0)){
System.out.println("Cette trame est de type I");
}else if (control.get(0) && !control.get(1)){
System.out.println("Cette trame est de type S");
// RR
if (ctrlS.substring(0,4).equals("1000")){
System.out.println("RR");
// Desire envoyer des trames
System.out.println("Desirez-vous envoyer une ou des trame(s)?");
for(;;){
try{
if( userIn.readLine().equals("oui")){
System.out.println("Les addresses sont en format binaire et commence toujours par 1");
System.out.println("Par exemple : Station Primaire = 10101010");
System.out.println("Station Secondaire 00 = 10000000");
System.out.println("Station Secondaire 01 = 10000001");
System.out.println("Station Secondaire 10 = 10000010");
System.out.println("...");
System.out.println("Station Secondaire 11111111 = 11111111");
System.out.println("\n");
System.out.println("Entrer l'addresse pour quel station ces trames sont destinées : ");
address = userIn.readLine();
System.out.println("Veuillez entrer l'information en binaire que vous-voulez envoyer à l'addresse "+ address +" : ");
info = userIn.readLine();
response = splitInfo(info);
print(response[0],512);
// ajoute l'addresse au trames
for(int i = 0; i < response.length-1; i++){
response [i].setAddress(address);
}
// retourne la serie de trames
return response;
// N'a aucune trame a envoyer
}else if (userIn.readLine().equals("non")){
response [0] = new MyFrame ("10101010", "10000000","","0000000000000000");
return response;
}else{
System.out.println("Veuillez entrer soit 'oui' soit 'non'");
}
break;
}catch(IOException e){
System.out.println(e);
}
}
}
// RNR
else if(ctrlS.substring(0,1).equals("1001")){
}
// FRAME ERROR
else{}
}else if (control.get(0) && control.get(1)){
System.out.println("Cette trame est de type U : ");
// SRNM
if (ctrlS.equals("11001001")){
System.out.print("SRNM \n");
response [0] = new MyFrame("10101010","11001110","","0000000000000000");
return response;
}
// DISC
else if(ctrlS.equals("11001010")){
}
// UA
else if(ctrlS.equals("11001110")){
System.out.print("UA \n");
}
// FRMR : Report receipt of an unacceptable frame
else{
}
}
return null;
}
// Methode qui prend un string d'information a envoyer et le subdivise en
// string binaire de 512 bits et cree le nombre de trame en consequence
// par defaut la limite en terme de longeur totale est de 8 (4096 bits)
public static MyFrame [] splitInfo (String info){
Integer binVal = new Integer(256);
String infoBin = "";
String [] infoS = new String [8];
MyFrame [] response = new MyFrame [8];
int numberSplit = 0;
// Transcode les caractere en UTF-8 binaire
try{
byte [] string = info.getBytes("UTF-8");
for(int i = 0 ; i<= string.length-1; i++){
infoBin = infoBin.concat(binVal.toBinaryString(string[i]));
}
// Si le message resultant est plus que 64 octets (512 bits)
// le splitter en message de 512 bits
if (infoBin.length() >511){
for (int i = 0; i<=((int)(infoBin.length()/512)); i++){
if(((i+1)*512) > infoBin.length()){
infoS[i] = infoBin.substring(512*i, infoBin.length());
}else{
infoS[i] = infoBin.substring(512*i, 512*(i+1));
}
numberSplit++;
}
// Creer les trames
for (int i = 0; i<numberSplit; i++){
MyFrame temp = new MyFrame ("","",infoS[i],"0000000000000000");
response[i] = new MyFrame(temp);
//print(temp,512);
}
print(response[0],512);
print(response[1],512);
//System.out.println(response[0]);
//System.out.println(response[1]);
//print(response2[0],512);
return response;
}else{
response [0] = new MyFrame("","",infoBin,"0000000000000000");
return response;
}
}catch(Exception e){}
return null;
}
public static void main(String args[]){
MyFrame trame = new MyFrame("0000000"+1,"10001000","","0000000000000011");
print(trame,0);
MyFrame trame2 = new MyFrame(trame.toString(0), 0);
print(trame2,0);
BitSet compare = new BitSet(8);
compare.set(0,2,true);
compare.set(4);
compare.set(7,true);
System.out.println("compare : " + compare.toString() + " ctrl : " + trame2.frame[2]);
System.out.println(trame2.frame[2].equals(compare));
trame2.setAddress("10111001");
MyFrame [] x = splitInfo("HEAKdsANSDLASDIASDLMASLDMASKDHAKSNDKAasdasdadasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdsdasdasdasdasdasdasdasdasdasdasdasSMDKASNDKNASKDNASODDFKANSKBFNSKANSDADKABSFKBNASKDNAKSDNOKGJIKASNDIKNASDNA");
}
}

A good way to test if the objects are really different objects is System.out.println(System.identityHashCode(object))
but the code you posted, as said before, is creating and saving distinct objects.

From the code snippet above, that's not possible. Each of them is a seperate new object.
Couple of things
If MyFrame is a custom class, did you override equals/hashcode poorly?
Are you seeing the same info across MyFrame instances? Could it be a poorly declared static variable?