Obter apenas parte de uma matriz em Java?

Eu tenho uma matriz de números inteiros em Java, gostaria de usar apenas uma parte dele. Eu sei que em Python você pode fazer algo como esse array [index:] e ele retorna o array do índice. É algo como isso possível em Java.

O comprimento de uma matriz em Java é imutável. Portanto, você precisa copiar a parte desejada como uma nova matriz.
Use o copyOfRangemétodo da classe java.util.Arrays :

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

startIndex é o índice inicial do intervalo a ser copiado, inclusive.
endIndex é o índice final do intervalo a ser copiado, exclusivo. (Esse índice pode estar fora da matriz)

Por exemplo:

   //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)

Você pode agrupar sua matriz como uma lista e solicitar uma sub-lista dela.

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

Sim, você pode usar Arrays.copyOfRange

Faz a mesma coisa (observe que há uma cópia: você não altera a matriz inicial).

Podes tentar:

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

Veja javadoc para System .

Se você estiver usando o Java 1.6 ou superior, poderá Arrays.copyOfRangecopiar uma parte da matriz. Do javadoc:

Copia o intervalo especificado da matriz especificada para uma nova matriz. O índice inicial do intervalo (de) deve estar entre zero e original.length, inclusive. O valor em original[from]é colocado no elemento inicial da cópia (a menos que from == original.lengthou from == to). Os valores dos elementos subseqüentes na matriz original são colocados nos elementos subseqüentes na cópia. O índice final do intervalo ( to), que deve ser maior ou igual a from, pode ser maior que original.length, nesse caso, falseé colocado em todos os elementos da cópia cujo índice é maior ou igual a original.length - from. O comprimento da matriz retornada será to - from.

Aqui está um exemplo simples :

/**
 * @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]);
    }

}

Confira copyOfRange ; e exemplo:

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

Você pode usar algo como isto: Arrays#copyOfRange

Você pode usar o subList(int fromIndex, int toIndex)método em seus números inteiros, algo como isto:

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

Saída será: 2 3.

Observe que o subList(int fromIndex, int toIndex)método executa menos 1 na 2ª variável que recebe (var2 - 1), não sei exatamente por que, mas é o que acontece, talvez para reduzir a chance de exceder o tamanho da matriz.