int oddCount = (int) array.length / 2; // cuenta los indices impares
 
int[] otherArray = new int[oddCount];
for(byte i=0; i<oddCount; i++)
{
	if(i % 2 != 0) // solo indices impares
		otherArray = array[i];
}

Integer[] array = {2,7,4,9,8};
Arrays.asList(array);
 
for(byte i=0; i<array.size(); i++)
{
	if(i % 2 == 0)
		array.remove(i);
}
Integer[] otherArray = array.toArray(new Integer[array.size()]);

String[] array = {"c","a","m","i","n","a","n","t","e"};

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
 
public class ArrayDemo {
 
	private Character[] letters  = new Character[30];
	private Scanner reader = new Scanner(System.in);
 
	/*
	 * Realiza un do while para ingresar datos
	 * hasta que se ingrese el centinela (0) lo cual
	 * indica que ya no se ingresaran más números
	 */
	void fillArray() throws IOException {
 
		byte i = 0;
		char letter;
 
		do {
			System.out.println("Introduce una letra o 0 para finalizar:");
			letter = reader.next().charAt(0);
			if( letter != '0') {
				letters [i] = letter;
				i++;
			}
		} while (letter != '0');
	}
 
	// imprime el array
	void printArray() {
 
		System.out.println("\n**** ARRAY ******\n");
		for(Character letter : letters)
		{
			if(letter != null) {
				System.out.println(letter);
			}
		}
	}
 
	/*
	 * Convierte el arreglo "letters" a lista, en concreto LinkedList para
	 * poder usar el método remove() sin necesidad de un iterator.
	 * Luego crea una lista "oddItems" que guardara los valores impares. 
	 * Posteriormente, elimina todos los elementos NULL que tiene la lista convertida
	 * desde "letters" ya que los elementos vacíos de un array contienen NULL por defecto.
	 * 
	 * Recorre la lista y evalúa si el index actual es par (quiere decir que el índice
	 * normal, es un impar porque en listas y arrays se empieza a contar por 0), guarda
	 * el elemento en la nueva lista "oddItems".
	 * seguidamente blankeo todo el array asignándole null a cada posición para que al
	 * guardar el nuevo array en "letters", éste esté limpio.
	 * 
	 * Finalmente guardo el array "oddItems" en "letters".
	 */
	void deleteEvensIndex() {
 
		List<Character> tempLetters = new LinkedList<Character> (Arrays.asList(letters));
		List<Character> oddItems = new ArrayList<>();
		tempLetters.removeAll(Collections.singleton(null));
 
		for(int i=0; i<tempLetters.size(); i++)
		{
			if ( i % 2 == 0)
				oddItems.add(tempLetters.get(i));
			letters[i] = null;
		}
		letters = oddItems.toArray(letters);
	}
 
}

import java.io.IOException;
 
public class ArrayDemoTest {
 
	public static void main(String[] args) {
 
		ArrayDemo obj = new ArrayDemo();
		try {
			obj.fillArray();
			obj.printArray();
			obj.deleteEvensIndex();
			obj.printArray();
		} catch (IOException e) {
			e.printStackTrace();
		}
 
	}
 
}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
public class ListDemo {
 
	private List<Character> letters;
	private Scanner reader;
 
	public ListDemo()
	{
		letters = new ArrayList<>();
		reader = new Scanner(System.in);
	}
 
	/*
	 * Realiza un do while para ingresar datos
	 * hasta que se ingrese el centinela (0) lo cual
	 * indica que ya no se ingresaran m&#225;s n&#250;meros
	 */
	public void fillList()
	{
		char letter;
 
		do {
			System.out.println("Introduce una letra o 0 para finalizar:");
			letter = reader.next().charAt(0);
			if( letter != '0') {
				letters.add(letter);
			}
		} while (letter != '0');
	}
 
	/*
	 * Convierte el arreglo "letters" a lista, en concreto LinkedList para
	 * poder usar el m&#233;todo remove() sin necesidad de un iterator.
	 * Luego crea una lista "oddItems" que guardara los valores impares. 
	 * Posteriormente, elimina todos los elementos NULL que tiene la lista convertida
	 * desde "letters" ya que los elementos vac&#237;os de un array contienen NULL por defecto.
	 * 
	 * Recorre la lista y eval&#250;a si el index actual es par (quiere decir que el &#237;ndice
	 * normal, es un impar porque en listas y arrays se empieza a contar por 0), guarda
	 * el elemento en la nueva lista "oddItems".
	 *
	 * Finalmente guardo el array "oddItems" en "letters".
	 */
	public void deleteEvensIndex()
	{
		List<Character> oddItems = new ArrayList<>();
		for(int i=0; i<letters.size(); i++)
		{
			if(i % 2 == 0)
				oddItems.add(letters.get(i));
		}
		letters = oddItems;
	}
 
	// imprime la lista
	public void printList()
	{
		System.out.println("\n ******** DATA OF LIST ******** \n");
		for(char c : letters)
		{
			System.out.println(c);
		}
	}
 
}

public class ListDemoTest {
 
	public static void main(String[] args) {
 
		ListDemo ld = new ListDemo();
		ld.fillList();
		ld.printList();
		ld.deleteEvensIndex();
		ld.printList();
 
	}
 
}

Introduce una letra o 0 para finalizar:
c
Introduce una letra o 0 para finalizar:
a
Introduce una letra o 0 para finalizar:
m
Introduce una letra o 0 para finalizar:
i
Introduce una letra o 0 para finalizar:
n
Introduce una letra o 0 para finalizar:
a
Introduce una letra o 0 para finalizar:
n
Introduce una letra o 0 para finalizar:
t
Introduce una letra o 0 para finalizar:
e
Introduce una letra o 0 para finalizar:
0

 ******** DATA OF LIST ******** 

c
a
m
i
n
a
n
t
e

 ******** DATA OF LIST ******** 

c
m
n
n
e

if(i % 2 == 0) // remplaza por
if(i % 2 != 0)