[Java] Comparable naar int

[Verwijderd]

Goedenavond,

Ik ben in Java aan het programmeren en wil graag van een Comparable[] de minimale en maximale waarde achterhalen. Aangezien dit voor zover ik weet niet mogelijk is met een al bestaande methode wil ik hiervoor zelf een methode schrijven.

Ik heb nu het volgende:

private Integer getMin(Comparable[] list)
{
int minValue = list[0];
for(int i = 0; i < list.length; i++)
{
//telkens waarden vergelijken
}
return minValue;
}

Ik krijg nu echter de melding: Cannot convert from Comparable to int. Nu is mijn vraag hoe kan ik het handigst en het snelst de maximale en minimale waarde berekenen van een Comparable array?

Alvast bedankt!

[momania]

Verwijderd schreef op zaterdag 18 oktober 2008 @ 18:13:
Aangezien dit voor zover ik weet niet mogelijk is met een al bestaande methode wil ik hiervoor zelf een methode schrijven.

Hint: Collection Framework en dan bv... TreeSet

Ik krijg nu echter de melding: Cannot convert from Comparable to int. Nu is mijn vraag hoe kan ik het handigst en het snelst de maximale en minimale waarde berekenen van een Comparable array?

De inhoud van je array is Comparable objecten... geen primitive int

[Koppensneller]

Kun je dan niet gewoon je minValue variabele van het type Comparable maken? Nu heb je een functie geschreven die met Comparable objecten werkt, maar je weet dus eigenlijk al dat er ints ingevoerd gaan worden? Heb je dan de invoer van je functie niet onnodig generiek gemaakt?

Ofwel: Invoer en uitvoer beide int, of invoer en uitvoer beide Comparable, maar dit is een onnodig generiek, halfbakken oplossing...

[Verwijderd]

momania schreef op zaterdag 18 oktober 2008 @ 18:19:
[...]

Hint: Collection Framework en dan bv... TreeSet

[...]

De inhoud van je array is Comparable objecten... geen primitive int

Ik ga hier naar kijken, bedankt. Maar wat Koppensneller zegt is natuurlijk ook gewoon een oplossing, niet scherp van me!

[Verwijderd]

De getMin() methode werkt nu wel. Hij geeft een Comparable terug, maar wat nu loop ik weer ergens anders tegenaan. Ik wil namelijk de minimale waarde door een int variabele, maar dat gaat niet lukken. Iemand een oplossing?

[Robtimus]

Wat is de int waarde van een Comparable? Zijn hashCode? De return waarde van x.compareTo(y) waarbij x het "minimum" is en y het "maximum"? Of waarbij y de op 1 na "kleinste" is?

[analog_]

Ben ik helemaal wazig of zoek je het volgende :
function Integer setMin(List<Integer> lalaland)
{
for (Integer : lalaland)
{
// do something
}
}

Als je toch enkel integers gaat gebruiken met setMin waarom zou je uberhaupt dan hem aanspreken via een interface ipv. het echte type. Java - Integer - docu

[Robtimus]

Mr.SiS schreef op zaterdag 18 oktober 2008 @ 19:19:
Ben ik helemaal wazig of zoek je het volgende :
function Integer setMin(List<Integer> lalaland)
{
for (Integer : lalaland)
{
// do something
}
}

Als je toch enkel integers gaat gebruiken met setMin waarom zou je uberhaupt dan hem aanspreken via een interface ipv. het echte type. Java - Integer - docu

Mee eens.

Als je Java 5 of hoger gebruikt kun je het zelfs heel gemakkelijk doen met generics:

Java:

public <T extends Comparable<T>> T getMin(T[] list)
{
    // jouw code hier, maar gebruik T ipv Comparable.
}

Dit kan je dan als volgt aanroepen:

Java:

Integer[] intList = ...;
Integer intMin = getMin(intList);

String[] stringList = ...;
String stringMin = getMin(stringList);

[YopY]

De Comparable interface wordt in Java gebruikt om een lijst te sorteren, dus lijkt mij dat je je lijst van Comparables laat sorteren en er dan het eerste en laatste element uit haalt.

[code]
List<Comparable> eenlijst;
Collections.sort(eenlijst);
eenlijst.get(0); // 0-e element, laagste waarde in de lijst
eenlijst.get(eenlijst.length() -1); // laatste element, hoogste.
[code]

[Verwijderd]

Ik ben met jullie tips aan de slag gegaan en ben tot het volgende gekomen:

code:

public <T extends Comparable<T>> T getMin(T[] list) 
    { 
        T minValue = list[0];
        for(int i = 0; i < list.length-1; i++)
        {
            if(list[i+1].compareTo(list[i]) < 0)
            {
                minValue = list[i+1];
            }
        }
        return minValue; 
    }

Alleen heb ik hier nog niet veel aan omdat ik een Comparable array heb en ik daarvan de minimale waarde van wil weten. Wat ik dan doe is:

code:

Comparable minValue = getMin(lst);

maar die minValue moet van het type int zijn omdat ik er anders niet mee kan delen voor zo ver ik weet.

[Koppensneller]

Als je weet dat het een int is, kun je dan niet zoiets fabriceren?

Java:

Comparable minValue = getMinI(lst);
int val = (int)minValue;
//Daarna je arithmische operaties

[momania]

Verwijderd schreef op zondag 19 oktober 2008 @ 12:18:

maar die minValue moet van het type int zijn omdat ik er anders niet mee kan delen voor zo ver ik weet.

Volgens mij doe je hier onnodig moeilijk door een array van Integer objecten te behandelen als een array van Comparable objecten en je eigen min/max functies te maken. En daarna probeer je een Comparable object als int referentie te gebruiken, wat dus 2 verschillende dingen zijn.

Is de input van je methode altijd een lijst/array met Integer objecten? Zo ja, gebruik dan gewoon een List of Set ipv een array

Goed startpunt: http://java.sun.com/docs/...al/collections/index.html

[Verwijderd]

KoppenSneller schreef op zondag 19 oktober 2008 @ 12:26:
Als je weet dat het een int is, kun je dan niet zoiets fabriceren?

Java:

Comparable minValue = getMinI(lst);
int val = (int)minValue;
//Daarna je arithmische operaties

Dat gaat niet lukken want dan krijg ik de melding "Cannot cast from Comparable to int"

@Momania: Er zitten niet alleen integers in, alle waarden die erin zitten voldoen aan de Comparable interface, ik heb er ook eigen gemaakte types inzitten. Echter gebruik ik voor waar ik nu mee bezig ben alleen Integers. Maar de Comparable[] moet wel blijven.

[momania]

Verwijderd schreef op zondag 19 oktober 2008 @ 12:42:
[...]
alle waarden die erin zitten voldoen aan de Comparable interface, ik heb er ook eigen gemaakte types inzitten.

Volgens mij heb je daar al het begin van een slecht design, maar goed.
Trek dan in alle Integers eruit en stop die in een aparte List/Set en dan heb je met 2 calls de min en max eruit.

[Verwijderd]

momania schreef op zondag 19 oktober 2008 @ 12:56:
[...]

Volgens mij heb je daar al het begin van een slecht design, maar goed.
Trek dan in alle Integers eruit en stop die in een aparte List/Set en dan heb je met 2 calls de min en max eruit.

Naja heb het design zelf niet bedacht. Ik denk dat ik dan maar gewoon gebruik ga maken van Integer[] ipv Comparable[] als ik er niet meer uit kom. Tot slot: Is er geen mogelijkheid dat ik kan kijken of het object in de Comparable[] een Integer is en zo ja wat dan de waarde van de Integer is op bijv list[2] ?

[Confusion]

Verwijderd schreef op zondag 19 oktober 2008 @ 12:42:
Dat gaat niet lukken want dan krijg ik de melding "Cannot cast from Comparable to int"

Waarom verwacht je dat iedere Comparable naar een int gecast kan worden?

Maar de Comparable[] moet wel blijven.

En telkens als je er een nieuwe variant bij verzint, dan ga je de compareTo methoden van alle andere objecten aanpassen zodat ze ook met dat niet object om kunnen gaan? Dat is een Heel Slecht Plan, want volstrekt niet onderhoudbaar. Andere klassen moeten aanpassen op het moment dat je een nieuwe variant van bestaande klassen toevoegt is een duidelijke code smell.

Dat iets Comparable implementeert betekent niet dat het zomaar vergeleken kan worden met instantie van andere klassen die ook Comparable implementeren. Als een klasse Comparable implementeert, dan betekent het alleen dat instanties van die klasse met elkaar vergeleken kunnen worden.

Als al jouw objecten met elkaar vergeleken kunnen worden, dan gebeurt dat waarschijnlijk op basis van een getal dat aan die objecten gevraagd kan worden. Wat jij dan wilt is niet dat alle objecten de Comparable interface implementeren, maar dat ze allemaal bijvoorbeeld de HasNumericRepresentation interface implementeren, met de methode getNumericRepresentation(). Vervolgens schrijf je een Comparator<HasNumericRepresentation> die ervoor zorgt dat ze geordend worden naar die numerieke representatie. Dan hoeft iedere klasse die je ook wilt kunnen sorteren alleen maar de getNumericRepresentation() te implementeren en hoeft er aan de andere klassen niets te wijzigen. De minimum waarde is vervolgens het eerste element in een gesorteerde lijst.

Qua performance: een hele lijst sorteren is waarschijnlijk niet relevant veel intensiever dan los de minimale waarde bepalen, als je de lijst toch al bij moet houden en kunt zorgen dat nieuw toegevoegde elementen automagisch op de goede plaats ingevoegd worden door eenTreeSet met voornoemde Comparator te gebruiken.

[ Voor 32% gewijzigd door Confusion op 19-10-2008 13:31 ]

[Verwijderd]

Waarom gebruik je niet gewoon Collections.min(Collection<? extends T> collection)?

code:

import java.util.*;

class Item implements Comparable<Item>{
    
    private static int counter = 0;
    public final int id = counter++;
    
    public int compareTo(Item item){
        return id < item.id? -1 : (id>item.id? 1: 0);
        }
    
    public String toString(){
        return Integer.toString(id);
        }
    }

public class MinTest{

    public static void main(String [] args){
        
        List<Item> list= new ArrayList<Item>();
        for (int i = 0; i < 10; i++)
            list.add(new Item());
        Item smallest = Collections.min(list);
        System.out.println(smallest);
        Item greatest = Collections.max(list);
        System.out.println(greatest);       

    }
}