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);
Related
Please, I need help to make this script work.
I dont know if I can make maths with an string.
I need a program that save numbers inside an array and after that i need to calculate the average betwen those numbers.
When trying to compile this program the compiler only gives me this message:
Basquete2.java:6: error: illegal start of expression
private Pontos [] pontos;
^
1 error
And this is the complete Script:
import javax.swing.JOptionPane;
public class Basquete {
public static void main(String[]args){
//criando array nulo
private Pontos [] pontos;
//variaveis
String desicaoUsuario = "sim";
int i = 0;
int pos = -1;
int soma = 0;
int divisor = 0;
float media;
while(desicaoUsuario == "sim" ){
if(pontos == null){
//criando array
pontos = new Pontos[1];
//posicionando
pos = 0;
//inserindo dados pelo usuario na posiçao
pontos[pos] = JOptionPane.showInputDialog("Informe o número:");
//pergunta se deseja continuar
desicaoUsuario = JOptionPane.showInputDialog("Deseja adicionar outro número? sim/nao");
}else{
//criando novo array guardando os objetos
Pontos [] backup = pontos;
//ampliando o array original
pontos = new Pontos[pontos.lenght + 1];
//copiando objetos para o array original
for(int i = 0; i < backup.lenght; i++){
pontos[i] = backup[i];
}
//posicionando
pos = backup.lenght;
//ciando objeto na posição pronta para inserir
pontos[pos] = JOptionPane.showInputDialog("Informe o número:");
//pergunta se deseja continuar
desicaoUsuario = JOptionPane.showInputDialog("Deseja adicionar outro número? sim/nao");
}
}
//mostrando mensagem
JOptionPane.showMessageDialog("Vamos calcular a media de pontos do time por partida!");
//calculando soma
i = 0;
while(i < pontos.lenght){
soma = soma + pontos[i];
i++;
}
//calcula media
divisor = pontos.lenght;
media = soma / divisor;
//mostra resultado da media
JOptionPane.showMessageDialog("A media de pontos é de " + media + " pontos por partida!");
//saida do sistema
System.exit(0);
}
}
Well im trying to change an array to arraylist, the create account seems to be working but the "show accounts" method keeps returning me that there's not account register.
this is the add account method (the commentary's are the original array)
//Metodo para agregar Cuentas
public void agregarCuenta(Cuenta c){
ArrayList<Cuenta> cuentas = new ArrayList<Cuenta>();
cuentas.add(c);
/*
Cuenta aux[] = new Cuenta[cuentas.length+1];
System.arraycopy(cuentas, 0, aux, 0, cuentas.length);
aux[aux.length-1] = c;
cuentas = aux;
*/
}
and this is the show accounts method
public static void mostrarAhorro()
{
ArrayList<Cuenta> cuentas = new ArrayList<Cuenta>();
//Si no hay cuentas en el arreglo, nos muestra el siguiente error
if (cuentas.size() == 0)
{
System.out.println("No hay cuentas registradas.");
return;
}
System.out.println("****Lista de cuentas de ahorro****");
//For para mostrar todas las cuentas de ahorro
for (int i = 0; i<cuentas.size();i++) {
if (cuentas.get(i) instanceof CuentaAhorros)
{
System.out.println("Id de cuenta: " + (i+1) +"\n"+ cuentas);
}
}
}
this is the rest of the code
package Programas;
import java.util.Scanner;
import Banco.Cuenta;
import Banco.CuentaAhorros;
import Banco.CuentaCheques;
import Banco.Movimientos;
import java.text.DecimalFormat;
import java.util.ArrayList;
public class programa1 {
//Instanciar scanner y formato de moneda
private static Scanner sc = new Scanner(System.in);
private static DecimalFormat MONEDA = new DecimalFormat("$#,###.00");;
//Arreglo de clases instanciada.
//private static Cuenta[] cuentas = new Cuenta[0];
//private static Movimientos [] movimientos = new Movimientos[0];
public static void main(String[] args) {
//ArrayList cuentas = new ArrayList();
ArrayList<Cuenta> cuentas = new ArrayList<Cuenta>();
ArrayList<Movimientos> movimientos = new ArrayList<Movimientos>();
//Selec para mantener el while corriendo, y while para mantener el menu.
int selec = 0;
while (selec <7)
{
//Imprimir lista de opciones
System.out.println("Seleccione una opcion: "+ "\n1.-Crear cuenta de ahorros."+ "\n2.-Crear cuenta de cheques."+ "\n3.-Mostrar listado de cuentas de ahorro."+ "\n4.-Mostrar listado de cuentas de cheques."+ "\n5.-Mostrar listado de todas las cuentas."+ "\n6.-Operaciones de una cuenta."+ "\n7.-Salir");
//Pedirle al usuario una opcion
selec = sc.nextInt();
//Switch para que cuando selec cambie se ejecute una opcion.
switch (selec)
{
//Caso 1 para agregar Cuenta de ahorros
case 1:
System.out.println("Ha escogido crear una cuenta de ahorros."+ "\nIngrese el saldo inicial, y la tasa de interes: ");
//Instancia de Cuenta tipo ahorros
Cuenta c1 = new CuentaAhorros(sc.nextDouble(),sc.nextDouble());
cuentas.add(c1);
System.out.println("\nCuenta de ahorros agregada exitosamente."+ "\nTotal de cuentas: " + cuentas.size() + "\nfecha de ingreso: " + movimientos.size());
break;
//Caso 2 para agregar cuenta de ahorros.
case 2:
System.out.println("Ha escogido crear una cuenta de cheques."+ "\nIngrese el saldo inicial, y el costo de manejo de la cuenta: ");
//Instancia de cuenta tipo cheques
Cuenta c2 = new CuentaCheques(sc.nextDouble(),sc.nextDouble());
cuentas.add(c2);
System.out.println("\nCuenta de cheques agregada exitosamente."+ "\nTotal de cuentas: "+ cuentas.size());
break;
//Caso para mostrar la lista de cuentas de ahorro
case 3:
System.out.println("Listado de cuentas de ahorro: ");
mostrarAhorro();
break;
//Caso para mostrar la lista de cuentas de cheques
case 4:
System.out.println("Listado de cuentas de Cheques: ");
mostrarCheques();
break;
//Caso para mostrar todas las cuentas
case 5:
System.out.println("Listado de todas las cuentas: ");
mostrarCuentas();
break;
//Caso para realizar operaciones de una cuenta
case 6:
operacionesCuenta();
break;
}
}
}
//Metodo para agregar Cuentas
public void agregarCuenta(Cuenta c){
ArrayList<Cuenta> cuentas = new ArrayList<Cuenta>();
cuentas.add(c);
//cuentas = aux;
/*
Cuenta aux[] = new Cuenta[cuentas.length+1];
System.arraycopy(cuentas, 0, aux, 0, cuentas.length);
aux[aux.length-1] = c;
cuentas = aux;
*/
}
//Metodo para mostrar las cuentas de tipo ahorro
public static void mostrarAhorro()
{
ArrayList<Cuenta> cuentas = new ArrayList<>();
//Si no hay cuentas en el arreglo, nos muestra el siguiente error
if (cuentas.isEmpty())
{
System.out.println("No hay cuentas registradas.");
return;
}
System.out.println("****Lista de cuentas de ahorro****");
//For para mostrar todas las cuentas de ahorro
for (int i = 0; i<cuentas.size();i++) {
if (cuentas.get(i) instanceof CuentaAhorros)
{
System.out.println("Id de cuenta: " + (i+1) +"\n"+ cuentas);
}
}
}
//Metodo para cuenta cheques
public static void mostrarCheques()
{
//Si no hay cuentas en el arreglo, nos muestra el siguiente error
ArrayList<Cuenta> cuentas = new ArrayList<>();
if (cuentas.size() == 0)
{
System.out.println("No hay cuentas registradas.");
return;
}
System.out.println("****Lista de cuentas de Cheques****");
//For para mostrar todas las cuentas de ahorro
for (int i = 0; i<cuentas.size();i++) {
if (cuentas.get(i) instanceof CuentaCheques)
{
//CuentaCheques a = (CuentaCheques)cuentas.get(1);
//System.out.println("Id de cuenta: " + (i+1) +"\n"+ a);
System.out.println(cuentas);
}
}
}
public static void mostrarCuentas()
{
//Si no hay cuentas en el arreglo, nos muestra el siguiente error
ArrayList<Cuenta> cuentas = new ArrayList<>();
if (cuentas.size() == 0)
{
System.out.println("No hay cuentas registradas.");
return;
}
System.out.println("****Lista de todas las cuentas****");
//For para mostrar todas las cuentas de ahorro
for (int i = 0; i<cuentas.size();i++) {
if (cuentas.get(i) instanceof CuentaCheques)
{
CuentaCheques a = (CuentaCheques)cuentas.get(i);
System.out.println("Tipo de cuenta: Cheques. "+ "\nId de cuenta: " + (i+1) +"\n"+ a.toString());
}
else
{
CuentaAhorros a = (CuentaAhorros)cuentas.get(i);
System.out.println("Tipo de cuenta: Ahorro."+ "\nId de cuenta: "+ (i+1) +"\n"+ a.toString());
}
}
}
public static void operacionesCuenta()
{
System.out.println("Seleccione la Id de la cuenta que desea usar: ");
int id = (sc.nextInt() -1);
ArrayList<Cuenta> cuentas = new ArrayList<>();
if(id > cuentas.size())
{
System.out.println("Escogio una cuenta que no existe.");
return;
}
if(cuentas.get(id) instanceof CuentaCheques)
{
int choice = 0;
while(choice<6)
{
CuentaCheques a = (CuentaCheques)cuentas.get(id);
System.out.println("Selecciono cuenta de cheques."+ "\n1.-Consultar Saldo."+ "\n2.-Retirar."+ "\n3.-Depositar." + "\n4.-Aplicar manejo de cuenta."+ "\n5.-Ver informacion de la cuenta."+ "\n6.-Salir."+ "\nSeleccione una opcion:");
choice = sc.nextInt();
switch(choice)
{
case 1:
System.out.println("\nEl saldo actual de la cuenta es: " +MONEDA.format(a.getSaldo()));
break;
case 2:
System.out.println("\nIngrese la cantidad que desea retirar: ");
double retirarAhorros = sc.nextDouble();
a.retirar(retirarAhorros);
break;
case 3:
System.out.println("\nIngrese la cantidad que desea depositar: ");
double depositarAhorros = sc.nextDouble();
a.depositar(depositarAhorros);
break;
case 4:
System.out.println("Selecciono aplicar manejo de la cuenta.");
a.aplicarCostoManejoCuenta();
break;
case 5:
System.out.println("Selecciono ver informacion de la cuenta.");
System.out.println(a);
break;
}
}
}
else
{
int choice2 = 0;
while(choice2<6)
{
CuentaAhorros a = (CuentaAhorros)cuentas.get(id);
System.out.println("Escogio cuenta de ahorros."+ "\n1.-Consultar Saldo."+ "\n2.-Retirar."+ "\n3.-Depositar."+ "\n4.-Aplicar manejo de cuenta."+ "\n5.-Ver informacion de la cuenta."+ "\n6.-Salir."+ "\nSeleccione una opcion:");
choice2 = sc.nextInt();
switch(choice2)
{
case 1:
System.out.println("\nEl saldo actual de la cuenta es: " +MONEDA.format(a.getSaldo()));
break;
case 2:
System.out.println("\nIngrese la cantidad que desea retirar: ");
double retirarCheques = sc.nextDouble();
a.retirar(retirarCheques);
break;
case 3:
System.out.println("\nIngrese la cantidad que desea depositar: ");
double depositarCheques = sc.nextDouble();
a.depositar(depositarCheques);
break;
case 4:
System.out.println("Selecciono aplicar manejo de la cuenta.");
a.aplicarInteres();
break;
case 5:
System.out.println("Selecciono ver informacion de la cuenta.");
System.out.println(a);
break;
}
}
}
}
}
The problem is, every time you call the mostrarAhorro method, and even every time you call the agregarCuenta method, you are overwriting the cuentas array list with:
ArrayList<Cuenta> cuentas = new ArrayList<Cuenta>();
Every time you call this, it creates an empty array and ignores any data it previously had.
You only need to create it once and store it as a member variable in the class.
ArrayList<Cuenta> cuentas = new ArrayList<Cuenta>();
//Metodo para agregar Cuentas
public void agregarCuenta(Cuenta c){
cuentas.add(c);
/*
Cuenta aux[] = new Cuenta[cuentas.length+1];
System.arraycopy(cuentas, 0, aux, 0, cuentas.length);
aux[aux.length-1] = c;
cuentas = aux;
*/
}
public static void mostrarAhorro()
{
//Si no hay cuentas en el arreglo, nos muestra el siguiente error
if (cuentas.size() == 0)
{
System.out.println("No hay cuentas registradas.");
return;
}
System.out.println("****Lista de cuentas de ahorro****");
//For para mostrar todas las cuentas de ahorro
for (int i = 0; i<cuentas.size();i++) {
if (cuentas.get(i) instanceof CuentaAhorros)
{
System.out.println("Id de cuenta: " + (i+1) +"\n"+ cuentas);
}
}
}
EDIT: You need to declare the cuentas array at the top of your class so all methods have access to it. Delete the creation of cuentas in the main method as well.
public class programa1 {
//Instanciar scanner y formato de moneda
private static Scanner sc = new Scanner(System.in);
private static DecimalFormat MONEDA = new DecimalFormat("$#,###.00");
private ArrayList<Cuenta> cuentas = new ArrayList<Cuenta>();
//Arreglo de clases instanciada.
//private static Cuenta[] cuentas = new Cuenta[0];
//private static Movimientos [] movimientos = new Movimientos[0];
public static void main(String[] args) {
//ArrayList cuentas = new ArrayList();
ArrayList<Movimientos> movimientos = new ArrayList<Movimientos>();
You are creating a complete new instance of the arrayList in the display method.
If this list is common across the current run , you can just declare it as
private static List cuentaList = new ArrayList();
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]);
}
}
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.
I know there are a lot of questions about that topic. In fact, I was searching in others questions and I tried to use some solutions but it was not enough.
I have to do a program that simulate puffball, using backtracking, and now I am developing the moves, and when I do a move I need to save the table because is a possible solution, so THE PROBLEM IS NEXT:
When a I try to keep off a table the first one save it right but the next is added and overwrite the earlier. I show you the code, it is not all, only methods and other info that I think can be useful for all of you.
In main() you can see how I get all information, and then when I start to play, I call to soplarBola(), It is here where you could see the problem.
Excuse me, because all is in Spanish. I hope you could understand my handicap.
Thanks a lot!
public class Main {
static Scanner sc = new Scanner(System.in);
static int[] dimension = new int[2];
static int numPoscionesFinales;
static int numBolas;
static ArrayList<Integer> totalIdBolas;
static ArrayList<ArrayList<Integer>> totalesIdBolas;
static ArrayList<int[]> coordenadasFinales;
static ArrayList<int[]> coordenadasBolas;
static Casilla ca;
static ArrayList<Casilla> tablero;
static ArrayList<ArrayList<Casilla>> tablerosSol;
static ArrayList<Integer> bolasSopladas; //Recoge todos los caminos posibles
static ArrayList<ArrayList<Casilla>> tablerosVisitados;
static ArrayList<ArrayList<Integer>> caminos; //Recoge los int[] que contienen caminos solucion
public static void main(String[] args) {
//Dimensiones del tablero
//Numero de posiciones finales que son las mismas que bolas habra
//Generamos un ArrayList con los idBolas posibles para despues permutar todas las posibles soluciones y generar los tableros solucion con los que compararemos los tableros que vayamos creando
//coordenadas de posiciones finales
//coordenadas de bolas
crearTablero(dimension);
crearTablerosSol(tablero,totalesIdBolas);
bolasSopladas = new ArrayList<Integer>();
resolverSoplarBola(bolasSopladas,tablero,totalesIdBolas,tablerosVisitados, caminos);
}
/* Esta es la semilla de la que nacerá el árbol solucion */
public static void resolverSoplarBola(ArrayList<Integer> bolasSopladas, ArrayList<Casilla> ta,
ArrayList<ArrayList<Integer>> totalesIdBolas, ArrayList<ArrayList<Casilla>> tablerosVisit, ArrayList<ArrayList<Integer>> caminos) {
ArrayList<Integer> solParcial = bolasSopladas;
int nBolas = 1;
caminos = new ArrayList<ArrayList<Integer>>();
//imprimirTab1(ta,nBolas);
while(nBolas<numBolas){
//Sea b la bola que sopla ...sopla y mueve todas las bolas generando un nuevo tablero añadido a tablerosVisitados
tablerosVisit.add(soplarBola(nBolas,ta));
// imprimirTableros(tablerosVisitados,nBolas);
//y calculamos el nuevo tablero a partir de tablero_actual - ta - y...
//solucionesParciales - bolasSopladas - añade b
solParcial.add(nBolas);
if(esTableroSolucion(ta, tablerosSol)){
caminos.add(bolasSopladas);
}else if(esTableroVisitado(ta, tablerosVisit)){
//se para aquí y no avanzará
break;
}else{
resolverSoplarBola(solParcial, ta, totalesIdBolas, tablerosVisit, caminos);
}
nBolas++;
}
}
private static void imprimirTab1(ArrayList<Casilla> ta, String m) {
Iterator<Casilla> itTab= ta.iterator();
System.out.println("");
System.out.println("Tablero actual: " + m);
for(int i=1; i<=dimension[0];i++){
for(int j=1; j<=dimension[1]; j++){
System.out.print("["+itTab.next().idBola+"] ");
}
System.out.println(".");
}
}
private static void imprimirTabVisitados(ArrayList<ArrayList<Casilla>> tabVisitados){
ArrayList<ArrayList<Casilla>> tabVis = tabVisitados;
Iterator<ArrayList<Casilla>> itVis = tabVis.iterator();
ArrayList<Casilla> tabN;
//Los tableros que se imprimen aquí ya han sido comprobados de que no están duplicados
while(itVis.hasNext()){
tabN = itVis.next();
imprimirTab1(tabN," visitados");
}
}
public static ArrayList<Casilla> soplarBola(int idBola,ArrayList<Casilla> tabl){
tablerosVisitados = new ArrayList<ArrayList<Casilla>>();
//ArrayList<Casilla> tabl = tab;
boolean movimientoHecho = false;
Iterator<Casilla> it = tabl.iterator();
int x =1;
int y =1;
Casilla casi;
Casilla casi2;
boolean hayMovimiento = false;
int cont = 0;
idBola = 3;
while(it.hasNext()){//Recorremos todo el tablero buscando la bola con idBola para obtener sus coordenadas
casi = it.next();
if(casi.idBola == idBola){
x = casi.coordX;
y = casi.coordY;
}
}
**tablerosVisitados.add(cont, tabl);
// imprimirTab1(tablerosVisitados.get(0), "0");
imprimirTodo(tablerosVisitados, "inicial");** <- //Here is all OK, print the rigth table.
//MOVIMIENTOS EN LA FILA
it = tabl.iterator();
//Vamos a analizar las filas desde el borde hasta la bola
casi = casillaBuscada(x,1,tabl); //Desde la izq
while(casi.coordY < y && casi.coordX == x){
//coordenadas que están a la izquierda de la idBola
if(casi.idBola!=0){ //Si hay bola no se podrá mover a esa posicion
hayMovimiento=false;
}else{
hayMovimiento=true; //si no hay bola, es que hay hueco y se puede mover a esa posicion
}
casi2 =casillaBuscada(casi.coordX,casi.coordY+1,tabl);
if(hayMovimiento && casi2.getIdBola()!=0 && casi2.getIdBola()!=idBola){ //si hay movimiento y en la posterior hay bola, se traslada a ocupar ese hueco
casi.setIdBola(casi2.getIdBola());
casi2.setIdBola(0); //Desplazamiento a la derecha cambiado el idBola
movimientoHecho = true;
}
casi = it.next();//pasamos a la siguiente casilla
}
**//imprimirTab1(tabl, "1"); If I use that line print the rigth table in that moment**
if(movimientoHecho){
cont++;
tablerosVisitados.add(cont, tabl);
//tablerosVisitados.add(tabl);
imprimirTodo(tablerosVisitados,"1");
movimientoHecho=false;
}
//coordenadas que están a la derecha de la idBola
casi = casillaBuscada(x,dimension[1],tabl); //nos colocamos a la derecha de la bola y vamos ---->>>
while(casi.coordY > y && casi.coordX == x){
if(casi.idBola!=0){ //Si hay bola no se podrá mover a esa posicion
hayMovimiento=false;
}else{
hayMovimiento=true; //si no hay bola, es que hay hueco y se puede mover a esa posicion
}
casi2 =casillaBuscada(casi.coordX,casi.coordY-1,tabl);
if(hayMovimiento && casi2.getIdBola()!=0){ //si hay movimiento y en la posterior hay bola, se traslada a ocupar ese hueco
casi.setIdBola(casi2.getIdBola());
casi2.setIdBola(0); //Desplazamiento a la derecha cambiado el idBola
movimientoHecho=true;
}
casi = it.next();//pasamos a la siguiente casilla
}
// imprimirTab1(tabl,"2");
if(movimientoHecho){
cont++;
**tablerosVisitados.add(cont, tabl);**
//This is the line of horror. Delete the first one and set all table like that
//tablerosVisitados.add(tabl);
imprimirTodo(tablerosVisitados,"2");
movimientoHecho=false;
}
//MOVIMIENTO EN LA COLUMNA
it = tabl.iterator();
//Vamos a analizar las columnas desde arriba hacia abajo
casi = casillaBuscada(1,y,tabl); //Desde arriba
while(casi.coordY == y && casi.coordX <= x){
//coordenadas que están por encima de la idBola
if(casi.idBola!=0){ //Si hay bola no se podrá mover a esa posicion
hayMovimiento=false;
}else{
hayMovimiento=true; //si no hay bola, es que hay hueco y se puede mover a esa posicion
}
casi2 =casillaBuscada(casi.coordX-1,casi.coordY,tabl);
if(hayMovimiento && casi2.getIdBola()!=0 && casi2.getIdBola() != idBola){ //si hay movimiento y en la posterior hay bola, se traslada a ocupar ese hueco
casi.setIdBola(casi2.getIdBola());
casi2.setIdBola(0); //Desplazamiento hacia arriba cambiado el idBola
movimientoHecho=true;
}
casi = casi2;//pasamos a la siguiente casilla
}
//imprimirTab1(tabl,"3");
if(movimientoHecho){
cont++;
**tablerosVisitados.add(cont, tabl);** //This is the line of horror. Delete the first one and set all table like that
//tablerosVisitados.add(tabl);
imprimirTodo(tablerosVisitados,"3");
movimientoHecho=false;
}
//coordenadas que están por debajo de la idBola
casi = casillaBuscada(dimension[0],y,tabl); //nos colocamos a la abajo del todo
casi2 =casillaBuscada(casi.coordX-1,casi.coordY,tabl);
while(casi2.coordY == y && casi2.coordX > x){
if(casi2.idBola!=0 && casi.idBola == 0){ //Si hay bola no se podrá mover a esa posicion
hayMovimiento=true;
}else{
hayMovimiento=false; //si no hay bola, es que hay hueco y se puede mover a esa posicion
}
if(hayMovimiento && casi.getIdBola()==0 && casi2.getIdBola() != idBola){ //si hay movimiento y en la posterior hay bola, se traslada a ocupar ese hueco
casi.setIdBola(casi2.getIdBola());
casi2.setIdBola(0); //Desplazamiento a la derecha cambiado el idBola
movimientoHecho=true;
}
casi = casi2;//pasamos a la siguiente casilla
casi2 = casillaBuscada(casi.coordX-1,casi.coordY,tabl);
}
//imprimirTab1(tabl,"4");
if(movimientoHecho){
cont++;
**tablerosVisitados.add(cont, tabl);**
//This is the line of horror. Delete the first one and set all table like that
//tablerosVisitados.add(tabl);
imprimirTodo(tablerosVisitados,"4");
movimientoHecho=false;
}
suprTablVisitDuplicados(tablerosVisitados);
imprimirTabVisitados(tablerosVisitados);
return tabl;
}
private static void imprimirTodo(ArrayList<ArrayList<Casilla>> tablerosVisitados2, String m) {
for(int i = 0; i<tablerosVisitados2.size();i++){
imprimirTab1(tablerosVisitados.get(i), m);
}
}
private static void suprTablVisitDuplicados(ArrayList<ArrayList<Casilla>> tabVis) {
ArrayList<Casilla> tabTemp;
for(int i=0; i<tabVis.size(); i++){
tabTemp = tablerosVisitados.get(i);
if(esTableroVisitado(tabTemp, tablerosVisitados)){
tablerosVisitados.remove(i);
}
}
}
private static Casilla casillaBuscada(int cX, int cY, ArrayList<Casilla> tab) {
Casilla buscada = null;
boolean encontrada = false;
Iterator<Casilla> it = tab.iterator();
while(it.hasNext() && !encontrada){
buscada = it.next();
if(buscada.coordY==cY && buscada.coordX==cX){
encontrada=true;
}
}
return buscada;
}
private static boolean esTableroSolucion(ArrayList<Casilla> tab1, ArrayList<ArrayList<Casilla>> tabSol){
Iterator<ArrayList<Casilla>> it0 = tabSol.iterator();
Iterator<Casilla> it1 = tab1.iterator();
ArrayList<Casilla> tsol;
boolean esIgual = false;
while(it0.hasNext() && !esIgual){ //bucle que recorre el ArrayList de tableros visitados
tsol = it0.next();
Iterator<Casilla> it2 = tsol.iterator(); //iterator de una de los tableros visitados
while(it1.hasNext() && it2.hasNext() && !esIgual){ //bucle que recorrera los tableros a comparar
if(it1.next().equals(it2.next())){
esIgual=true;
}else{
esIgual=false;
}
}
}
return esIgual;
}
private static boolean esTableroVisitado(ArrayList<Casilla> tab1, ArrayList<ArrayList<Casilla>> tabVisitadas){
//Partimos de la suposición de que los 2 tableros son iguales y en caso de encontrar una diferencia break
Iterator<ArrayList<Casilla>> it0 = tabVisitadas.iterator();
Iterator<Casilla> it1 = tab1.iterator();
ArrayList<Casilla> tv;
boolean esIgual = true;
imprimirTab1(tab1, " original");
while(it0.hasNext() && esIgual){ //bucle que recorre el ArrayList de tableros visitados
tv = it0.next();
Iterator<Casilla> it2 = tv.iterator(); //iterator de una de los tableros visitados
while(it1.hasNext() && it2.hasNext() && esIgual){ //bucle que recorrera los tableros a comparar
imprimirTab1(tv, " comparado.");
if(it1.next() == it2.next()){
esIgual=true;
}else{
esIgual=false;
break;
}
}
}
return esIgual;
}
private static boolean estaContenido(int[] posicion, ArrayList<int[]> coords) {
boolean r = false;
int[] option;
for(int i=0; i<coords.size();i++){
option=new int[2];
option = coords.get(i);
if(option[0] == posicion[0]){
if(option[1]==posicion[1]){
r=true;
break;
}else{
r=false;
}
}else{
r=false;
}
}
return r;
}
}
The problem is result.
When my ArrayList tabVisited.add(newTable) is using references, so it is not copying another different, but the same. And like, all are connected between references, all changes.
The solution is here: https://energiaenescena.wordpress.com/2013/03/11/copia-profunda-de-objetos-en-java-por-serializacion/