Besoin de connaître quelques notions de base de la classe LinkedList en Java

Question

package abc; 

class DependencyDataCollection 
{ 
    private int sNo; 
    private String sessionID; 
    private int noOfDependency; 
    private int noOfRejection; 
    private int totalValue; 

    /** Creates a new instance of DependencyDataCollection */ 
    public DependencyDataCollection(int sNo, String sessionID, int noOfDependency, int noOfRejection, int totalValue) 
    { 
     this.sNo = sNo; 
     this.sessionID = sessionID; 
     this.noOfDependency = noOfDependency; 
     this.noOfRejection = noOfRejection; 
     this.totalValue = totalValue; 
    } 

    public int getSNo() 
    { 
     return sNo; 
    } 

    public String getSessionID() 
    { 
     return sessionID; 
    } 

    public int getNoOfDependency() 
    { 
     return noOfDependency; 
    } 

    public int getNoOfRejection() 
    { 
     return noOfRejection; 
    } 

    public int getTotalValue() 
    { 
     return totalValue; 
    } 
} 

public class DependencyStack { 

    LinkedList lList; 

    /** Creates a new instance of DependencyStack */ 
    public DependencyStack() 
    { 
     lList = new LinkedList(); 
    } 

    public void add(int sNo, String sessionID, int noOfDependency, int noOfRejection, int totalValue) 
    { 
     lList.add(new DependencyDataCollection(sNo,sessionID,noOfDependency,noOfRejection,totalValue)); 
    } 

    public int size() 
    { 
     return lList.size(); 
    } 

    public void show() 
    { 
     for(int i=0;i<lList.size();i++) 
     { 
      DependencyDataCollection ddc = (DependencyDataCollection)lList.get(i); 
      System.out.println(ddc.getSNo()+" "+ddc.getSessionID()+" "+ddc.getNoOfDependency()+"  "+ddc.getNoOfRejection()+"  "+ddc.getTotalValue()); 
     } 
    } 

    public int returnIndexOfSession(String sessionID) 
    { 
     DependencyDataCollection ddc = null; 
     for(int i=0;i<lList.size();i++) 
     { 
      ddc = (DependencyDataCollection)lList.get(i); 
      if(ddc.getSessionID().equals(sessionID)) 
       break; 
     } 
     return ddc.getSNo(); 
    } 

    public static void main(String args[]) 
    { 
     DependencyStack ds = new DependencyStack(); 
     ds.add(1,"a",0,0,0); 
     ds.add(2,"b",0,0,0); 
     ds.show(); 

     //System.out.println(ds.returnIndexOfSession("a")); 

//  DependencyDataCollection ddc = new DependencyDataCollection(1,"a",0,0,0); 
//  System.out.println(ds.indexOf(ddc)); 
    } 
} 

Ceci est un simple programme Linked List dans java qui utilise la classe intégrée de liste liée du paquet java.util. La liste chaînée est utilisée pour stocker différentes quantités de données à l'aide DependencyDataCollection classe ..

Maintenant, ma question est

1) S'il vous plaît évaluer ce programme, et Temme suis-je respecte tous les concepts java comme membre privé accès, ce que j'ai fait, etc.

2) Je suis confronté à un problème pour trouver le indexOf une session particulière.

Par exemple. Le noeud 1 contient 1, "a", 0,0,0 ............... Noeud 2 contient 2, "b", 0,0,0

Maintenant Je voulais trouver l'index du noeud qui contient l'une des données en tant que "b" ou "a". Quelle pourrait être la méthode intégrée la plus courte qui puisse le faire, comme j'ai fait une fonction nommée "public int returnIndexOfSession (String sessionID)" qui utilise la boucle for, je trouve cela très long. Y at-il un autre moyen de s'en sortir.

Veuillez évaluer et guider comme je suis un débutant en Java.

Answer 1

Voici les changements que je ferais, la justification est dans les commentaires.

import java.io.OutputStream; 
import java.io.OutputStreamWriter; 
import java.io.PrintWriter; 
import java.io.Writer; 
import java.util.ArrayList; 
import java.util.List; 


class DependencyDataCollection 
{ 
    // makte them fnal, then you hava an immutible object and your code is much safer. 
    // in your case you had noset methods so it was safe, but always try to make things final. 
    private final int sNo; 
    private final String sessionID; 
    private final int noOfDependency; 
    private final int noOfRejection; 
    private final int totalValue; 

    public DependencyDataCollection(final int sNo, 
            final String sessionID, 
            final int noOfDependency, 
            final int noOfRejection, 
            final int totalValue) 
    { 
     this.sNo   = sNo; 
     this.sessionID  = sessionID; 
     this.noOfDependency = noOfDependency; 
     this.noOfRejection = noOfRejection; 
     this.totalValue  = totalValue; 
    } 

    public int getSNo() 
    { 
     return sNo; 
    } 

    public String getSessionID() 
    { 
     return sessionID; 
    } 

    public int getNoOfDependency() 
    { 
     return noOfDependency; 
    } 

    public int getNoOfRejection() 
    { 
     return noOfRejection; 
    } 

    public int getTotalValue() 
    { 
     return totalValue; 
    } 
} 

class DependencyStack 
{ 
    // change the type to be as generic as poosible - List interface 
    // added generics so you get compile time safety and don't use casts later on 
    // renamed it to something meaningful 
    private final List<DependencyDataCollection> dependencies; 

    // use an ArrayList instead of a LinkedList, it'll be faster since you are not inserting/deleting 
    // into the middle of the list 
    { 
     dependencies = new ArrayList<DependencyDataCollection>(); 
    } 

    // your Stack shouldn't know how to make the collections... (in my opinion) 
    public void add(final DependencyDataCollection ddc) 
    { 
     dependencies.add(ddc); 
    } 

    public int size() 
    { 
     return dependencies.size(); 
    } 

    // the next 3 methods are just convenience since you don't know if someione 
    // will want to write to a file or a writer instead of a stream 
    public void show() 
    { 
     show(System.out); 
    } 

    public void show(final OutputStream out) 
    { 
     show(new OutputStreamWriter(out)); 
    } 

    public void show(final Writer writer) 
    { 
     show(new PrintWriter(writer)); 
    } 

    public void show(final PrintWriter writer) 
    { 
     // use the new for-each instead of the old style for loop 
     // this also uses an iterator which is faster than calling get 
     // (well on an ArrayList it probably is about the same, but a LinkedList it'll be faster) 
     for(final DependencyDataCollection ddc : dependencies) 
     { 
      writer.println(ddc.getSNo()   + " " + 
          ddc.getSessionID()  + " " + 
          ddc.getNoOfDependency() + " " + 
          ddc.getNoOfRejection() + " " + 
          ddc.getTotalValue()); 
     } 
    } 

    public int returnIndexOfSession(final String sessionID) 
    { 
     DependencyDataCollection foundDDC; 
     final int    retVal; 

     foundDDC = null; 

     for(final DependencyDataCollection ddc : dependencies) 
     { 
      if(ddc.getSessionID().equals(sessionID)) 
      { 
       foundDDC = ddc; 
       break; 
      } 
     } 

     // deal with the fact that you might have not found the item and it would be null. 
     // this assumes -1 is an invalid session id 
     if(foundDDC == null) 
     { 
      retVal = -1; 
     } 
     else 
     { 
      retVal = foundDDC.getSNo(); 
     } 

     return (retVal); 
    } 

    public static void main(final String[] args) 
    { 
     DependencyStack ds = new DependencyStack(); 
     ds.add(new DependencyDataCollection(1,"a",0,0,0)); 
     ds.add(new DependencyDataCollection(1,"a",0,0,0)); 
     ds.show(); 

     //System.out.println(ds.returnIndexOfSession("a")); 

//  DependencyDataCollection ddc = new DependencyDataCollection(1,"a",0,0,0); 
//  System.out.println(ds.indexOf(ddc)); 
    } 
} 

Edit:

Celui-ci permettra d'accélérer les recherches (et supprime).

class DependencyStack 
{ 
    // A Map provides quick lookup 
    private final Map<String, DependencyDataCollection> dependencies; 

    // a LinkedHashMap allows for quick lookup, but iterates in the order they were added... if that matters for show. 
    { 
     dependencies = new LinkedHashMap<String, DependencyDataCollection>(); 
    } 

    // your Stack shouldn't know how to make the collections... (in my opinion) 
    public void add(final DependencyDataCollection ddc) 
    { 
     if(ddc == null) 
     { 
      throw new IllegalArgumentException("ddc cannot be null"); 
     } 

     dependencies.put(ddc.getSessionID(), ddc); 
    } 

    public int size() 
    { 
     return dependencies.size(); 
    } 

    // the next 3 methods are just convenience since you don't know if someione 
    // will want to write to a file or a writer instead of a stream 
    public void show() 
    { 
     show(System.out); 
    } 

    public void show(final OutputStream out) 
    { 
     show(new OutputStreamWriter(out)); 
    } 

    public void show(final Writer writer) 
    { 
     show(new PrintWriter(writer)); 
    } 

    public void show(final PrintWriter writer) 
    { 
     // use the new for-each instead of the old style for loop 
     // this also uses an iterator which is faster than calling get 
     // (well on an ArrayList it probably is about the same, but a LinkedList it'll be faster) 
     for(final DependencyDataCollection ddc : dependencies.values()) 
     { 
      writer.println(ddc.getSNo()   + " " + 
          ddc.getSessionID()  + " " + 
          ddc.getNoOfDependency() + " " + 
          ddc.getNoOfRejection() + " " + 
          ddc.getTotalValue()); 
     } 
    } 

    public int returnIndexOfSession(final String sessionID) 
    { 
     final DependencyDataCollection ddc; 
     final int      retVal; 

     if(sessionID == null) 
     { 
      throw new IllegalArgumentException("sessionID cannot be null"); 
     } 

     // get it if it exists, this is much faster then looping through a list 
     ddc = dependencies.get(sessionID); 

     // deal with the fact that you might have not found the item and it would be null. 
     // this assumes -1 is an invalid session id 
     if(ddc == null) 
     { 
      retVal = -1; 
     } 
     else 
     { 
      retVal = ddc.getSNo(); 
     } 

     return (retVal); 
    } 

    public static void main(final String[] args) 
    { 
     DependencyStack ds = new DependencyStack(); 
     ds.add(new DependencyDataCollection(1,"a",0,0,0)); 
     ds.add(new DependencyDataCollection(1,"a",0,0,0)); 
     ds.show(); 

     //System.out.println(ds.returnIndexOfSession("a")); 

//  DependencyDataCollection ddc = new DependencyDataCollection(1,"a",0,0,0); 
//  System.out.println(ds.indexOf(ddc)); 
    } 
} 

Answer 2

Une chose qui se démarque est le manque de style javadoc commentaires (de http://en.wikipedia.org/wiki/Javadoc)

 
/** 
* Validates a chess move. Use {@link #doMove(int, int, int, int)} to move a piece. 
* 
* @param theFromFile file from which a piece is being moved 
* @param theFromRank rank from which a piece is being moved 
* @param theToFile file to which a piece is being moved 
* @param theToRank rank to which a piece is being moved 
* @return   true if the chess move is valid, otherwise false 
*/ 

Answer 3

Vous voulez utiliser les médicaments génériques:

List<DependencyDataCollection> lList; 

En outre, dans la définition variable que vous devez utiliser l'interface List et non le type concret (LinkedList).

Pour indexOf travailler, votre type d'élément (DependencyDataCollection) doit mettre en œuvre le comparateur pour l'égalité:

class DependencyDataCollection{ 

    @Override 
    public boolean equals(Object o){ 
    ... 
    } 
} 

Vous pouvez alors utiliser le fait que l'interface de liste intégrée fournit indexOf(). Il fera cependant le même genre de boucle que vous faites maintenant. Si cela prend trop de temps (vraiment?) Alors vous avez besoin d'une liste de hash-backed ou quelque chose (dans ce cas, vous devrez également implémenter hashCode()).

Mise à jour: Il fera le même type de bouclage, mais plus efficacement que maintenant. Ne pas accéder à une liste liée par index, il ne se construit pas pour cela, utiliser la boucle foreach ou un Iterator (ou un ArrayList):

for(DependencyDataCollection d: iList){ 
    ... } 

Answer 4

Dans les versions récentes de Java, vous pouvez utiliser generics afin que vous n » Je dois lancer l'objet produit lorsque vous appelez lList.get(i). Par exemple:

LinkedList<DependencyDataCollection> lList = new LinkedList<DependencyDataCollection>(); 

... 

DependencyDataCollection ddc = lList.get(0); 

Pour obtenir l'index d'un élément spécifique, parcourez la liste manuellement. Pour chaque index i dans la plage de la liste, récupérez le DependencyDataCollection et voyez s'il a les propriétés que vous voulez.Si c'est le cas, enregistrez l'index.

Answer 5

Vous êtes bien parti. Raffinements que vous pourriez faire:

• Génériques. Votre liste chaînée peut être

  LinkedList DependencyDataCollection> lList; Cela vous permet de vérifier le type.

• Vous avez vu ici que votre liste liée est peu pratique à rechercher - vous devez vérifier chaque valeur, ce qui est lent et lourd. C'est pourquoi les gens utilisent des hashmaps.

• Recherchez le motif du générateur pour trouver un moyen de contourner la longue liste d'arguments du constructeur.

Answer 6

1) Pourquoi ne pas utiliser Génériques:

LinkedList<DependencyDataCollection> lList; 

2) qui est l'inconvénient de LinkedList, vous pourriez aussi bien utiliser HashMap ou d'autres structures de données

Answer 7

LinkedList est dans java.util et peut contenir n'importe quel type de classe. Par exemple j'utilise une classe appelée Application. Donc, dans le code ci-dessous j'ai juste une liste d'applications. Ensuite, je mets une application dans la liste. Je peux aussi itérer sur mes applications pour faire ce que je veux avec mes objets.

 LinkedList<Application> app = new LinkedList<Application>(); 

      app.add(new Application("firefox")); 

    Iterator<Application> iterable = app.iterator(); 
    while(iterable.hasNext()){ 
     Application eachapp = iterable.next(); 
    } 

Si vous avez besoin de trouver un objet avec indexOf, vous pouvez remplacer la méthode égale pour votre objet dans mon cas « Application » si dans l'égalité, je déclarai et l'application de son égale et autre application si le nom du champ est le même que

app.indexOf (nouvelle application ("firefox")) retournera l'index de l'application que je viens d'insérer.