[JAVA]Implementare Comparator

[3vi]

Allora, mettiamo che io abbia un metodo così definito:

public static <E> void pincoPallo(E[] a, Comparator<E> c) {

......

}

inserito in una classe Prova.java insieme al main.

Ora, io nel main devo testare il metodo pincoPallo con un array di double, ma non so cosa passare come secondo parametro del metodo...

ho provato con:

import java.util.Comparator;

public class Prova implements Comparator

dovrei scrivere il metodo compare(Object a, Object b) definito nell'interfaccia Comparator, ma se io ho un array di double, come fo? :stordita:

Insomma, ho un pò di confusione, c'è qualcuno che mi puà dare una dritta? :stordita:

Grazie

[banryu79]

A occhio il metodo "pincoPallo" prende in ingresso un array di oggetti di qualsiasi tipo (il tipo è parametrizzato) e un Comparator definito per oggetti dello stesso tipo.

Se ne deduce che pincoPallo al suo interno utilizza il Comparator su ogni oggetto dell'array passatogli, probabilmente per trovare i primi due oggetti che sono identici? Questo mi viene da pensare dato che il metodo torna un oggetto dello stesso tipo parametrizzato di quelli passati in ingresso.

Il compito di un Comparator, definito per un tipo ben preciso di ogetti, sarebbe quello di confrontare due oggetti dello stesso tipo per vedere se sono identici o meno (in cosa consiste l'identità tra due oggetti dello stesso tipo lo decide chi implementa il tipo).

Nel tuo caso che passi un array di double (forse Double?) il confronto lo farei in base al valore: se due oggetti passati in ingresso al metodo compare() hanno lo stesso valore torno true, altrimenti false.


@EDIT:
Scusa mi correggo: hai ragione, Comparator serve per distinguere quale tra i due oggetti che compara è il "maggiore" e quale il "minore", non per verificare la loro euguaglianza (mi son confuso con equals(), sorry).

[3vi]

A occhio il metodo "pincoPallo" prende in ingresso un array di oggetti di qualsiasi tipo (il tipo è parametrizzato) e un Comparator definito per oggetti dello stesso tipo.

Se ne deduce che pincoPallo al suo interno utilizza il Comparator su ogni oggetto dell'array passatogli, probabilmente per trovare i primi due oggetti che sono identici? Questo mi viene da pensare dato che il metodo torna un oggetto dello stesso tipo parametrizzato di quelli passati in ingresso.

Il compito di un Comparator, definito per un tipo ben preciso di ogetti, sarebbe quello di confrontare due oggetti dello stesso tipo per vedere se sono identici o meno (in cosa consiste l'identità tra due oggetti dello stesso tipo lo decide chi implementa il tipo).

Nel tuo caso che passi un array di double (forse Double?) il confronto lo farei in base al valore: se due oggetti passati in ingresso al metodo compare() hanno lo stesso valore torno true, altrimenti false.

pincoPallo è un metodo per ordinare un array di qualsiasi tipo. Quello che io mi chiedo è: essendo definito pincoPallo genericamente, cosa devo fare perchè io possa ordinare il mio array di Double?

dovrei fare una cosa tipo DoubleComparator c = new DoubleComparator() e poi pincoPallo(a[], c) dove a è un array di Double, però non riesco a capire come fare questo passaggio :asd:

[!fazz]

pincoPallo è un metodo per ordinare un array di qualsiasi tipo. Quello che io mi chiedo è: essendo definito pincoPallo genericamente, cosa devo fare perchè io possa ordinare il mio array di Double?

dovrei fare una cosa tipo DoubleComparator c = new DoubleComparator() e poi pincoPallo(a[], c) dove a è un array di Double, però non riesco a capire come fare questo passaggio :asd:

ma se devi ordinare un array di double ti basta usare una collection

altrimenti se devi ordinare array di dati di un tipo definito da te devi fare un override del metodo Comparator

poi dopo ti basta usare una collection e usare il metodo sort della collection

o almeno così mi pare non uso java da anni

[banryu79]

Comparator (http://java.sun.com/javase/6/docs/api/java/util/Comparator.html) è un'interfaccia; dovresti dunque scriverti un'implementazione per il tipo che ti interessa.

Siccome devi comparare double dovresti scrivere un Comparator per il tipo specifico: ma dato che non puoi usare un tipo primitivo come tipo parametrico devi usare il tipo Double.

class DoubleComparator<Double> implements Comparator
{
// implementazione interfaccia java.util.Comparator
}


poi puoi usarlo così:

// mi creo un array di double
double[] primitives = new double[5];
for(int i = 0; i < primitives.length; i++)
primitives[i] = i+1;

// chiamo pincoPallo, passandogli l'array e un'istanza del Comparator adatto
Double result = pincoPallo(primitives, new DoubleComparator());


Spero di non aver commesso erroracci :p


@fazz!:
Giuste osservazioni le tue, ma credo che l'utente debba svolgere un esercizio che gli impone di fare così, probabilmente ha lo scopo di fargli implementare un Comparator con tipo parametrizzato, e deve gestire il fatto che il tipo primitivoo double non può essere usato per tipizzare l'implementazione del Comparator, ma deve usare appunto la classe Double.

P.S: occhio che mi sono accorto adesso che il metodo pincoPallo vuole un E[] come array quindi devi sostituire l'array di double con un array di Double[].

[!fazz]

Comparator (http://java.sun.com/javase/6/docs/api/java/util/Comparator.html) è un'interfaccia; dovresti dunque scriverti un'implementazione per il tipo che ti interessa.

Siccome devi comparare double dovresti scrivere un Comparator per il tipo specifico: ma dato che non puoi usare un tipo primitivo come tipo parametrico devi usare il tipo Double.

class DoubleComparator<Double> implements Comparator
{
// implementazione interfaccia java.util.Comparator
}


poi puoi usarlo così:

double[] primitives = new double[5];
for(int i = 0; i < primitives.length; i++)
primitives[i] = i+1;

Double result = pincoPallo(primitives, new DoubleComparator());


Spero di non aver commesso erroracci :p


@fazz!:
Giuste osservazioni le tue, ma credo che l'utente debba svolgere un esercizio che gli impone di fare così, probabilmente ha lo scopo di fargli implementare un Comparator con tipo parametrizzato, e deve gestire il fatto che il tipo primitivoo double non può essere usato per tipizzare l'implementazione del Comparator, ma deve usare appunto la classe Double.

ah ecco svelato l'arcano, mi pareva troppo semplice :D :D :D

[3vi]

ok, provo a riassumere :asd:

Creo l'interfaccia DoubleComparator che implementa Comparator;

Nella mia classe, dov'è definito il metodo che riceve un array generico, estendo la classe DoubleComparator, creo l'oggetto cm con new DoubleComparator() e lo passo al metodo pincoPallo l'array di Double e l'oggetto cm...così dovrebbe funzionare? :stordita: funziona anche se comunque il metodo dovrebbe ricevere un E?

Grazie :ave:

[3vi]

Ho provato, ed il compilatore mi segnala questo:

<E>pincoPallo(E[], Comparator<E>) in Prova cannot be applied to (java.lang.Double[], DoubleComparator

Ora, come io ho sempre pensato, è impossibile fare un metodo generico e poi passare un array di Double oppure ho sbagliato io qualcosa?

[Don[ITA]]

Avrai sbagliato qualcosa a livello di codice :)

Guarda qui:

import java.util.Comparator;

public class Comparatori {

static Double[] arrayDouble = null;
static Integer[] arrayInteger = null;

public static void main(String[] args){

arrayDouble = new Double[5];
arrayInteger = new Integer[5];

//riempio arrayDouble con numeri casuali
for(int i = 0; i < arrayDouble.length; i++){
arrayDouble[i] = Math.random() * 10;
}

//e faccio lo stesso con arrayInteger
for(int i = 0; i < arrayInteger.length; i++){
arrayInteger[i] = (int)(Math.random() * 10);
}

sort(arrayDouble, new DoubleComparator());
print(arrayDouble);

System.out.println("----------------");

sort(arrayInteger, new IntegerComparator());
print(arrayInteger);
}

public static <E> void sort(E[] array, Comparator<E> comp){
//un semplice BubbleSort
int lunghezza = array.length;
for(int j = 1; j < lunghezza; j++){
for(int i = 0; i < lunghezza - j; i++){
if(comp.compare(array[i], array[i+1]) > 0){
E temp = array[i];
array[i] = array[i+1];
array[i+1] = temp;
}
}
}
}

public static <E> void print(E[] array){
for(E element : array){
System.out.println(element);
}
}

private static class DoubleComparator implements Comparator<Double> {
//ritorna un numero positive se d1 > d2, un numero negativo se d1 > d2, zero se sono uguali
public int compare(Double d1, Double d2){
return (int)(d1-d2);
}
}

private static class IntegerComparator implements Comparator<Integer> {
//come prima, solo che stavolta li ordinerà al contrario
public int compare(Integer i1, Integer i2){
return i2-i1;
}
}
}


Probabilmente avrai fatto qualco casino con gli static :)

Ciauz

[3vi]

ora provo :ave: