[RESOLVIDO] java.util.ArrayList.rangeCheck [Resolvido pelo JavaRanch]

Oi,

Quando entra no método armazena(), seu LISTA_DE_NOMES não tem tamanho, ou melhor, tem um size 0.

A condição do for (0 é menor do que 5) é válida. Quando você tenta pegar o get(0) dá o erro. Até porque não existe um elemento nessa posição a ser retornado.

Sugiro então, verificar se o LISTA_DE_NOMES é maior do que zero antes de rodar o laço de repetição.

Tchauzin!

lina:

Oi,

Quando entra no método armazena(), seu LISTA_DE_NOMES não tem tamanho, ou melhor, tem um size 0.

A condição do for (0 é menor do que 5) é válida. Quando você tenta pegar o get(0) dá o erro. Até porque não existe um elemento nessa posição a ser retornado.

Sugiro então, verificar se o LISTA_DE_NOMES é maior do que zero antes de rodar o laço de repetição.

Tchauzin!

Problema em LISTA_DE_NOMES, não aceita condição ??? !!!

public boolean verifica(String newName){ if (LISTA_DE_NOMES.size()>0) for(String s:LISTA_DE_NOMES){ if(s.equals(newName)) return true; } }

Mude essa linha:

for (int i=0;LISTA_DE_NOMES.size()<=5; i++){

Essa condição é estranha. Você está dizendo que "enquanto o tamanho da lista de nomes for menor que 5"…

Entretanto, seu método não faz nenhuma inclusão na lista. Ou seja, quando a lista tiver tamanho menor que 5, ele irá tentar comparar até elementos que não existem.

Talvez sua condição devesse ser:

for (int i=0;i < LISTA_DE_NOMES.size() && i <= 5; i++){

Embora, se isso aí é para sua aplicação socket, bastaria simplesmente não inserir mais de 5 elementos no list e deixar somente:

for (int i=0;i < LISTA_DE_NOMES.size(); i++){

Ou usar o for each.

Jonas,

Acho que você está querendo fazer algo como o exemplo abaixo.
Para usar a sintaxe do for-each, declare as listas como List e ArrayList

import java.util.*;
public class Lista{
   private static List<String> LISTA_DE_NOMES = new ArrayList<String>();  
      
   public static boolean armazena(String newName){ 
      if(verifica(newName)){
         return false;
      }else{ 
         //adiciona na lista   
         LISTA_DE_NOMES.add(newName);  
         return true;  
      }
   }

   public static boolean verifica(String newName){  
       if (LISTA_DE_NOMES.size()>0){  
           for(String s:LISTA_DE_NOMES){  
              if(s.equals(newName)){
                  return true;  
              }  
           }
        }
        return false;
   }

   public static void main(String args[]){
      String nome;

      nome = "Maria";
      if(armazena(nome))
         System.out.println("armazenou " + nome);
      else
         System.out.println(nome + " ja presente");

      nome = "Jose";
      if(armazena(nome))
         System.out.println("armazenou " + nome);
      else
         System.out.println(nome + " ja presente");


      nome = "Maria";
      if(armazena(nome))
         System.out.println("armazenou " + nome);
      else
         System.out.println(nome + " ja presente");

   }
}

Tudo isso:

public boolean verifica(String newName){ if (LISTA_DE_NOMES.size()>0) for(String s:LISTA_DE_NOMES){ if(s.equals(newName)) return true; } }

Pode ser substituido por:

public boolean verifica(String newName){ return LISTA_DE_NOMES.contains(newName); }

Veja um exemplo de várias coisas que podem ser feitas com listas:

[quote=ViniGodoy]Tudo isso:

public boolean verifica(String newName){ if (LISTA_DE_NOMES.size()>0) for(String s:LISTA_DE_NOMES){ if(s.equals(newName)) return true; } }

Pode ser substituido por:

public boolean verifica(String newName){ return LISTA_DE_NOMES.contains(newName); }

Veja um exemplo de várias coisas que podem ser feitas com listas:

al.barbosa:

Jonas,

Acho que você está querendo fazer algo como o exemplo abaixo.
Para usar a sintaxe do for-each, declare as listas como List e ArrayList

import java.util.*;
public class Lista{
   private static List<String> LISTA_DE_NOMES = new ArrayList<String>();  
      
   public static boolean armazena(String newName){ 
      if(verifica(newName)){
         return false;
      }else{ 
         //adiciona na lista   
         LISTA_DE_NOMES.add(newName);  
         return true;  
      }
   }

   public static boolean verifica(String newName){  
       if (LISTA_DE_NOMES.size()>0){  
           for(String s:LISTA_DE_NOMES){  
              if(s.equals(newName)){
                  return true;  
              }  
           }
        }
        return false;
   }

   public static void main(String args[]){
      String nome;

      nome = "Maria";
      if(armazena(nome))
         System.out.println("armazenou " + nome);
      else
         System.out.println(nome + " ja presente");

      nome = "Jose";
      if(armazena(nome))
         System.out.println("armazenou " + nome);
      else
         System.out.println(nome + " ja presente");


      nome = "Maria";
      if(armazena(nome))
         System.out.println("armazenou " + nome);
      else
         System.out.println(nome + " ja presente");

   }
}

Respondido Fonte
A Java list is a collection of objects ... the elements of a list. The size of the list is the number of elements in that list. If you want that size to be fixed, that means that you cannot either add or remove elements, because adding or removing elements would violate your "fixed size" constraint.

The simplest way to implement a "fixed sized" list (if that is really what you want!) is to put the elements into an array and then Arrays.asList(array) to create the list wrapper. The wrapper will allow you to do operations like get and set, but the add and remove operations will throw exceptions.

On the other hand, if you really want a list type with a fixed limit (or limits) on its size, then you'll need to create your own List class to implement this. For example, you could create a wrapper class that implements the relevant checks in the various add / addAll and remove / removeAll / retainAll operations. (And in the iterator remove methods if they are supported.)

So why doesn't the Java Collections framework implement these? Here's why I think so:

Use-cases that need this are rare.
The use-cases where this is needed, there are different requirements on what to do when an operation tries to break the limits; e.g. throw exception, ignore operation, discard some other element to make space.
A list implementation with limits could be problematic for helper methods.

import java.util.ArrayList;

public class FixedSizeList<T> extends ArrayList<T> {

    public FixedSizeList(int capacity) {
        super(capacity);
        for (int i = 0; i < capacity; i++) {
            super.add(null);
        }
    }

    public FixedSizeList(T[] initialElements) {
        super(initialElements.length);
        for (T loopElement : initialElements) {
            super.add(loopElement);
        }
    }

    @Override
    public void clear() {
        throw new UnsupportedOperationException("Elements may not be cleared from a fixed size List.");
    }

    @Override
    public boolean add(T o) {
        throw new UnsupportedOperationException("Elements may not be added to a fixed size List, use set() instead.");
    }

    @Override
    public void add(int index, T element) {
        throw new UnsupportedOperationException("Elements may not be added to a fixed size List, use set() instead.");
    }

    @Override
    public T remove(int index) {
        throw new UnsupportedOperationException("Elements may not be removed from a fixed size List.");
    }

    @Override
    public boolean remove(Object o) {
        throw new UnsupportedOperationException("Elements may not be removed from a fixed size List.");
    }

    @Override
    protected void removeRange(int fromIndex, int toIndex) {
        throw new UnsupportedOperationException("Elements may not be removed from a fixed size List.");
    }
}

Jonas,

Estou enviando mais uma forma de fazer que talvez ajude. Imagino que você tenha uma classe Sala, ou algo parecido. Você quer ir armazenando usuarios na sala. Pode haver no máximo 5 usuarios, e ao incluir precisa testar se o usuario ja esta na sala.

import java.util.*;
import javax.swing.*;
public class Sala{
   private List<String> LISTA_DE_NOMES = new ArrayList<String>();  
      
   public synchronized boolean armazena(String newName) throws Exception { 
      if(LISTA_DE_NOMES.size()>=5){
         throw new Exception("Esta sala já esta cheia");
      }else if(LISTA_DE_NOMES.contains(newName)){
         throw new Exception("Este usuario já esta na sala.");
      }else{ 
         //adiciona na lista   
         LISTA_DE_NOMES.add(newName);
         return true;  
      }
   }

   public void listar(){
      System.out.println();
      System.out.println("Usuarios presentes na sala:");
      for(String nome : LISTA_DE_NOMES){
         System.out.println(nome);
      }
   }

   public static void main(String args[]){
      Sala sala = new Sala();
      while(true){
         String retorno = JOptionPane.showInputDialog(null, "Digite o nome do novo usuario.");
         if(retorno == null) break;    // Cancel na InputDialog
         try{
            sala.armazena(retorno);
         }catch(Exception e){
            JOptionPane.showMessageDialog(null, e.getMessage());
         }finally{
            sala.listar();
         }
      }
   }
}

Você está usando Thread no programa de chat? Imagino que sim, por isso coloquei o metodo armazena como synchronized.

al.barbosa:

Jonas,

Estou enviando mais uma forma de fazer que talvez ajude. Imagino que você tenha uma classe Sala, ou algo parecido. Você quer ir armazenando usuarios na sala. Pode haver no máximo 5 usuarios, e ao incluir precisa testar se o usuario ja esta na sala.

import java.util.*;
import javax.swing.*;
public class Sala{
   private List<String> LISTA_DE_NOMES = new ArrayList<String>();  
      
   public synchronized boolean armazena(String newName) throws Exception { 
      if(LISTA_DE_NOMES.size()>=5){
         throw new Exception("Esta sala já esta cheia");
      }else if(LISTA_DE_NOMES.contains(newName)){
         throw new Exception("Este usuario já esta na sala.");
      }else{ 
         //adiciona na lista   
         LISTA_DE_NOMES.add(newName);
         return true;  
      }
   }

   public void listar(){
      System.out.println();
      System.out.println("Usuarios presentes na sala:");
      for(String nome : LISTA_DE_NOMES){
         System.out.println(nome);
      }
   }

   public static void main(String args[]){
      Sala sala = new Sala();
      while(true){
         String retorno = JOptionPane.showInputDialog(null, "Digite o nome do novo usuario.");
         if(retorno == null) break;    // Cancel na InputDialog
         try{
            sala.armazena(retorno);
         }catch(Exception e){
            JOptionPane.showMessageDialog(null, e.getMessage());
         }finally{
            sala.listar();
         }
      }
   }
}

Você está usando Thread no programa de chat? Imagino que sim, por isso coloquei o metodo armazena como synchronized.

Estou usando Vector CLIENTES;
Na sua observação ele não faz uma referencia para thread que deve ter uma consistencia para tratar LISTA_DE_NOMES.get(i), então eu tenho List para LISTA_DE_NOMES e ainda preciso jogar essas threads quando o metodo armazena for incluir em CLIENTES.add quando nomeCliente já existir !!!

public synchronized boolean armazena(String newName) throws Exception {   
      
    	for(int i=0;(LISTA_DE_NOMES.size()>=5);i++){
        	if(LISTA_DE_NOMES.get(i).equals(newName))
        	return true;
           throw new Exception("Esta sala já esta cheia");  
         
                      
        }  if(LISTA_DE_NOMES.contains(newName)){  
               throw new Exception("Este usuario já esta na sala.");
           
        }else{   
           //adiciona na lista     
           LISTA_DE_NOMES.add(newName);  
           return true;    
        }
     }

A Implementação e o uso de Vector para CLIENTES e LIST para LISTA_DE_NOMES

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
public class ServidorSocket extends Thread {
    // Parte que controla as conexões por meio de threads.
    private static Vector CLIENTES;
    // socket deste cliente
    private Socket conexao;
    // nome deste cliente
    private String nomeCliente;
    // lista que armazena nome de CLIENTES
   /* private static List LISTA_DE_NOMES = new ArrayList();*/
    private List<String> LISTA_DE_NOMES = new ArrayList<String>();
    // construtor que recebe o socket deste cliente
    public ServidorSocket(Socket socket) {
        this.conexao = socket;
    }
    public synchronized boolean armazena(String newName) throws Exception {   
      
    	for(int i=0;(LISTA_DE_NOMES.size()>=5);i++){
        	if(LISTA_DE_NOMES.get(i).equals(newName))
        	return true;
           throw new Exception("Esta sala já esta cheia");  
         
                      
        }  if(LISTA_DE_NOMES.contains(newName)){  
               throw new Exception("Este usuario já esta na sala.");
           
        }else{   
           //adiciona na lista     
           LISTA_DE_NOMES.add(newName);  
           return true;    
        }
     }  
        
     //remove da lista os CLIENTES que já deixaram o chat
    public void remove(String oldName) {
       for (int i=0; i< LISTA_DE_NOMES.size(); i++){
         if(LISTA_DE_NOMES.get(i).equals(oldName))
           LISTA_DE_NOMES.remove(oldName);
       }
    }
    public static void main(String args[]) {
        // instancia o vetor de CLIENTES conectados
        CLIENTES = new Vector();
        try {
            // cria um socket que fica escutando a porta 5555.
            ServerSocket server = new ServerSocket(5555);
            System.out.println("ServidorSocket rodando na porta 5555");
            // Loop principal.
            while (true) {
                // aguarda algum cliente se conectar.
                // A execução do servidor fica bloqueada na chamada do método accept da
                // classe ServerSocket até que algum cliente se conecte ao servidor.
                // O próprio método desbloqueia e retorna com um objeto da classe Socket
                Socket conexao = server.accept();
                // cria uma nova thread para tratar essa conexão
                Thread t = new ServidorSocket(conexao);
                t.start();
                // voltando ao loop, esperando mais alguém se conectar.
            }
        } catch (IOException e) {
            // caso ocorra alguma excessão de E/S, mostre qual foi.
            System.out.println("IOException: " + e);
        }
    }
    // execução da thread
    public void run()
    {
        try {
            // objetos que permitem controlar fluxo de comunicação que vem do cliente
            BufferedReader entrada = new BufferedReader(new InputStreamReader(this.conexao.getInputStream()));
            PrintStream saida = new PrintStream(this.conexao.getOutputStream());
            // recebe o nome do cliente
            this.nomeCliente = entrada.readLine();
            //chamada ao metodo que testa nomes iguais
            if (armazena(this.nomeCliente)){
              saida.println("Este nome ja existe! Conecte novamente com outro Nome.");
              CLIENTES.add(saida);
              //fecha a conexao com este cliente
              this.conexao.close();
              return;
            } else {
               //mostra o nome do cliente conectado ao servidor
               System.out.println(this.nomeCliente + " : Conectado ao Servidor!");
            }
            //igual a null encerra a execução
            if (this.nomeCliente == null) {
                return;
            }
            //adiciona os dados de saida do cliente no objeto CLIENTES
            CLIENTES.add(saida);
            //recebe a mensagem do cliente
            String msg = entrada.readLine();
            // Verificar se linha é null (conexão encerrada)
            // Se não for nula, mostra a troca de mensagens entre os CLIENTES
            while (msg != null && !(msg.trim().equals("")))
            {
                // reenvia a linha para todos os CLIENTES conectados
                sendToAll(saida, " escreveu: ", msg);
                // espera por uma nova linha.
                msg = entrada.readLine();
            }
            //se cliente enviar linha em branco, mostra a saida no servidor
            System.out.println(this.nomeCliente + " saiu do bate-papo!");
            //se cliente enviar linha em branco, servidor envia mensagem de saida do chat aos CLIENTES conectados
            sendToAll(saida, " saiu", " do bate-papo!");
            //remove nome da lista
            remove(this.nomeCliente);
            //exclui atributos setados ao cliente
            CLIENTES.remove(saida);
            //fecha a conexao com este cliente
            this.conexao.close();
        } catch (IOException e) {
            // Caso ocorra alguma excessão de E/S, mostre qual foi.
            System.out.println("Falha na Conexao... .. ."+" IOException: " + e);
        }
    }
    // enviar uma mensagem para todos, menos para o próprio
    public void sendToAll(PrintStream saida, String acao, String msg) throws IOException {
        Enumeration e = CLIENTES.elements();
        while (e.hasMoreElements()) {
            // obtém o fluxo de saída de um dos CLIENTES
            PrintStream chat = (PrintStream) e.nextElement();
            // envia para todos, menos para o próprio usuário
            if (chat != saida) {
                chat.println(this.nomeCliente + acao + msg);
            }
        }
      }
}

Jonas Backer,

Não entendi o for que você colocou no método armazena:

for(int i=0;(LISTA_DE_NOMES.size()>=5);i++){

Isso é para testar se a lista tem 5 elementos ou mais? Nesse caso não basta um if?

Se a questão é limitar a lista a no máximo 5 nomes, e não permitir incluir o nome se ele já existe, acredito que a forma abaixo resolva:

public void armazena(String newName) throws Exception { if(LISTA_DE_NOMES.size()>=5){ throw new Exception("O numero de nomes da lista ja chegou ao maximo"); }else if(LISTA_DE_NOMES.contains(newName)){ throw new Exception("Este nome ja existe! Conecte novamente com outro Nome."); }else{ //adiciona na lista LISTA_DE_NOMES.add(newName); } }

E dentro do método run() da classe ServidorSocket ficaria assim:

public void run()  
     {  
         try {  

         // .......

             this.nomeCliente = entrada.readLine();  
             try{
                armazena(this.nomeCliente);
                CLIENTES.add(saida);  
                //mostra o nome do cliente conectado ao servidor  
                System.out.println(this.nomeCliente + " : Conectado ao Servidor!");
             }catch(Exception e){
                saida.println(e.getMessage());
                //fecha a conexao com este cliente  
                this.conexao.close();  
                return;  
             }

       // ........

Dessa forma, se a lista estiver cheia ou o nome já existir, será lançada a Exception. A Exception será tratada no catch da seguinte forma: a mensagem de erro será colocada na saída e e a conexão (Socket) será fechada.

Você pode também criar classes de Exception personalizadas para as diferentes condições que podem ocorrer, e lançar exceções das classes personalizadas. Teriam vários catch, um para cada classe de Exception.

Fiquei em dúvida quanto ao synchronized.

Se alguém souber favor responder à dúvida: no exemplo do Jonas os métodos armazena e remove, dentro da classe ServidorSocket, devem ser synchronized? Ou só se os métodos armazena e remove estivessem em uma classe separada, compartilhada pelos threads?

Explicando melhor a classe separada que estou pensando: poderia haver uma classe separada para encapsular a lista de nomes, chamada por exemplo de ListaNomes. ListaNomes teria os métodos armazena e remove. Os novos Threads iriam receber o mesmo objeto da classe ListaNomes e iriam chamar armazena e remove nesse objeto. Os métodos armazena e remove de ListaNomes teriam que ser synchronized para evitar problemas de concorrência quando fossem chamados ao mesmo tempo por threads diferentes.

Jonas Backer,

Não entendi o for que você colocou no método armazena:

for(int i=0;(LISTA_DE_NOMES.size()>=5);i++){

Isso é para testar se a lista tem 5 elementos ou mais? Nesse caso não basta um if?

Estou disponibilizando, a aplicação para você fazer essa incrementação entretanto parece que não controlou a quantidade de usuário, excedeu !

Outra Versão do Chat dessa vez o Template aqui é de melhor visualização !!!

Tem outras classes que vou deixar , junto com o arquivo download para se fazer uma melhor analise !!!

Faz tempo que não via comentários em grego

Achei que “mporouse” fosse “browser” mas quer dizer “poderia” segundo o Google Translator. Aliás o Google Translator até me indicou como isso seria escrito em alfabeto grego - que interessante.

A tradução que ele deu é mais ou menos assim:

Como eu não sei grego, não consigo entender direito qual é a tradução correta.

entanglement:

Faz tempo que não via comentários em grego

//i vasiki klasi tou server gia epikoinonia me to client  
//perimeni minimata apo to client kai antidra analoga  
//exei prosvasi stous xristes tou server meso tou antikeinenou Vector clients tou server  
//tha mporouse na ine edo mesa to clients   
//alla etsi ekatse prota opote to afisa

Achei que “mporouse” fosse “browser” mas quer dizer “poderia” segundo o Google Translator. Aliás o Google Translator até me indicou como isso seria escrito em alfabeto grego - que interessante.

Eu achei que era em dinamarques ou noruegues :lol: , quando joguei no Google ele aproximou para esses idiomas , bom agora estou vendo que é Grego mesmo !!!

al.barbosa:

Jonas Backer,

Não entendi o for que você colocou no método armazena:

for(int i=0;(LISTA_DE_NOMES.size()>=5);i++){

Isso é para testar se a lista tem 5 elementos ou mais? Nesse caso não basta um if?

Se a questão é limitar a lista a no máximo 5 nomes, e não permitir incluir o nome se ele já existe, acredito que a forma abaixo resolva:

public void armazena(String newName) throws Exception { if(LISTA_DE_NOMES.size()>=5){ throw new Exception("O numero de nomes da lista ja chegou ao maximo"); }else if(LISTA_DE_NOMES.contains(newName)){ throw new Exception("Este nome ja existe! Conecte novamente com outro Nome."); }else{ //adiciona na lista LISTA_DE_NOMES.add(newName); } }

E dentro do método run() da classe ServidorSocket ficaria assim:

public void run()  
     {  
         try {  

         // .......

             this.nomeCliente = entrada.readLine();  
             try{
                armazena(this.nomeCliente);
                CLIENTES.add(saida);  
                //mostra o nome do cliente conectado ao servidor  
                System.out.println(this.nomeCliente + " : Conectado ao Servidor!");
             }catch(Exception e){
                saida.println(e.getMessage());
                //fecha a conexao com este cliente  
                this.conexao.close();  
                return;  
             }

       // ........

Dessa forma, se a lista estiver cheia ou o nome já existir, será lançada a Exception. A Exception será tratada no catch da seguinte forma: a mensagem de erro será colocada na saída e e a conexão (Socket) será fechada.

Você pode também criar classes de Exception personalizadas para as diferentes condições que podem ocorrer, e lançar exceções das classes personalizadas. Teriam vários catch, um para cada classe de Exception.

Fiquei em dúvida quanto ao synchronized.

Se alguém souber favor responder à dúvida: no exemplo do Jonas os métodos armazena e remove, dentro da classe ServidorSocket, devem ser synchronized? Ou só se os métodos armazena e remove estivessem em uma classe separada, compartilhada pelos threads?

Explicando melhor a classe separada que estou pensando: poderia haver uma classe separada para encapsular a lista de nomes, chamada por exemplo de ListaNomes. ListaNomes teria os métodos armazena e remove. Os novos Threads iriam receber o mesmo objeto da classe ListaNomes e iriam chamar armazena e remove nesse objeto. Os métodos armazena e remove de ListaNomes teriam que ser synchronized para evitar problemas de concorrência quando fossem chamados ao mesmo tempo por threads diferentes.

Na assinatura do método “armazena” ele retorna boolean, mas na sua implementação ou ele retorna true ou lança exceção, e nunca retorna false. Não tem porque ser boolean nesse caso. Pode ser void, mesmo.

No método “remove” tanto o “for” quanto o “if” estão sobrando, basta delegar a chamada ao método “remove” do ArrayList e ele remove o objeto se ele estiver presente na coleção. Aliás, esse método também tem ser sincronizado.

Fonte

The way you are handling that code, you are not using the List as a List. You are actually using it as a Set, because you are not permitting duplicates. Do you require a Set which does not support duplicates, in combination with recording the order of insertion. If so, go through the Java Tutorials. You will find all sorts of implementations, including one which combines a linked list and a Set. That might provide what you want all in one class.

ViniGodoy:

Mude essa linha:
Embora, se isso aí é para sua aplicação socket, bastaria simplesmente não inserir mais de 5 elementos no list e deixar somente:

for (int i=0;i < LISTA_DE_NOMES.size(); i++){

Ou usar o for each.

[RESOLVIDO] java.util.ArrayList.rangeCheck [Resolvido pelo JavaRanch]

Program condition Cha Java does not work for five elements inserted in the List