Umbrechen einer ArrayList

Ich bin versucht, zu erstellen eine einfache Paginierung routine für Werte statt in einem ArrayList. Im Grunde, was ich tun wollen ist machen Sie den ersten fünf Elemente in der ArrayList auf Anhieb. Und dann, wenn Benutzer klicken Sie auf Next (increment by another 5) und Previous (decrease by 5).

Meine Logik sieht so aus:

class foo
{
   private static final int defaultStep = 5;
   private int moveCounter;
   private List<String> values;

   public foo()
   {
     values = new ArrayList<String>();
     values.add("Fiber Channel");
     values.add("Copper Channel");
     ...
   }

  private void pageNext()
  {
   if (moveCounter > -1 && moveCounter < values.size())
   {
    int currentIndex = (moveCounter + 1);
    renderValues(currentIndex, false);
   }
  }

  private void pagePrevious()
  {
   if (moveCounter > -1 && moveCounter <= values.size())
   {
    renderValues(moveCounter-1, true);
   }
  }

 private void renderValues(int startIndex, boolean isPreviousCall)
 {
  if (startIndex > -1)
  {
   StringBuilder html = new StringBuilder();
   List<String> valuesToRender = new ArrayList<String>();
   int checkSteps = 1;
   while (startIndex < values.size())
   {
     valuesToRender.add(values.get(startIndex));
     if (checkSteps == defaultStep) break;
     startIndex++;
     checkSteps++;
   }
   moveCounter = startIndex;

   //TODO: Build html String
   ...
   }
 }
}

Ich habe ein Problem mit pagePrevious nennen, könnt Ihr mir helfen, die valuesToRender 5-Schritte bis values array vor dem hinzufügen des Werts zu machen, um die valuesToRender array.

Ich habe versucht, etwas zu tun, wie auch dieses:

  for (int start = startIndex, end = values.size() - 1; start < end; start++, end--)
  {
    if (isPreviousCall) valuesToRender.add(values.get(end));
    else valuesToRender.add(values.get(start));

    if (checkSteps == defaultStep) break;
    checkSteps++;
  }

Aber das scheint nicht zu funktionieren, weder noch. Können Sie Kerle Stelle und mir helfen, dieses Problem zu beheben.
Danke Jungs.

InformationsquelleAutor Bitmap | 2012-04-25
  1. 1

    Ich würde es so machen:

    Ich bin mir nicht sicher, was renderValues tut, und ob wir zu subtrahieren 1 oder vielleicht defaultStep aus der oberen Grenze der moveCounter.

    private void pageMove (int step)
{
    moveCounter = moveCounter + step;
    if (moveCounter < 0) moveCounter = 0;
    if (moveCounter > values.size ()) moveCounter = values.size ();
    renderValues (currentIndex, false);
}

private void pageNext ()
{
    pageMove (defaultStep);
}

private void pagePrevious ()
{
    pageMove (-defaultStep);
}

    Den ersten 3 Zeilen werden konnte, gepackt in zwei große ternären experssions etwa so: 

    mc = ((mc + s) < 0) ? 0 : ((mc + s) > vs) ? vs : (mc + s);

    aber die 3-Zeilen-Lösung ist besser zu Folgen.

    • Doing es auf diese Weise, würde renderValues(..) bleiben, wie es ist oder Sie denken, dass die zweite option steht passen - oder vielleicht ändern muss?!
    • Gut, ich verstehe nicht, was 'renderValues' tut. Die Variablennamen sind quiete verwirrend. StartIndex und checkSteps sind veränderlich? Vielleicht haben Sie bessere Namen nennen, ich oder n ist. Ich dachte, der job des pagePrev, ist der Rahmen irgendwie wieder von 17-22 auf 12-17 zum Beispiel, und um zu überprüfen, Grenze für die Verletzung (verhindern, -3). Die spätere Arbeit des layout ist in renderValues. Stellen Sie kurz die Methoden, die haben nur eine Aufgabe zu lösen.
    InformationsquelleAutor user unknown
  2. 1

    Ändern

    if (moveCounter > -1 && moveCounter <= archive.size())
{
  renderValues(moveCounter-1, true);
}

    zu

    if (moveCounter > 0 && moveCounter <= archive.size())
{
  renderValues(moveCounter-1, true);
}
    InformationsquelleAutor Marko Topolnik
  3. 1

    Basierend auf "pscuderi" Lösung hier
    Ich habe gebaut, ein wrapping-Klasse, die hilfreich sein können für jemanden, der sich für diese:

    import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class PaginatedList<T> {

private static final int DEFAULT_PAGE_SIZE = 10;

private List<T> list;
private List<List<T>> listOfPages;
private int pageSize = DEFAULT_PAGE_SIZE;
private int currentPage = 0;

public PaginatedList(List<T> list) {
    this.list = list;
    initPages();
}

public PaginatedList(List<T> list, int pageSize) {
    this.list = list;
    this.pageSize = pageSize;
    initPages();
}

public List<T> getPage(int pageNumber) {
    if (listOfPages == null || 
        pageNumber > listOfPages.size() ||
        pageNumber < 1) {
        return Collections.emptyList();
    }

    currentPage = pageNumber;
    List<T> page = listOfPages.get(--pageNumber);
    return page;
}

public int numberOfPages() {
    if (listOfPages == null) {
        return 0;
    }

    return listOfPages.size();
}

public List<T> nextPage() {
    List<T> page = getPage(++currentPage);
    return page;
}

public List<T> previousPage() {
    List<T> page = getPage(--currentPage);
    return page;
}

public void initPages() {
    if (list == null || listOfPages != null) {
        return;
    }

    if (pageSize <= 0 || pageSize > list.size()) {
        pageSize = list.size();
    }

    int numOfPages = (int) Math.ceil((double) list.size() / (double) pageSize);
    listOfPages = new ArrayList<List<T>>(numOfPages);
    for (int pageNum = 0; pageNum < numOfPages;) {
        int from = pageNum * pageSize;
        int to = Math.min(++pageNum * pageSize, list.size());
        listOfPages.add(list.subList(from, to));
    }
}

public static void main(String[] args) {
    List<Integer> list = new ArrayList<Integer>();
    for (int i = 1; i <= 62; i++) {
        list.add(i);
    }

    PaginatedList<Integer> paginatedList = new PaginatedList<Integer>(list);
    while (true) {
        List<Integer> page = paginatedList.nextPage();
        if (page == null || page.isEmpty()) {
            break;
        }

        for (Integer value : page) {
            System.out.println(value);
        }

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

}
    InformationsquelleAutor Qussay Najjar
Schreibe einen Kommentar