Необходимо знать некоторые основы класса LinkedList в 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));
    }
}

Это простая программа Linked List в Java, которая использует встроенный класс связанного списка из пакета java.util. Связанный список используется для хранения различного объема данных с использованием класса DependencyDataCollection.

Теперь мой вопрос

1) Пожалуйста, оцените эту программу, и я уважаю все Java такие понятия, как частный член доступ, который я сделал, и т.д ..

2) У меня проблема с поиском indexOf конкретного сеанса.

Например, Узел 1 содержит 1, "а", 0,0,0 ............... Узел 2 содержит 2, "б", 0,0,0

Теперь я хотел найти индекс узел, который содержит один из данные как «б» или «а». Что может быть самым коротким встроенным методом, который может это сделать, так как я сделал функцию с именем "public int returnIndexOfSession (String sessionID)", которая использует цикл for, я считаю это очень трудоемким. Есть ли другой выход. .

Пожалуйста, оцените и проведите, так как я новичок в Java.

Answer 1

Вот изменения, которые я бы сделал, обоснование в комментариях.

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));
    }
}

Редактировать:

Этот ускорит поиск (и удалит).

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

1) Почему вы не используете Generics:

LinkedList<DependencyDataCollection> lList;

2) Это недостаток LinkedList, вы также можете использовать HashMap или другие структуры данных

Answer 3

У тебя хорошее начало. Уточнения, которые вы можете сделать:

• Дженерики. Ваш связанный список может быть

  LinkedList lList; Это дает вам проверку типа.

• Вы видели здесь, что ваш связанный список неудобен для поиска - вы должны проверить каждое значение, которое является медленным и громоздким. Вот почему люди используют хэш-карты.

• Просмотрите шаблон построителя, чтобы найти способ обойти длинный список аргументов конструктора.

Answer 4

Вы хотите использовать дженерики:

List<DependencyDataCollection> lList;

Кроме того, в определении переменной следует использовать интерфейс List, а не конкретный тип (LinkedList).

Чтобы indexOf работал, тип вашего элемента (DependencyDataCollection) должен реализовать компаратор для равенства:

class DependencyDataCollection{

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

Затем вы можете использовать встроенную функцию indexOf (), предоставляемую интерфейсом List. Однако он будет выполнять те же циклы, что и сейчас. Если это слишком много времени (правда?), Тогда вам нужен список с хэш-поддержкой или что-то еще (в этом случае вам также необходимо реализовать hashCode ()).

Обновление: Это будет делать такой же цикл, но более эффективно, чем вы делаете сейчас. Не обращайтесь к связанному списку по индексу, для которого он не создан, используйте цикл foreach, итератор (или ArrayList):

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

Answer 5

Одна вещь, которая выделяется, это отсутствие комментариев в стиле javadoc. (от 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 6

LinkedList находится в java.util и может содержать любой тип класса. Например, я использую класс под названием Application. Так что в приведенном ниже коде у меня просто есть список приложений. Затем я положил одно приложение в списке. Я также могу перебирать свои приложения, чтобы делать с объектами все, что я хочу.

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

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

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

Если вам нужно найти объект с indexOf, вы можете переопределить метод равных для вашего объекта в моем случае «Приложение», так что если в равном я объявил, что и приложение равно, и другое приложение, если имя поля совпадает, то

app.indexOf (новое приложение ("firefox")) вернет индекс приложения, которое я только что вставил.

Answer 7

В последних версиях Java вы можете использовать generics , чтобы вам не приходилось приводить объект, созданный при вызове lList.get(i). Например:

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

...

DependencyDataCollection ddc = lList.get(0);

Чтобы получить индекс определенного элемента, прокрутите список вручную. Для каждого индекса i в диапазоне списка найдите коллекцию DependencyDataCollection и посмотрите, есть ли у нее нужные свойства. Если это так, сохраните индекс.