urgente ArrayList

[stregone_giallo_rosso]

Potete aiutarmi a risolvere questo esercizio?

Un operatore telefonico ha organizzato l’archivio anagrafico dei propri clienti in un file denominato “Anagrafe.dat” ordinato in senso crescente rispetto al cognome, come segue:

Nome Cliente Cognome Cliente Numero Telefono

Esempio:

Gerardo Bianchi 0333457362
Rosa Clementino 0543778825
…
…
Pasquale Zigone 2234887289

Per ogni telefonata effettuata viene prodotto ed accodato ad un file denominato “telefonate.dat” un record con le seguenti informazioni:

Numero-chiamante Numero-chiamato Durata (in secondi)

Esempio:

0543778825 0834586372 15
2234887289 0834765736 358
…
…
0543778825 8463726534 446

Scrivere un programma che riceva in ingresso (possibilmente dalla linea di comando) il cognome e nome di due persone e calcoli il tempo totale di conversazione fra le due persone.

Ho caricato gli elementi dei due file su due ArrayList, ma adesso non so come continuare! Le classi Tel e Ele già le ho fatte.
import java.util.Scanner;
import java.util.ArrayList;
import java.io.FileReader;
class Array {
public Array (String file, String file1) throws Exception {
Scanner n = new Scanner (new FileReader (file));
Scanner m = new Scanner (new FileReader (file1));
ArrayList<Ele> a = new ArrayList<Ele>();
ArrayList<Tel> z = new ArrayList<Tel>();
Ele b = Ele.read(n);


while(b != null) {
a.add(b);
b = Ele.read(n);

}
Tel x = Tel.read1(m);
while(x != null) {
z.add(x);
x = Tel.read1(m);

}

n.close();
m.close();

}

[stregone_giallo_rosso]

Non mi dite che nessuno è in grado di farlo!!!!!!!!!!

[andbin]

Scrivere un programma che riceva in ingresso (possibilmente dalla linea di comando) il cognome e nome di due persone e calcoli il tempo totale di conversazione fra le due persone.

Ho caricato gli elementi dei due file su due ArrayList, ma adesso non so come continuare! Le classi Tel e Ele già le ho fatte.E quale è il problema preciso?

Da linea di comando viene passato il nome/cognome di 2 persone.
Per ognuna delle due persone, andrai a cercare il record corrispondente nell'array ArrayList<Ele>.
A quel punto hai i numeri di telefono delle due persone e vai nell'array ArrayList<Tel> a cercare tutti i record in cui ci sono, nello stesso record, i due numeri di telefono (cioè vuol dire che le due persone si sono parlate).

Non l'hai specificato ma in effetti, chiaramente, una delle due persone può chiamare l'altra ma anche viceversa.

[stregone_giallo_rosso]

Il problema è che non so cercare i record nell'ArrayList, e nemmeno il confronto fra il nome e il cognome per trovare il numero. (Mi puoi scrivere tutto il codice )

[andbin]

Il problema è che non so cercare i record nell'ArrayList, e nemmeno il confronto fra il nome e il cognome per trovare il numero. (Mi puoi scrivere tutto il codice )Dipende tutto da come hai scritto le classi Ele e Tel (e io ovviamente senza una sfera di cristallo non posso saperlo ....).

Posso solo immaginare (e sperare) che ad esempio nella classe Ele tu abbia definito 3 fields marcati private per il nome, cognome e telefono e poi abbia definito degli appositi metodi getter del tipo getNome(), ecc....

Quindi ti basta scansionare l'ArrayList, per ognuno prendere il nome e cognome e confrontarlo con quello che stai cercando.

[andbin]

Già che ci sono, volevo suggerirti un'altro possibile (e probabilmente più valido) design per le classi.

Una classe Nominativo che contiene:
- i campi private per nome, cognome e telefono
- un costruttore per passare i tre dati
- i metodi getter per leggere le proprietà

Una classe ElencoTelefonico che contiene:
- un campo di tipo ArrayList<Nominativo>
- un costruttore per inizializzare l'oggetto
- un metodo public void loadFile (String filename) throws IOException per caricare il file di dati
- un metodo public Nominativo findNominativo (String nome, String cognome) per cercare un oggetto Nominativo dal nome/cognome

Una classe Telefonata che contiene:
- i campi private per numero chiamante/chiamato e durata
- un costruttore per passare i tre dati
- i metodi getter per leggere le proprietà

Una classe LogTelefonate che contiene:
- un campo di tipo ArrayList<Telefonata>
- un costruttore per inizializzare l'oggetto
- un metodo public void loadFile (String filename) throws IOException per caricare il file di dati
- un metodo public int totaleConversazione (Nominativo a, Nominativo b) per calcolare il totale della conversazione tra 2 nominativi

[stregone_giallo_rosso]

Non potresti farmi un esempio di questo:
- un metodo public Nominativo findNominativo (String nome, String cognome) per cercare un oggetto Nominativo dal nome/cognome

Queste è la classe Tel:

import java.util.Scanner;
class Tel {
public Tel (String numc, String numr, int sec){
this.numc = numc;
this.numr = numr;
this.sec = sec;
}
public String getNumc(){
return numc;
}
public String getNumr(){
return numr;
}
public int getSec(){
return sec;
}
public static Tel read1(Scanner in) throws Exception {

if (!in.hasNext()) return null;
return new Tel(in.next(), in.next(), in.nextInt());
}
public String toString1(){
return " "+ numc + numr + sec + "";
}


private String numc, numr ;
private int sec;
}

E questa è la classe Ele:

import java.util.Scanner;
class Ele {
public Ele (String nome, String cognome, String num){
this.nome = nome;
this.cognome = cognome;
this.num = num;
}
public String getNome(){
return nome;
}
public String getCognome(){
return cognome;
}
public String getNum(){
return num;
}
public static Ele read(Scanner in) throws Exception {
String nome , cognome , num;
if (!in.hasNext()) return null;
nome = in.next();
cognome = in.next();
num = in.next();
return new Ele(nome, cognome, num);
}
public String toString(){
return " "+ nome + cognome + num + "";
}


private String nome, cognome, num;
}

[andbin]

Non potresti farmi un esempio di questo:
- un metodo public Nominativo findNominativo (String nome, String cognome) per cercare un oggetto Nominativo dal nome/cognomePosso farti l'esempio di come l'avrei pensato io. Ma come vedrai è davvero molto semplice!
public class ElencoTelefonico
{
private ArrayList<Nominativo> arrElenco;

public ElencoTelefonico ()
{
arrElenco = new ArrayList<Nominativo> ();
}

public void loadFile (String filename)
throws IOException
{
// .... caricamento file dati e riempimento arrElenco ....
}

public Nominativo findNominativo (String nome, String cognome)
{
Nominativo nominativo = null;

for (Nominativo n : arrElenco)
{
if (n.getCognome ().equals (cognome) && n.getNome ().equals (nome))
{
nominativo = n;
break;
}
}

return nominativo;
}
}

[stregone_giallo_rosso]

e come si fa ad ordinarli per cognome??? ho messo il metodo Collections.sort(arreylist) ma mi da errore come mai???
poi per fare il metodo che dal nome e cognome di 2 persone calcoli i min di conversazione come si fa, cosi è per una persona

[andbin]

e come si fa ad ordinarli per cognome??? ho messo il metodo Collections.sort(arreylist) ma mi da errore come mai???Ci sono 2 metodi sort() in Collections. Uno si basa su un Comparable (implicitamente) e l'altro su un Comparator (esplicitamente).

Comparable è una interfaccia che va implementata nell'oggetto da comparare. L'ordine definito da questa comparazione è detto "natural ordering" (l'ordine naturale) e chiaramente ne puoi avere uno solo.
Comparator è una interfaccia che puoi implementare in N classi diverse (separate dall'oggetto da comparare) e il cui scopo è di poter definire comparazioni differenti per ottenere ordinamenti diversi.

A te la scelta se usare un Comparable o un Comparator.

poi per fare il metodo che dal nome e cognome di 2 persone calcoli i min di conversazione come si fa, cosi è per una personaPer il calcolo della durata totale di conversazione si fa una cosa davvero molto simile a quella che ho scritto io nel metodo findNominativo.

Al metodo (chiamiamolo come avevo già detto totaleConversazione), passi 2 oggetti che rappresentano il nominativo (secondo i nomi che ho dato io è la classe Nominativo). Quindi fai un ciclo for-each per scansionare l'array delle telefonate. Per ogni elemento prendi il numero di telefono e lo confronti con quello dei due nominativi. Il test è doppio perché devi testare i due casi in cui un nominativo è il chiamante o il chiamato.
Ad ogni match, sommi la durata.

[stregone_giallo_rosso]

ho provato a implementare con l'interfaccia Comparable ma non va lo stesso :
public int compareTo(String cognome)
return n.getCognome .compareTo(cognome)
puoi scrivermi il codice

[andbin]

ho provato a implementare con l'interfaccia Comparable ma non va lo stesso :
public int compareTo(String cognome)
return n.getCognome .compareTo(cognome)
puoi scrivermi il codiceIo posso farti un esempietto per una classe Automobile:
class Automobile implements Comparable<Automobile>
{
private String marca;
private String modello;

// .... costruttore e metodi getMarca() e getModello() ....

public int compareTo (Automobile automobile)
{
int r = getMarca ().compareTo (automobile.getMarca ());

if (r == 0)
r = getModello ().compareTo (automobile.getModello ());

return r;
}
}L'ordinamento avviene per marca/modello

Dopotutto è meglio se il codice impari a scriverlo tu. Se dovessi fare io esercizi come quello che stai facendo tu, come si dice, vivrei di "rendita" per non so quanto!

EDIT: se usare in compareTo i getter o direttamente i fields, è più che altro una scelta di "design". Nulla vieta di fare direttamente:

int r = marca.compareTo (automobile.marca);
....

[stregone_giallo_rosso]

Io posso farti un esempietto per una classe Automobile:
class Automobile implements Comparable<Automobile>
{
private String marca;
private String modello;

// .... costruttore e metodi getMarca() e getModello() ....

public int compareTo (Automobile automobile)
{
int r = getMarca ().compareTo (automobile.getMarca ());

if (r == 0)
r = getModello ().compareTo (automobile.getModello ());

return r;
}
}L'ordinamento avviene per marca/modello

Dopotutto è meglio se il codice impari a scriverlo tu. Se dovessi fare io esercizi come quello che stai facendo tu, come si dice, vivrei di "rendita" per non so quanto!
Quindi per ordinare nome e cognome verrebbe cosi:

CODE]class Persona implements Comparable<Persona>
{
private String nome;
private String cognome;

metodi getName() e getSurname() ....

public int compareTo (Persona p)
{
int r = getSurname ().compareTo (p.getSurname ());

if (r == 0)
r = getNAme ().compareTo (p.getName ());

return r;
}
ArrayList <Persona> a = new ArrayList<Persona>();
Collections.sort(a);
}[/CODE]

[andbin]

Quindi per ordinare nome e cognome verrebbe cosi:Sì, esatto (rileggi sopra, se non l'hai fatto, la nota circa l'uso dei getter o meno).

E per completare la questione della comparazione, vediamo un Comparator per la classe Automobile:

class ModelloAutomobileComparator implements Comparator<Automobile>
{
public int compare (Automobile a, Automobile b)
{
return a.getModello ().compareTo (b.getModello ());
}
}
Da usare poi con:

Collections.sort (arr, new ModelloAutomobileComparator ());

Essendo generalmente i Comparator in classi separate, ne puoi fare quanti ne vuoi in base agli ordinamenti particolari da fare.

[stregone_giallo_rosso]

Grazie!