Un array es una tipo de dato con un tamaño fijo, es decir, es estático. Una vez que le das un tamaño al array, ya no puede cambiar, por lo que no es posible remover posiciones como en otros lenguajes. Con objetos tipo List (y por ende las clases que lo implementan) si es posible.

Lo que puedes hacer es crear otro array y guardar allí los datos que estén en los índices impares:

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];
}

Otra opción es convertirlo a lista y luego convertirlo nuevamente a array (tienes que trabajar con los Wrappers):

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

No te entiendo.


¿Quieres decir que eliminas los impares y dejas solo los pares?

a -> 2
i -> 4
a -> 6
t -> 8

¿Esa cadena "caminante" la pasas en un array? ¿de qué forma?


¿Así?

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

Trata de explicar tu enunciado por partes para que se entienda qué es lo que pretendes hacer.

Cuando se programa se trata de mantener las cosas simples y, haciendo ésto con arrays lo estás complicando. De todos modos, te pondré dos versiones: una con arrays y otra con list.

Versión con arrays:

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

Versión con List:

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

Salida:


Si quieres que salga "aiat":

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

No es complejo para nada, tan solo usas clases de la API de Java, totalmente estándar.

Lo que si tienes que tener en cuenta es que por más que intentes una vez que has definido el tamaño del array no podrás eliminar índices ni modificar dinámicamente el array. Como mucho podrás asignarle NULL a los índices pares.

Te recomiendo que sigas intentando hasta que consigas hacerlo a tu manera. Éste es el objetivo de los cursos de algoritmos, agilizar la lógica mental. Cuando lo logres, puedes colocar el código por si le sirve a otra persona.

Saludos.