[Java] Vector / innerclass probs

[Verwijderd]

Ik ben aan het proberen Java te leren, maar heb wat problemen met Vectoren. Uit de bestaande documentatie word ik ook niet echt wijzer... wat ik zoek is ff een goed voorbeeld (of een schop in de goede richting)..

Nu mijn problemen

Ik heb een innerclass met een toString() methode. Een berg instanties daarvan stop ik in een Vector. Vervolgens probeer ik de indexOf() methode van Vector te gebruiken om te kijken of een String hierin voorkomt (oftewel gelijk is aan mijn object z'n toString(). Maar om een of andere reden krijg ik altijd -1 terug...

mijn code:

code:

static class Keyword{
    String keyword  = "";
    int amount  = 1;

    Keyword(String kw){
        this.keyword = kw;
    }
        public String toString(){
        return this.keyword;
    }
}

[...]

int kwIndex = list.indexOf(ele);
if(kwIndex<0) list.addElement(new Keyword(ele));
else{
    Keyword kw = (Keyword)list.elementAt(kwIndex);
    kw.amount++;
}

In de else komtie dus nooit, terwijl in mn vorige versie met gewoon String alles wel goed werkte. Om een of andere reden werkt die indexOf() niet goed met de toString() van de objecten die derin zitten

Ok.. tweede probleem Geeeeeeen flauw idee hoe ik dit efficient kan aanpakken, maar ik wil vervolgens die Vector gaan sorteren op "amount" dus...

NB: Ik zoek geen uitgewerkte scripts, maar voorbeeldjes/hints in de goede richting, zodat ik weer wat verder kom in m'n Java leerproces Bij voorbaat dank!

[.oisyn]

je codestyle laat nogal wat te wensen over (is vrij onleesbaar)

hier even een aangepaste versie:

code:

static class Keyword
{
    String keyword  = "";
    int amount      = 1;

    Keyword (String kw)
    {
      this.keyword = kw;
    }
        
    public String toString()
    {
      return this.keyword;
    }
}

[...]

int kwIndex = list.indexOf (ele);
if (kwIndex < 0)
    list.addElement(new Keyword(ele));
else
{
    Keyword kw = (Keyword)list.elementAt(kwIndex);
    kw.amount++;
}

overigens is die this.keyword niet echt nodig, je kunt ook wel gewoon keyword doen (gebruik this. als je een lokale variabele hebt met dezelfde naam, en je wilt de class member hebben ipv die lokale var)

volgens mij moet je de equals-methode implementeren, zodat Vector de instanties met elkaar kan vergelijken. Het werkt namelijk met objecten, en niet met strings, en zal dus ook niet te toString-methode gaan gebruiken

[roelio]

Op maandag 06 mei 2002 16:08 schreef .oisyn het volgende:
je codestyle laat nogal wat te wensen over (is vrij onleesbaar)

op de { op een nieuwe regel na die jij gebruikt valt dat toch best mee ....

[.oisyn]

ik doelde meer op het verkeerde inspringen, en de code direct achter de if ()

[Alarmnummer]

Op maandag 06 mei 2002 16:12 schreef .oisyn het volgende:
ik doelde meer op het verkeerde inspringen, en de code direct achter de if ()

Ik denk dat hij ruzie heeft met die prut editor van GoT (ook vaak gedonder hiero).

[Verwijderd]

Sorry mijn coding style laat niderdaad nog al eens te wensen over

Ik probeer dus nu de list die ik aanmaak anders aan te maken die equals methode te veranderen, maar dat wil niet echt lukken:

code:

Vector list = new Vector() {
    public boolean equals(Object o) {
        return this.toString().equals(o);
    }
};

Hier klopt waarschijnlijk geen zak van, maar waar haal ik de "huidige" waarde anders vandaan om te vergelijken met wat ik binnenkrijg? Of zit ik helemaal te prutsen?

[Glimi]

code:

int indexOf(Object elem)

Dit vermeldt de API. Dit betekend dus dat Vector Objecten opeet en met indexOf hij controleerd of het ene object gelijk is aan het andere, niet of de state gelijk is (de inhoud van de string)
Concreet vergelijkt hij dus geheugenadressen

[.oisyn]

Op maandag 06 mei 2002 16:21 schreef Fred_Emmer het volgende:
Sorry mijn coding style laat niderdaad nog al eens te wensen over

Ik probeer dus nu de list die ik aanmaak anders aan te maken die equals methode te veranderen, maar dat wil niet echt lukken:

code:

Vector list = new Vector() {
    public boolean equals(Object o) {
        return this.toString().equals(o);
    }
};

Hier klopt waarschijnlijk geen zak van, maar waar haal ik de "huidige" waarde anders vandaan om te vergelijken met wat ik binnenkrijg? Of zit ik helemaal te prutsen?

je moet de equals methode van Keyword implementeren

dus in je class Keyword:

code:

public boolean equals (Object o)
{
    if (!o instanceof Keyword)
      return false;

    Keyword k = (Keyword)o;

    return keyword.equals (k.keyword) && amount == (k.amount);
}

[Alarmnummer]

Op maandag 06 mei 2002 16:21 schreef Fred_Emmer het volgende:
Sorry mijn coding style laat niderdaad nog al eens te wensen over

Ik probeer dus nu de list die ik aanmaak anders aan te maken die equals methode te veranderen, maar dat wil niet echt lukken:

code:

Vector list = new Vector() {
    public boolean equals(Object o) {
        return this.toString().equals(o);
    }
};

Hier klopt waarschijnlijk geen zak van, maar waar haal ik de "huidige" waarde anders vandaan om te vergelijken met wat ik binnenkrijg? Of zit ik helemaal te prutsen?

Je zit inderdaad helemaal te prusten. Als je iets wilt zoeken op basis van een string kan je veel beter werken met een hashmap. Dit is echt geknoei. Snap je hier wel goed wat je zegt? de toString van een list te overriden om keywords erin te vinden? Ik denk dat je eerst wat meer moet richten op de basis kennis van java dan je met dit soort 'geavanceerdere' *ahum* dingen bezig te houden.

[Alarmnummer]

Op maandag 06 mei 2002 16:32 schreef .oisyn het volgende:
een matige implementatie van de equals.

code:

public boolean equals (Object o)
{
   if(item == null)
    return false;

   if(item == this)
    return true;    

   if(o.hashCode()!=hashCode())//kan je leuke performance winst mee halen als je hashcodes gaat cachen.
    return false; 
   
if (!(o instanceof Keyword))
      return false;

    Keyword k = (Keyword)o;

    return keyword.equals (k.keyword) && amount == (k.amount);
}

En hier kan hij ook niet mee doen wat hij wil omdat hij een Item uit een lijst wil ophalen op basis van een String.

boerenkinkel methode

code:

Keyword find(String text){
   Assert.assertNotNull("text",text);
    
   Keyword result = null;
   int size = _keywordList.size();
   int index = 0;
   while(index<size){
    Keyword temp = (Keyword)_keywordList.get(k);
    if(temp.getText().equals(text)){
       index = size;
       result = temp;
    } else{
        index++;
    }
   }

   return result;
}

slimmere methode:

code:

class KeywordMap{
   private Hashmap _hashMap = new Hashmap();
   
   public void put(Keyword keyword){
     Assert.assertNotNull("keyword",keyword);
     _hashmap.put(keyword.getText(),keyword); 
   }
  
   public void get(String text){
    Assert.assertNotNull("text",text);
    return (Keyword)_hashmap.get(text);
   }
}

[Verwijderd]

Op maandag 06 mei 2002 16:34 schreef Alarmnummer het volgende:

[..]

Je zit inderdaad helemaal te prusten. Als je iets wilt zoeken op basis van een string kan je veel beter werken met een hashmap. Dit is echt geknoei. Snap je hier wel goed wat je zegt? de toString van een list te overriden om keywords erin te vinden? Ik denk dat je eerst wat meer moet richten op de basis kennis van java dan je met dit soort 'geavanceerdere' *ahum* dingen bezig te houden.

snap m nu.. zat ff verkeerd om te denken

.oisyn thanks... dat moet lukken...

Alarmnummer: ik wil trouwens niet alleen Strings onthouden, maar ook een amount van hoevaak ik dat woord gevonden heb zeg maar.. vandaar dat ik een simpele innerclass wou gaan implementeren, maar toen liep ik tegen deze problemen op...

edit:
Maaruh.. als ik equals() in Keyword implementeer, dan schiet ik nog niks op, want ik doe indexOf(String), niet Keyword Als ik de JavaDoc erop nalees zie ik dat ie elem.equals(elementData[k])...

Als ik logisch nadenk zou ik dus de equals van String aan moeten passen, maar dat is dus prusten... ?

[Alarmnummer]

Op maandag 06 mei 2002 16:40 schreef Fred_Emmer het volgende:

[..]

snap m nu.. zat ff verkeerd om te denken

.oisyn thanks... dat moet lukken...

Alarmnummer: ik wil trouwens niet alleen Strings onthouden, maar ook een amount van hoevaak ik dat woord gevonden heb zeg maar.. vandaar dat ik een simpele innerclass wou gaan implementeren, maar toen liep ik tegen deze problemen op...

edit:
Maaruh.. als ik equals() in Keyword implementeer, dan schiet ik nog niks op, want ik doe indexOf(String), niet Keyword Als ik de JavaDoc erop nalees zie ik dat ie elem.equals(elementData[k])...

Als ik logisch nadenk zou ik dus de equals van String aan moeten passen, maar dat is dus prusten... ?

Lees nog even goed wat ik hierboven heb gedaan. En een equals van een string aanpassen zal je niet lukken:
a) is prutsen
b) string is final.

[.oisyn]

[quote]
Op maandag 06 mei 2002 16:37 schreef Alarmnummer het volgende:

[..]

code:

public boolean equals (Object o)
{
   if(item == null)
    return false;

   if(item == this)
    return true;    

   if(o.hashCode()!=hashCode
    return false; 
   
if (!(o instanceof Keyword))
      return false;

    Keyword k = (Keyword)o;

    return keyword.equals (k.keyword) && amount == (k.amount);
}

het was maar eventjes snel getiept
maar moet je de hashCode () nou niet implementeren? (daar had ik ooit eens last van toen ik een eigen object in een hashtable moest zetten... het werkte alleen als ik mijn eigen hashCode methode implementeerde)

En hier kan hij ook niet mee doen wat hij wil omdat hij een Item uit een lijst wil ophalen op basis van een String.

tuurlijk wel, hij kan toch ook kijken of het een string is waarmee ie moet controleren?
zo zeg maar:

code:

if (o instanceof String)
{
    return keyword.equals (((String)o).equals ());
}

[Alarmnummer]

if override equals then overidehascode zoek maar op op sun docs. Ik doe het ook niet overal hoor want niet ieder element komt in een hashmap te staan. Eigelijk zou je dan de hashcode functie moeten overriden en een UnsupportedOperation moeten opwerpen als je het echt veilig wil doen. Of je Stuurt per definitie altijd een 0 terug. Dit is niet in strijd maar een ongelovelijke slechte verdeling over je buckets.

[Verwijderd]

En hier kan hij ook niet mee doen wat hij wil omdat hij een Item uit een lijst wil ophalen op basis van een String.

Nee ik wil de index opvragen van het Keyword object met als keyword eigenschap de String die ik opgeef Klinkt simpel en is het voor jullie waarshijnlijk ook

[Alarmnummer]

Op maandag 06 mei 2002 16:52 schreef Fred_Emmer het volgende:

[..]

Nee ik wil de index opvragen van het Keyword object met als keyword eigenschap de String die ik opgeef

Er staat hier genoeg info in dit topic om je vraag te beantwoorden. Kijk nog maar eens goed naar mijn boerenkinkel methode.

[Verwijderd]

Op maandag 06 mei 2002 16:53 schreef Alarmnummer het volgende:

[..]

Er staat hier genoeg info in dit topic om je vraag te beantwoorden. Kijk nog maar eens goed naar mijn boerenkinkel methode.

Lol.. thanks, die was ik al aan eht bestuderen

Maar ik heb die Hashmap beter bestudeerd en volgens mij kan ik beter het hele gedeelte van mijn code cnoverteren naar Hashmap ipv een Vector/innerclass combo..

[Invalid]

Vectors zijn oud. Je kunt beter een van de collection klassen gebruiken.

[Verwijderd]

Op maandag 06 mei 2002 16:58 schreef InvalidTarget het volgende:
Vectors zijn oud. Je kunt beter een van de collection klassen gebruiken.

Sun:

As of the Java 2 platform v1.2, this class has been retrofitted to implement List, so that it becomes a part of Java's collection framework. Unlike the new collection implementations, Vector is synchronized.

leg uit?

[Alarmnummer]

Op maandag 06 mei 2002 16:58 schreef InvalidTarget het volgende:
Vectors zijn oud. Je kunt beter een van de collection klassen gebruiken.

Ik ben ook zeer benieuwd

(en kijk eens goed in deze overerving boom)
http://java.sun.com/j2se/1.4/docs/api/java/util/Vector.html

kortom: dom gelul

[Glimi]

Nounou, dat viel ook wel mee hoor Alarmnummer, want dit is nog te vinden op java.sun.com

Using Vector in the Collection Framework
Collections are a new feature of the Java 2 Platform, and are described in detail in various articles available on the Java Developer Connection. Collections are used to organize and operate on groups of data elements. For example, ArrayList is a replacement for Vector, and HashMap is similar to Hashtable.

The old classes such as Vector are still available, but the new ones are preferred. So an obvious question is how to convert between old and new. You might, say, have a Vector object in an application, and you want to call a method that takes an ArrayList argument. One way of doing such a conversion is illustrated by the following example:

Maar aangezien Vector nu ook een Collection is
http://developer.java.sun.com/developer/TechTips/1999/tt0216.html

Trouwens ik zal vanaaf ff m'n universele equals method posten

[Alarmnummer]

vanaf jdk1.2 is Vector al onderdeel van het Collections framework:

As of the Java 2 platform v1.2, this class has been retrofitted to implement List, so that it becomes a part of Java's collection framework. Unlike the new collection implementations, Vector is synchronized.

en ik ben wel geinteresseerd in die universele equals

[Glimi]

Hmmmz nog steeds staat vermeld bij java.sun.com (tutorials)

Problem: What collection interface behaves like the legacy Vector class? The feature I'm most interested in is a Vector's ability to grow dynamically in size.
All of the new general-purpose collection implementations have the ability to grow dynamically in size. The new interface that models Vector's behavior is List. The two general purpose implementations of List are ArrayList and LinkedList. The one whose performance properties are similar to Vector's is ArrayList. All other things being equal, ArrayList is the preferred List implementation. So, to recap, the Java 2 replacement for the legacy:
Vector a = new Vector();

is:
List a = new ArrayList();

te zien op http://java.sun.com/docs/books/tutorial/collections/problems/index.html, maar komt me een beetje oud over

Nou hier dan de beloofde universele equals() samen met een universele toString(). Grotendeels gebaseerd op Core Java, met eigen verbeteringen erbij

Hier ObjectAnalyzer ( met de universele toString en equals

code:

import java.lang.reflect.*;
import java.util.*;

class ObjectAnalyzer {
    
    /**
     * Universal toStringMehod. The reflection contains the name of the class of the object and between [ ] the values of the classvars
     * @param object the object which we will project to a String
     * @return the string that represents the object
     */
    
    public static String toString( Object object ) {
      
      //We do not accept null as input
      if( object == null ){
        assert discription!=null:"object can`t be null";
      }
      
      Class objectClass      = object.getClass();
      StringBuffer returnString   = new StringBuffer( "" );
      
      //Add the className and the classVariables to the returnString and then move to the superclass (if any)
      do {
        //Add the className
        returnString.append( objectClass.getName() );
        returnString.append( "[ " );
        
        //Get all declared variables of the class and make sure that they are accessible
        Field[] fields  = objectClass.getDeclaredFields();
        AccessibleObject.setAccessible( fields, true );
        
        //Get the name and all values of all fields
        for( int i = 0; i < fields.length; i++ ) {
            
            Field currentField     = fields[i];
            returnString.append( currentField.getName() );     //get the name of the field
            returnString.append( "=" );
            
            try{
              
              Object value    = currentField.get( object );     //get the value
              returnString.append( value.toString() );
              
            }catch( Exception e) {
              
              e.printStackTrace();
            }
            
            //Put a , between the fields
            if( i < fields.length -1 ) {
              returnString.append( ", " );
            }
        }
        
        returnString.append( " ] " );
        //Now move to the superclass of objectClass
        objectClass     = objectClass.getSuperclass();
        
      }while( objectClass != Object.class ); //keep going until the class is Object.
      
      return returnString.toString();
    }
    
    /**
     * Tests is two objects are equal by checking if all values of the classVariables are equal.
     * @param objectA the object which we compare with
     * @param objectB the object which we use to compare
     * @return true is objectA and objectB are equal
     */
    public static boolean equals( Object objectA, Object objectB ) {
      
      Class objectAClass  = objectA.getClass();
      Class objectBClass  = objectB.getClass();
      
      //if the object share the same memmoryspace then they are equal and exit
      if( objectA == objectB ){
        
        return true;
        
        // if one of the object is null, then they can't be equal
      }else if( objectA == null || objectB == null ){
        
        return false;
        
        //if the object don't share the class, then they can't be equal
      }else if( objectAClass != objectBClass ){
        
        return false;
        
      }else{
        
        do{
            
            //Get the fields and set the permission allright
            Field[] fields = objectAClass.getDeclaredFields();
            AccessibleObject.setAccessible( fields, true );
            
            for( int i = 0; i < fields.length; i++ ){
              
              Field currentField = fields[i];
              
              //if fieldvalues are not equal, then the objects are nog equal.
              try{
                
                if( !currentField.get( objectA ).equals( currentField.get(objectB) ) ){
                    
                    return false;
                }
                
              }catch( Exception e ){
                
                e.printStackTrace();
                
              }
            } //end for
            
            //Move to the superclass
            objectAClass = objectAClass.getSuperclass();
            
        }while( objectAClass != Object.class ); //stop when the superclass equals Object
        
        return true; //the objects past all tests and are totally equal
        
      } //end else
    }
}

Hier de aanroepen in je eigenklasse:

code:

class Hond {
    
    private String _arg1     = "";
    private String _arg2     = "";
    private int    _arg3     =  0;
    
    Hond( String arg1, String arg2, int arg3 ){
      
      _arg1   = arg1;
      _arg2   = arg2;
      _arg3   = arg3;
    }
    
    public String toString() {
      
      return ObjectAnalyzer.toString( this );
    }
    
    public boolean equals( Hond equals ){
      
      return ObjectAnalyzer( this, equals );
}

En het bewijs

code:

public class Blaaat {

    /** Creates new Blaaat */
    public Blaaat() {
    }

    /**
    * @param args the command line arguments
    */
    public static void main (String args[]) {
      
      Hond bla = new Hond( "Henk", "Truus", 34 );
      Hond bla2 = new Hond( "Henk", "Truus", 34 ); //equal bla
      Hond bla3 = new Hond( "Henk1", "Truus", 34 ); //!equal bla3
      System.out.println( bla.toString( ) ); 
      System.out.println( bla.equals( bla2 ) ); 
      System.out.println( bla.equals( bla3 ) ); 
    }

}