Ajuda com coleções

Cara, a única maneira que me veio a cabeça foi essa

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Test {

	public static void main(String[] args) throws IOException {
		
		Object[] o = new Object[10];
		
		o[3] = "A";
		
		List a = new ArrayList( Arrays.asList(o)); 
		a.add(3, "O");
	}
}

Pelo menos funcionou :lol:

List (acho que qualquer implementacao) atende a necessidade 2. Agora a primeira na verdade eu não entendi o porque.
Ai qdo eu olho os dois requisitos nao entendo nada dá para dar umas marretadas que atendem a necessidade 1… mas não sou adepto desses modos

Thiago o seu código até atende, mas como ele não sabe qual o indice que ele quer inserir o size 10 no array pode dar pau.

A marretada mais correta (se é que existe marretada correta) poderia ser
sobrescrever o método add(indice, valor) de uma lista, e qdo ele fosse adicionar o item verificar se esse indice ja existe… se ja existe ok… adiciona e boa, se não existe insere uns null na lista até que vc possa adicionar.

Só que ai… na hora de retirar esses itens da lista ele poderia pegar um monte de null, teria que fazer o tratamento na saida tb.

Marretada!!! talvez se tivermos o problema na mão seja mais fácil de entender melhor e tentar ajudar

Não entendo pq o elemento não pode ser inserido na primeira posição. Os espaços vazios da lista podem ser despresados então você pode criar uma constant de ordenação e a cada list.add(objetc) você pdoe usar um Collections.sort(list) para ordenar da forma q você quer.

Imagine o cenário:

Um protocolo proprietário me envia o dados da seguinte forma : (index, objeto). Onde o índice é a posição que o objeto deve ocupar numa lista.

Porém o index pode vir de forma desordenada, o index 4, por exemplo, pode chegar antes do index 1. Porém minha lista já deve estar organizada.
Pois pode chegar uma informação no protocolo, que o objeto xpto deve ser inserido na posição 4 também dessa lista, e por convenção, devo empurrar para o index 5 o objeto anterior para poder inserir o novo no index 4.

Uma estrutura com duas listas onde você

todos os elementos que estiverem em posições maior igual a que você deseja inserir, você insere na lista auxiliar e remove da principal. quando a posição estiver livre você insere seu elemento e coloca os elementos da lista auxiliar de volta a lista principal.

public class Teste {
    List<String> listaPrincipal = new ArrayList<String>();
    public void setObject(int index, String objeto ){
    	List<String> aux = new ArrayList<String>();
    	
    	
    	while(listaPrincipal.size() > index){
    	   aux.add(listaPrincipal.get(index));
    	   listaPrincipal.remove(index);
    	}
    	
    	listaPrincipal.add(objeto);
    	
    	for(int i = 0 ; i < aux.size(); i++){
    		listaPrincipal.add((String) aux.get(i));
    	}
    }
    
    public static void main(String args[]){
    	Teste t = new Teste();
    	
    	t.setObject(0, "Carro");
    	t.setObject(1, "Casa");
    	t.setObject(2, "Prato");
    	t.setObject(3, "Mulher");
    	t.setObject(4, "Homem");
    	t.setObject(5, "Filho");
    	t.setObject(2, "Apto");
    	t.setObject(2, "Arvore");
    	
    	for(String s: t.listaPrincipal){
    		System.out.println(s);
    	}
    } 
}

Fiz um teste aqui é funciona da forma que você quer. Teste ai e veja se resolve seu problema.

Esse código nao performa, a cada setObject vc varre as duas listas inteiras, se sua lista for grande a cada setObjet vai demorar uma eternidade.

O melhor (mas nao ideal) seria extender ArrayList e sobrescrever o metodo add(int, T) e aplicar a lógica la dentro, a lógica que eu mencionei no outro post.

luciano@@:

Uma estrutura com duas listas onde você

todos os elementos que estiverem em posições maior igual a que você deseja inserir, você insere na lista auxiliar e remove da principal. quando a posição estiver livre você insere seu elemento e coloca os elementos da lista auxiliar de volta a lista principal.

public class Teste {
    List<String> listaPrincipal = new ArrayList<String>();
    public void setObject(int index, String objeto ){
    	List<String> aux = new ArrayList<String>();
    	
    	
    	while(listaPrincipal.size() > index){
    	   aux.add(listaPrincipal.get(index));
    	   listaPrincipal.remove(index);
    	}
    	
    	listaPrincipal.add(objeto);
    	
    	for(int i = 0 ; i < aux.size(); i++){
    		listaPrincipal.add((String) aux.get(i));
    	}
    }
    
    public static void main(String args[]){
    	Teste t = new Teste();
    	
    	t.setObject(0, "Carro");
    	t.setObject(1, "Casa");
    	t.setObject(2, "Prato");
    	t.setObject(3, "Mulher");
    	t.setObject(4, "Homem");
    	t.setObject(5, "Filho");
    	t.setObject(2, "Apto");
    	t.setObject(2, "Arvore");
    	
    	for(String s: t.listaPrincipal){
    		System.out.println(s);
    	}
    } 
}

Fiz um teste aqui é funciona da forma que você quer. Teste ai e veja se resolve seu problema.

Mas se o cara quer inserir na posição mesmo que ja exista elemento essa é a melhor forma de fazer. Talvez o algoritimo não seja o mais performático, mas a forma de fazer é essa.

Ao invês de percorrer ele poderia usar um System.arraycopy(array1, start1, array2, start2, length)

primeiro ele pega os itens do inicio, até a posição anterior a que ele quer inserir e adicionar em uma nova lista.
insere o novo elemento na nova lista.
e depois usa o array copy para pegar os elementos da posição que ele quer inserir até o final e adiciona na nova lista.
retorna a nova lista

Encapsula o indice e o objeto dentro de um outro objeto e coloca esse objeto na lista. Me parece ser mais simples assim…

Pelo que o cara explicou o problema não é tão simples assim.

Pelo que eu entendi ele quer q mesmo que ja exista um indice 4, se ele mandar inserir outro objeto no indice 4, o existente passa a ser o 5 e assim por diante. Vamos esperar que ele pronuncie.

SImples… porém nao funcional
Pq vc perde a arvore, dai nao consegue mais usar polimorfismo entao toda a parte da java.util.Collections foi pro saco

Ex: public static void main(String[] args) throws IOException { Object[] object = new Object[10]; object[9] = "A"; List lista = new ArrayList( Arrays.asList(object)); lista.add(0, "O"); System.out.println(lista); }

List<String> listaPrincipal = new ArrayList<String>();   

	public void setObject(int index, String objeto){   
        List<String> aux = new ArrayList<String>();   
           
        while(listaPrincipal.size() > index){   
           aux.add(listaPrincipal.get(index));   
           listaPrincipal.remove(index);   
        }   
           listaPrincipal.add(objeto);   
      
           for(int i = 0 ; i < aux.size(); i++){   
            listaPrincipal.add((String) aux.get(i));   
        }   
    }   
       
    public static void main(String args[]){   
        PraticandoList t = new PraticandoList();   
           
        t.setObject(0, "Carro");   
        t.setObject(1, "Casa");   
        t.setObject(2, "Prato");   
        t.setObject(3, "Mulher");   
        t.setObject(4, "Homem");   
        t.setObject(5, "Filho");   
        t.setObject(2, "Apto");   
        t.setObject(2, "Arvore");   
         

        
        for(String s: t.listaPrincipal){   
            System.out.println(s);   
        }   
    }

System.out.println(new PraticandoList().listaPrincipal.isEmpty());

não é nela que as palavras foram adicionadas?