Dostajesz tylko część tablicy w Javie?

Mam tablicę liczb całkowitych w Javie, chciałbym użyć tylko jej części. Wiem, że w Pythonie możesz zrobić coś takiego jak ta tablica [indeks:] i zwraca tablicę z indeksu. Czy coś takiego jest możliwe w Javie.

Długość tablicy w Javie jest niezmienna. Musisz więc skopiować żądaną część jako nową tablicę.
Użyj copyOfRangemetody z klasy java.util.Arrays :

int[] newArray = Arrays.copyOfRange(oldArray, startIndex, endIndex);

startIndex jest początkowym indeksem zakresu do skopiowania, włącznie.
endIndex to końcowy indeks zakresu do skopiowania, wyłączny. (Ten indeks może leżeć poza tablicą)

Na przykład:

   //index   0   1   2   3   4
int[] arr = {10, 20, 30, 40, 50};
Arrays.copyOfRange(arr, 0, 2);          // returns {10, 20}
Arrays.copyOfRange(arr, 1, 4);          // returns {20, 30, 40}
Arrays.copyOfRange(arr, 2, arr.length); // returns {30, 40, 50} (length = 5)

Możesz owinąć tablicę jako listę i poprosić o jej podlistę.

MyClass[] array = ...;
List<MyClass> subArray = Arrays.asList(array).subList(index, array.length);

Tak, możesz użyć Arrays.copyOfRange

Robi to samo (pamiętaj, że istnieje kopia: nie zmieniasz początkowej tablicy).

Możesz spróbować:

System.arraycopy(sourceArray, 0, targetArray, 0, targetArray.length);// copies whole array

// copies elements 1 and 2 from sourceArray to targetArray
System.arraycopy(sourceArray, 1, targetArray, 0, 2); 

Zobacz javadoc dla Systemu .

Jeśli używasz Java 1.6 lub nowszej, możesz użyć Arrays.copyOfRangedo skopiowania części tablicy. Z javadoc:

Kopiuje określony zakres określonej tablicy do nowej tablicy. Początkowy indeks zakresu (od) musi wynosić od zera do original.lengthwłącznie. Wartość at original[from]jest umieszczana w początkowym elemencie kopii (chyba że from == original.lengthlub from == to). Wartości z kolejnych elementów w oryginalnej tablicy są umieszczane w kolejnych elementach w kopii. Ostateczny indeks zakresu ( to), który musi być większy lub równy from, może być większy niż original.length, w którym falseto przypadku jest umieszczany we wszystkich elementach kopii, których indeks jest większy lub równy original.length - from. Długość zwracanej tablicy będzie wynosić to - from.

Oto prosty przykład :

/**
 * @Program that Copies the specified range of the specified array into a new 
 * array.
 * CopyofRange8Array.java 
 * Author:-RoseIndia Team
 * Date:-15-May-2008
 */
import java.util.*;
public class CopyofRange8Array {
    public static void main(String[] args) {
       //creating a short array
       Object T[]={"Rose","India","Net","Limited","Rohini"};
        // //Copies the specified  short array upto specified range,
        Object T1[] = Arrays.copyOfRange(T, 1,5);
        for (int i = 0; i < T1.length; i++) 
            //Displaying the Copied short array upto specified range
            System.out.println(T1[i]);
    }

}

Sprawdź copyOfRange ; i przykład:

int[] arr2 = Arrays.copyOfRange(arr,0,3);

Możesz użyć czegoś takiego: Arrays#copyOfRange

Możesz użyć subList(int fromIndex, int toIndex)metody na liczbach całkowitych arr, mniej więcej tak:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(2);
        arr.add(3);
        arr.add(4);
        List<Integer> partialArr = arr.subList(1, 3);

        // print the subArr
        for (Integer i: partialArr)
            System.out.println(i + " ");
    }
}

Wyjście będzie: 2 3.

Zauważ, że subList(int fromIndex, int toIndex)metoda wykonuje minus 1 na drugiej zmiennej, którą otrzymuje (var2 - 1), nie wiem dokładnie dlaczego, ale tak właśnie się dzieje, być może w celu zmniejszenia szansy na przekroczenie rozmiaru tablicy.