Jak usunąć ostatni element z tablicy?

Question

Teraz pracuję z rekursywnym wycofywaniem, moim zadaniem jest znaleźć najdłuższą ścieżkę w labiryncie, masa jest przedstawiona jako pole pokryte współrzędnymi, a współrzędne ścian są obolałe w pliku. Zrobiłem parser do parsowania pliku wejściowego i budowania ścian, ale również zapisałem te współrzędne w tablicy typu obiektu Coordinate, aby sprawdzić, czy możliwe jest przeniesienie następnego fragmentu "węża" na następne pole, to stworzyłem tę metodę, teraz zrozumiałem, że będę potrzebował metody, aby usunąć ostatnią współrzędną z tablicy, gdy użyję cofnięcia, jak to zrobić? Cel nie polega na używaniu list tablic ani łączonych wyświetla tylko tablice! Dziękujemy!

public class Coordinate { 
int xCoord; 
int yCoord; 

Coordinate(int x,int y) { 
    this.xCoord=x; 
    this.yCoord=y; 
} 

public int getX() { 
    return this.xCoord; 
} 

public int getY() { 
    return this.yCoord; 
} 
public String toString() { 
    return this.xCoord + "," + this.yCoord; 

} 

} 

I

public class Row { 
static final int MAX_NUMBER_OF_COORD=1000; 

Coordinate[] coordArray; 
int numberOfElements; 


Row(){ 
    coordArray = new Coordinate[MAX_NUMBER_OF_COORD]; 
    numberOfElements=0; 

    } 


void add(Coordinate toAdd) { 
    coordArray[numberOfElements]=toAdd; 
    numberOfElements +=1; 
} 
boolean ifPossible(Coordinate c1){ 
    for(int i=0;i<numberOfElements;i++){ 

     if(coordArray[i].xCoord==c1.xCoord && coordArray[i].yCoord==c1.yCoord){ 
       return false; 
      } 
     } 


    return true; 
} 

} 

Answer 1

Ponieważ tablice Java są non-zmienny rozmiar, trzeba będzie skopiować wszystko do nowej, krótszej tablicy.

Arrays.copyOf(original, original.length-1) 

Answer 2

Arrays.asList(ARRAY_NAME).remove(ARRAY_NAME.length) 

Answer 3

wiem, że to bardzo stary wątek. Wciąż sama zatwierdzona odpowiedź nie działa dla mnie. I tak to rozwiązałem.

Tworzenie metody takie jak to:

String[] sliceArray(String[] arrayToSlice, int startIndex, int endIndex) throws ArrayIndexOutOfBoundsException { 
    if (startIndex < 0) 
     throw new ArrayIndexOutOfBoundsException("Wrong startIndex = " + startIndex); 
    if (endIndex >= arrayToSlice.length) 
     throw new ArrayIndexOutOfBoundsException("Wrong endIndex = " + endIndex); 

    if (startIndex > endIndex) { // Then swap them! 
     int x = startIndex; 
     startIndex = endIndex; 
     endIndex = x; 
    } 

    ArrayList<String> newArr = new ArrayList<>(); 
    Collections.addAll(newArr, arrayToSlice); 
    for (int i = 0; i < arrayToSlice.length; i++) { 
     if (!(i >= startIndex && i <= endIndex)) // If not with in the start & end indices, remove the index 
      newArr.remove(i); 
    } 
    return newArr.toArray(new String[newArr.size()]); 
} 

wówczas nazywano go tak:

String lines[] = {"One", "Two", "Three", "Four", "Five"}; 
lines = sliceArray(lines, 0, 3); 

spowoduje:

"One", "Two", "Three", "Four" 

Teraz mogę pokroić tablicę w zależności od tego, sposób, jaki chcę!

lines = sliceArray(lines, 2, 3); 

To spowoduje:

"Three", "Four"