Estrutura de dados com Java

Estrutura de dados com Java

Arrays : Classe Vetor       Definição Adicionar elemento no final do vetor  Verificar quantidade de elementos no vetor Imprimir elementos do vetor Obter elementos de uma posição Adicionando elemento em qualquer posição do Vetor Adicionar mais capacidade ao vetor Remover elemento do vetor Generalizar os tipos dos elementos Definindo o tipo do vetor dinamicamente  API Java ArrayList             

" Um vetor (ou array ) é a estrutura de dados mais simples que existe. Um vetor armazena uma sequência de valores onde todos são do mesmo tipo."          - Loiane Groner Um exemplo simples em Java, temos as seguintes informações: double temperaturaDia1 = 33.4 ; double temperaturaDia2 = 37.9; E assim vai ...   A primeira posição será destinada a temperaturaDia1 e a segunda posição a temperaturaDia2 ;  

Definição

Continuando o exemplo da primeira página um array segue uma  coleção de itens, sendo assim elaborando um array de temperatura dos dias do ano teremos 365 ou 366 itens registrados neste array.  double[] temperatura = new  double[365]   // cria-se o array temperatura[0] = 31.3 ;   // a primeira temperatura é adicionada  temperatura[1] = 32.3;  // a segunda temperatura é adicionada na posição de index 1 temperatura[2] = 44.0;  Sendo assim podemos acessar as posições de 0 a 364.    

Para se ter acesso aos valores de qualquer posição devemos declarar o nome do array mais o index desejado ( temperatura[ index] ). Para se ter acesso ao tamanho desse array utilizamos o método length ( temperatura.length ). Utilização de array em uma estrutura de repetição: for( int index = 0 ; index< temperatura.length; index++) {                      System.out.println( temperatura[index]); } O que está ocorrendo aí em cima ?? Na estrutura for é passado , em primeiro lugar, uma variável e seu valor inicial , a condição de limite desta variável , ou seja, até onde pode-se incrementa-la ( este limite é dado pelo tamanho total do array ) e logo depois o último parâmetro é o incremento desta variável.  Então dentro da estrutura é passado o comando de impressão System.out.println( )  Outro modo de se fazer uma outro tipo de iteração melhorada : for (double temp: temperaturas){ System.out.print( ) }

A IDE - Integrated Development Environment  empregada será o Eclipse , sendo assim para fins práticos de acessar, adicionar, remover e mudar elementos de um vetor. Criaremos um package ( pacote ) com uma classe denominada Vetor ( lembrando: começo letra maiúscula) .  Criando uma pasta bin ( Um pasta bin é uma pasta do sistema, com arquivos já compilados , não conseguimos trabalhar diretamente com estes arquivos).  cod: ( Simbologia para inicialização de código) package estrutura_de_dados_loine; public Vetor(){       private String[ ] elementos; // criamos um array tipo string denominado elementos       public Vetor( int capacidade ){                      // criamos um construtor passando a capacidade de elemento que se deseja criar                 this.elementos = new String[capacidade];          }  } Teste1 cod:  import package public Teste1{     public static void main(String[] args){         Vetor vetor = new Vetor(5);         int i = 0;         i++;      } }        

Adicionar um elemento no Vetor

Como fazer para se adicionar um elemento no vetor ? Por padrão quando instanciamos um vetor em java, quando o tipo primitivo é String, o valor dos elementos é null. ( Para o tipo boolean é false; para tipo inteiro é 0 ) .  O que se faz é iterar o vetor e verificar se a posição deseja  a adicionar está vazia - disponível para poder ser usada. ( null ). Vetor  cod: public Vetor(){       private String[] elementos;       public Vetor(int capacidade){                this.elementos = new String[capacidade];       }       public void adiciona( String elemento){       // Você sabe para que serve o void ? Quando não tem de retornar nenhum valor.               for(int i = 0; i < this.elementos.length ; i ++){                     if(  elementos[i] == null){                             elementos[i] = elemento;                             break;   // Finaliza a iteração                      }                  }  }  Teste2 cod: public Teste2{      public static void main(String[] args) {            Vetor vetor = new Vetor(5);            vetor.adiciona(" Inseto");            vetor.adicicona(" Animal");            vetor.adicona("Seres humanos");       } } Mas esse algoritmo é eficiente? Nem tanto, imagine um array com milhares, milhões de elementos não seria tão interessante já que a iteração tem de passar por todos as posições até achar uma vazia. cod:  public Vetor{      private String[] elementos;      private int tamanho;      public Vetor( int capacidade) {                      this.elementos = new String[ capacidade];                       this.tamanho = 0;       }      public void adiciona( String elemento){                      this,elementos[this.tamanho] = elementos;                       this.tamanho++;       } }    A função adiciona nos ajuda agora, mas ainda não está completa. Caso o tamanho do array atinge o ilimite o que ocorre ? Dá erro. " Exception thread "main" " O que está ocorrendo ? Devemos interromper o adicionamento de um elemento no array quando o tamanho do mesmo for excedido. Precisa-se de uma verificação. cod.: public Vetor{      private String[] elementos;      private int tamanho;           // podemos utiliza esse atributo como tamanho real do vetor.      public Vetor( int capacidade ) {                 this.elementos = new String[ capacidade ];                 this.tamanho = 0;      }      public void adiciona( String elemento){                 if( this.tamanho < this.elementos.length ) throws Exception{                        this.elementos[ this.elementos ] = elemento;                        this.tamanho ++;                 } else{                        throw new Exception( " O Vetor está cheio, não temos como adicionar mais nada" ) ;                }       } } cod.: Teste2 public Teste2{       public static void main( String[] args ) {                Vetor vetor = new Vetor( 3) ;                try{                       vetor.adiciona( " Inseto ");                       vetor.adiciona("Animal");                       vetor.adiciona("Seres humanos");               }catch  ( Exception e ) {                        e.printStackTrace();                }       } } Outra opção seria colocar um booleano para a verificação : public boolean adiciona( String elemento) {      if ( tamanho < elementos.length) {                    elementos[tamanho] = elemento;                    this.tamanho++;                    return true;      }      return false; }  

Tamanho e imprimir elementos

Nessa etapa o objetivo é avaliar, determinar o tamanho do array. Como ?  cod.:  public Vetor{        private String[] elementos;        public int tamanho;        public Vetor(int capacidade){             this.elementos = new Vetor[capacidade];              this.tamanho = 0;       }        publc void adiciona( String elemento ){               if( this.tamanho < this.elementos.length ) throws Exception{                              this.elementos[this.tamanho] = elemento;                               this.tamanho++;                               } else{                               throw new Exeption( "  O vetor atingiu o limite ");         }         public int tamanho(){                             return this.tamanho;         } }   Foi criado um método para expor a variável tamanho.  Pode ser nomeado "getTamanho" também.  Não desejamos que o usuário modifique a variável tamanho, ela será utilizada somente internamente.  

Imprimir elementos do array   No java há uma classe utilitária Arrays que possibilita a manipulação de vetores. Essa classe possui o método toString que retornar todos os elementos do array. cod.:  public Vetor{            private String[] elementos;            public int tamanho;            public Vetor(int caplacidade){                   this.elementos = new Vetor[capacidade];                   this.tamanho = 0;            }            public void adiciona( String elemento ){                    if( this.tamanho< this.elementos.length ) throws Exception {                             this.elementos[ this.tamanho] = elemento;                             this.tamanho++;                    }else{                             throw new Exception( " O vetor está cheio ");            }             public int tamanho() {                          return this.tamanho;             }            public String toString() {                         return Arrays.toString(elementos); } } Porém ao executar o toString no teste temos um problema,  havendo espaço vazios , ou seja null, também serão impressos. Sendo assim vamos desenvolver uma meio de retirar esses espaços vazios por iteração.  cod.: plublic String toString() {              String s = "["              for( int i = 0;  i< this.tamanho.length-1 ; i++) {                      s+= this.elementos[i];                      s+= ", ";              }              if (this.tamanho>0){                      s+= this.elementos[this.tamanho-1];              }              s+= " ]";              return Arrays.toString(elementos); }   Porém essa concatenação não é a maneira mais eficiente. Ao invés de utilizar a concatenação o java tem uma classe específica para isso StringBuilder:    cod.:   public String toString(){           StringBuilder s = new StringBuilder();           s.append(" [");           for(int i = 0 ; i< this.tamanhos -1; i++) {                     s.append( this.elementos[i] );                     s.append( " , ") ;           }           if( this.tamanho>0) {                     s.append( this.elementos[ this.tamanho-1]  );                     s.append (" ]");             }            return s.toString();  }     fonte : https://youtu.be/VyOihAHcigY  

Obter o elemento de uma posição

Criaremos uma novo método chamado busca, esse método possui como retorno tipo String, já que, o vetor é declarado como String . Sendo assim temos: cod.: public Vetor{            private String[] elementos;             public int tamanho;             public Vetor( int capacidade) {                     this.elementos = new Vetor( capacidade );                      this.tamanho = 0;              }               public void adiciona( String elemento) {                      if( this.tamanho< this.elementos.length) throws Exception {                                this.elementos[ this.tamanho] = elemento;                                 this.tamanho++;                      }else{                                throw new Exception ( " O vetor atingiu seu limite");                      }              public String busca( int posicao){                              return this.elementos[posicao];               }               public int tamanho() {                             return this.tamanho;                }                public String toString() {                          StringBuilder s = new StringBuilder();                           s.append(" [ ");                           for( int i = 0; i< this.tamanho-1; i++){                                      s.append( this.elementos[ i] );                                      s.append(", ");                           }                           s.append(" ] ");                           return s.toString();                } } Contudo há um problema em fazer o método busca dessa forma , sem verificação, como não se sabe qual valor de posição o usuário deseja acaba que o valor passado pode dar erro caso esteja fora do tamanho do array ou pode retornar um número vazio. Sendo assim há necessidade de tratarmos esse método de busca.

cod.:  public String busca( int posicao) {             if( !(posicao>= 0 && posicao>                       throw new IllegalArgumentException( " Posição Inválida" );               }             return this.elementos[ posicao ] ; } Sendo feito o tratamento pode-se notar novo tipo de exceção especial para este cado. IllegalArgumentException que será executado quando o valor da posição passada pelo usuário não estiver dentro do intervalo do tamanho do array. Caso contrário será retornado o valor da posição normalmente. Nota-se que estamos falando do tamanho real e não do tamanho do array, dessa forma os elementos vazios não são retornados.   fonte: https://youtu.be/SiIhY6mj2xk      

Verificar se elemento existe no Vetor

cod.: public Vetor{     private String[] elementos;     public int tamanho;     public Vetor(int capacidade){          this.elementos = new String[capacidade];           this.tamanho = 0;     public void adiciona( string elemento){           for( int i = 0; i< this.elementos.length; i++){                    if( this.tamanho< this.elementos.length){                               this.elemento[i] = elemento;                               this.tamanho++;                    }      public String busca( int posicao) {                   if(! (  posicao>=0 && posicao                           throw new IllegalArgumentException( " Posição inválida ");                  }                  return this,elementos[ posicao];           }      }      public int tamanho(){          return this.tamanho;              }      public String toString() {          StringBuilder s = new StringBuilder;           s.append( " [ ");           for( var i = 0;  i< this.tamanho-1; i++) {                    s.append( this.elementos[i]);                    s.append( " , ");            }            if( this.tamanho>0) {                     s.append( this.elementos[this.tamanho-1];             }            s.append( " ]");     } }   Se quisermos determinar se um certo elemento existe ou não dentro de uma determinada coleção podemos retornar um booleano.  cod.: public    boolean busca( String  elemento){       for( var i = 0 ; i                if(this.elementos[i].equals( elemento){                         return true;                 }       return false; }  Vamos analisar agora oque ocorre:  A solução mais simples é uso da busca sequencial, verificação de cada elemento um a um. É evidenciado pela estrutura de repetição for. A cada posição é feito uma verificação por meio do método equals, não se pode utilizar o operador relacionacinal "=="    pois o tipo String trata-se de um Objeto.  Caso o valor da posição seja igual ao valor do elemento então o retorno é true. cod.: public  int busca( String  elemento){       for( var i = 0 ; i                if(this.elementos[i].equals( elemento){                         return i;                 }       return -1; }   Este último código é um jeito mais elegante de se usar o a busca sequencial, temos então o retorno da posição caso o elemento esteja na coleção e o retorno de -1 caso contrário.     fonte: https://youtu.be/oWP0UBepjVI           

Adicionar Elemento em um vetor, em qualquer posição.

Nós temos um vetor com 10 posições e desejamos colocar o "A" na posição 0. Contudo de 0 ao index 4 estão ocupados. Sendo assim não podemos sobrescrever o elemento da posição 0. [ "B" , "C" , "D" , "E" , "F" , null, null, null , null , null ]     0      1      2       3      4      5        6       7       8        9     Sendo assim para a letra "A" ser inserida na posição 0 temos que mover todos os elementos. [ "B" , "C" , "D" , "E" , "F" , "F", null, null , null , null ] [ "B" , "C" , "D" , "E" , "E" , "F", null, null , null , null ] [ "B" , "C" , "D" , "D" , "E" , "F", null, null , null , null ] [ "B" , "C" , "C" , "D" , "E" , "F", null, null , null , null ] [ "B" , "B" , "C" , "D" , "E" , "F", null, null , null , null ] [ "A" , "B" , "C" , "D" , "E" , "F", null, null , null , null ]   Nota-se que foi feita uma iteração do final do tamanho ao começo da lista deslocando os elementos, até a posição 0 que é adicionado o novo elemento.   Repare que o tamanho do vetor aumentou. cod.: // overload do método adiciona   public boolean adiciona( int posicao, String elemento){          if(!( posicao >=0  && posicao                  throw new IllegalArgumentException ( " Posicao inexistente");   // Ver se a posição é válida          }          for( int i = this.tamanho-1; i > posicao; i-- ){                 this.elementos[ i +1 ] = this.elementos[ i  ];           }          this.elementos[posicao] = elemento;          this.tamanho++;          // Atualizando o tamanho          return false;             }   Veja como é simples inserir um elemento em qualquer posição dentro do limite do vetor. Também podemos colocar void como tipo para não ser retornado nada.            

Aumentando capacidade do vetor

Necessitamos aumentar o vetor dinamicamente, ou seja, de acordo com o que a gente precisa.  Então o que acontece,  se a capacidade do nosso vetor estourar nós iremos aumentar a sua capacidade. Para isso cria-se um novo vetor passando todos os elementos do vetor antigo para o novo. cod .: public Vetor{      private String[] elementos;      private String[]  elementosNovos;      public int tamanho;      public Vetor( int capacidade ) {          this.elementos = new String( capacidade);          this.tamanho = 0;      }       public void adiciona( String elemento ){           aumentaCapacidade( );           if( this.tamanho< this.elementos.length) throws Exception{                  this.elementos[ this.tamanho] = elementos;                  this.tamanho++;            } else {                throw new Exception( " Limite do vetor atingido");                      }         }                   private void aumentaCapacidade( ) {                 if( this.tamanho == this.elementos.length ) {                      String[] elementosNovos = new String[ this.elementos.length *2]; // instanciamos um novo vetor                  };                  for( int i =  0; i< this.tamanho;  i++ ) {                         this.elementosNovos[i] = this.elementos[i] ;                  };                   this.elementos = this.elementosNovos;         }                  public boolean adiciona( int posicao, String elemento){              aumentaCapacidade( ) ;              if(!( posicao >=0  && posicao                     throw new IllegalArgumentException ( " Posicao inexistente");   // Ver se a posição é válida               }               for( int i = this.tamanho-1; i >= posicao; i-- ){                    this.elementos[ i +1 ] = this.elementos[ i  ];                }                this.elementos[posicao] = elemento;                 this.tamanho++;          // Atualizando o tamanho                 return false;                             }         public String busca( int posicao){              if( !( posicao>= 0 && posicao< this.tamanho){                    throw new IllegalArgumentException( " Tamanho inválido ");               }               return this.elementos[ posicao];           }           public int busca( String elemento){                 if( !( posicao>= 0 && posicao< this.tamanho){                         throw new IllegalArgumentException( " Tamanho inválido ");                 }                  for( int i = 0;  i< this.tamanho; i++) {                        if( this.elementos[i].equals( elemento)){                               return i;                         }                      }                return -1;                 }              public int tamanho(){               return this.tamanho();             }             public String toString() {                    StringBuilder s = new StringBuilder();                    s.append = " [ " ;                    for( int i = 0;  i< this.tamanho -1 ; i++) {                          s.append( this,elemento[ i ]);                          s.append( " , ");                     }                     if( this.tamanho>0){                          s.append( this,elementos[ this.tamanho]);                      }                      s.append( " ]") ;                       return s.toString() ;            } }

Analisando: cod.:     private void aumentaCapacidade( ) {                 if( this.tamanho == this.elementos.length ) {                      String[] elementosNovos = new String[ this.elementos.length *2]; // instanciamos um novo vetor                  }                  for( int i =  0; i< this.tamanho;  i++ ) {                         this.elementosNovos[i] = this.elementos[i] ;                  }                   this.elementos = this.elementosNovos;         }   Foi criado um novo método interno aumentaCapacidade(), se o tamanho em que nos encontramos no vetor for igual ao tamanho do vetor, ora está prestes a estourar ( overload ). Sendo assim criamos um novo vetor o instanciando com o dobro da capacidade do primeiro vetor e o denominamos de elementosNovos. Mas por que o dobro? É a melhor forma sempre iremos garantir que nosso vetor pode crescer mais, logo o dobrando a preocupação acaba. Se pensarmos em acrescentarmos só mais um espaço a eficiência não será tão garantida, já que, toda vez que houver necessidade de apenas mais um espaço vamos estar criando um vetor inteiro. Influência na performance e no custo. Logo depois iteramos o vetor antigo e então copiamos seus elementos para o novo vetor. Por fim atribuímos o vetor novos ao antigo.   this.elementos = this.elementosNovos; Todos os métodos que possuem a função de adicionar elemento no vetor devemos empregar o método aumentarCapacidade() internamente.   fonte: https://youtu.be/LfeHU9Z09sA  

Remover elemento do vetor

Empregaremos a mesma lógica aplicada ao adicionar elemento :   [ "A","B","C","D","E","F", null, null, null, null ]     0    1    2     3    4    5      6       7      8     9 Notemos que o tamanho do vetor é 5. Desejamos remover a letra "B" que encontra-se na posição 1, o sobrescrevemos com o conteúdo anterior. [ "A","C","C","D","E","F", null, null, null, null ] [ "A","C","D","D","E","F", null, null, null, null ] [ "A","C","D","E","E","F", null, null, null, null ] [ "A","C","D","E","F","F", null, null, null, null ]   Atualizando o tamanho do vetor temos o valor de 4. Contudo podemos verificar que ficou um resquício que chamaremos de lixo ao final da lista. Mas não tem o menor problema desde que atualizemos o tamanho. A posição 5 é ignorada. cod.: public Vetor{       private String[] elementos;       private String[] elementosNovos;       public int tamanho;       public String Vetor( int capacidade){             this.elementos = new String( capacidade);             this.tamanho = 0;       }       public void adiciona( String elemento) {           if( this.tamanho< this.elementos.length) throws Exception{                   this.elementos[ this.tamanho] = elemento;                   this.tamanho++;           } else{                   throw new Exception( " Overload " );                   }          public void adiciona( int posicao, String elemento){                  if( !( posicao>=0 && posicao< this.tamanho) {                        throw new IllegalArgumentException( " Posição Inválida" );                  }                  for( int i = this.tamanho-1 ; i< posicao; i--) {                        this.elementos[ this.tamanho +1 ] = this.elementos[ i ];                  }                  this.elementos[ posicao ] = elemento;                  this.tamanho++;               }            public aumentarCapadade() {               if( this.tamanho == this.elementos.length){                        String elementosNovos = new String[ this.elementos.length*2 ];                        for( int i = 0;  i< this.tamanho; i++){                               this.elementosNovos[ i ] = this.elementosNovos[ i ] ;                         }                         this.elementos= this.elementosNovos;                  }                         }          public int busca( String elemento) {           for( int i = 0; i< this.tamanho; i++) {                 if( this.elementos[i].equals( elementos ){                         return i;                 }                 return -1;                }        public String toString() {                   StringBuilder s = new StringBuilder;                   s.append( " [");                   for( int i = 0 ; i < this.tamanho-1; i++){                          s.append( this.elementos[ i ] ) ;                          s.append( " , ");                    }                   if( this.tamanho > 0) {                         s.append( this.elementos[ this.tamanho] );                    }                    s.append( "]");                    return s.toString();                   }                  }   cod.: Principal public void remove( int posicao) {      if( !( posicao>=0 && posicao< this.tamanho) {           throw new IllegalArgumentException( " Posição Inválida" );      }      for( int i = posicao ; i< this.tamanho-1 ; i++) {             this.elementos[ i ] = this.elementos[ i + 1 ];      }      this.tamanho--; } Como o uso de if ( !( posicao ... é recorrente ele pode ser transformado em um método.    fonte: https://youtu.be/_nZvr7-njEU

Gerenalizar o tipo do vetor

Pode haver alguns casos de projetos que devemos deixar as classes genéricas para que ela possa funcionar com qualquer tipo de dado e classe do java. A super classe, classe mãe, classe pai  de todas as classes do java é a classe object.   Criaremos então uma nova classe:   cod.:    public VetorDeObjetos{       private Object[] elementos;       private Object[] novosElementos;       public int tamanho;       public Object Vetor( int capacidade){             this.elementos = new String( capacidade);             this.tamanho = 0;       }       public void adiciona( Object elemento) {           aumentaCapacidade();           if( this.tamanho< this.elementos.length) throws Exception{                   this.elementos[ this.tamanho] = elemento;                   this.tamanho++;           } else{                   throw new Exception( " Overload " );                   }          public void adiciona( int posicao, Object elemento){                  aumentaCapacidade() ;                   if( !( posicao>=0 && posicao< this.tamanho) {                        throw new IllegalArgumentException( " Posição Inválida" );                  }                  for( int i = this.tamanho-1 ; i< posicao; i--) {                        this.elementos[ this.tamanho +1 ] = this.elementos[ i ];                  }                  this.elementos[ posicao ] = elemento;                  this.tamanho++;               }       public void remove( int posicao ) {                if( !( posicao>= 0 && posicao< this.tamanho) {                        throw new lllegalArgumentException( " Posição Inválida ");                 }                 for( var i = posicao ; i< this.tamanho ;  i++){                         this.elementos[ i ] = this.elemento[ i+1 ];                  }                   this.tamanho--;        }            public aumentarCapadade() {                  if( this.tamanho == this.elementos.length) {                          Object novosElementos = new Object[ this.elementos.length*2 ] ;                           for( int i = 0; i < this.tamanho ; i++){                                 novosElementos[ i ]  = this.elementos[ i ];                           }                           this.elementos  = this.novosElementos;                  }              }          public int busca( Object elemento) {           for( int i = 0; i< this.tamanho; i++) {                 if( this.elementos[i].equals( elementos ){                         return i;                 }                 return -1;                }       public int tamanho(){              return this.tamanho;        }        public String toString() {  // Não há modificação ;                   StringBuilder s = new StringBuilder;                   s.append( " [");                   for( int i = 0 ; i < this.tamanho-1; i++){                          s.append( this.elementos[ i ] ) ;                          s.append( " , ");                    }                   if( this.tamanho > 0) {                         s.append( this.elementos[ this.tamanho] );                    }                    s.append( "]");                    return s.toString();                   }                  }

Teste: cod.:  public Teste10{        public static void main( String[] args) {                  VetorDeObjetos  vetor = new VetorDeObjetos( 3 ) ;                   vetor.adiciona( 3 ) ; // poderia ser double, String, char ...                  vetor.adiciona( 4 ) ;                  vetor.adiciona( 6 ) ;                  System.out.println( " O tamanho é " + vetor.tamanho);                  System.out.println(  vetor );          }                     Esse processo destacado de passarmos um tipo primitivo e ele ser transformado em um objeto é autoboxing no java.  Autoboxing - https://www.devmedia.com.br/autoboxing-e-unboxing-em-java/28620 Classes Wrapper - https://www.devmedia.com.br/wrappers-em-java-aprenda-como-utilizar/30275    

Vamos criar agora uma classe teste,  cod.: public class Contato{         private String nome;         private String tel;         private String email;          public Contato( String nome, String telefone, String email) {                  super();                  this.nome = nome;                  this.tel = telefone;                  this.email = email;         }         public  Contato(){ }         public String getNome(){                return this.nome;          }          public void setNome( String nome){                  this.nome = nome;          }          public String getTel( ){                 return this.tel;           }           public void setTel( String telefone) {                  this.tel = telefone;           }           public String getEmail( ) {                  return this.email;            }            public void setEmail( String email){                   this.email = email;            }            public String toString() {                   return " Contato[ Nome: " + this.nome +", " + " Telefone: " + this.tel + " Email: "+ this.email + "]" ;             } }   cod.: teste public class Teste10{      public static void main( String[] args ) {                 VetorDeObjetos  vetor = new VetorDeObjetos( 3 );                  Contato c1 = new Contato( "Fabio" , "4444-4444", "fabio@gmail.com");                  Contato c2 = new Contato( "Pedro" , "6236-1234", "pedro@gmail.com");                  Contato c3 = new Contato( "Francisco" , "7162-2734", "chico@gmail.com");                  vetor.adiciona( c1 );                  vetor.adiciona( c2 );                  vetor.adiciona( c3 );                   int pos = vetor.busca( c2 );                   if( pos > -1 ) {                         System.out.println( "Elemento Existe no vetor");                   }else{                         System.out.println( "Elemento não Existe no vetor");                    }                   System.out.println( vetor);        fonte: https://youtu.be/SgPkuX4_IEo

Definindo o tipo de vetor dinamicamente

cod.:  public class Teste11{        public static void main( String[] args ){                VetorDeObjetos vetor = new VetorDeObjetos( 2);                 vetor.adiciona( 2 );                 vetor.adiciona( " Estamos adicionando mais " );                System.out.println( vetor );          } } Esse código será executável. Mas a definição de vetor diz que todos os elementos devem ser do mesmo tipo, logo esse algoritmo montado não adequa a definição. Sendo assim devemos conseguir de alguma forma declarar esse vetor ou lista ou array de maneira genérica para trabalharmos com qualquer outro tipo. Sem quebrar o conceito de estrutura de dados.

Generix - uma funcionalidade do java 5 Onde podemos na declaração do nosso vetor passar o tipo class que queremos que esse vetor trabalhe. Vamos criar outra classe. cod.:    public class Lista <T> {   // essa é a simbologia do generix <> " diamond" internamente temos o T que significa class Type.       private T[] elementos;   // temos de deixar nosso tipo dinâmico por isso substituimos pela simbologia de tipo       private T[] novosElementos;       public int tamanho;         // Reflection no java é uma API que nos permite acessar dinamicamente classes e atributos.        // Mas por hora  precisamos saber que em instanciação isso ( this.elementos = new T[ capacidade] ; ) não é permitido no java.             public Lista( int capacidade){   // para podermos instanciar um vetor dinamicamente no java             this.elementos = (<T>) new Object( capacidade); // Essa é uma solução simples do effective java fazer o casting.             this.tamanho = 0;       }        // Está é a segunda forma que para podermos instanciar um construtor         public Lista( int capacidade, Class <T> tipo Classe) {                 this.elementos = (T[]) Array.newInstance(TipoClasse, capacidade);                 this.tamanho = 0;         }              public void adiciona( T elemento) {  // tipo T genérico ( casting )            aumentaCapacidade();           if( this.tamanho< this.elementos.length) throws Exception{                   this.elementos[ this.tamanho] = elemento;                   this.tamanho++;           } else{                   throw new Exception( " Overload " );                   }          public void adiciona( int posicao, T elemento){                  aumentaCapacidade() ;                   if( !( posicao>=0 && posicao< this.tamanho) {                        throw new IllegalArgumentException( " Posição Inválida" );                  }                  for( int i = this.tamanho-1 ; i< posicao; i--) {                        this.elementos[ this.tamanho +1 ] = this.elementos[ i ];                  }                  this.elementos[ posicao ] = elemento;                  this.tamanho++;               }       public void remove( int posicao ) {                if( !( posicao>= 0 && posicao< this.tamanho) {                        throw new lllegalArgumentException( " Posição Inválida ");                 }                 for( var i = posicao ; i< this.tamanho ;  i++){                         this.elementos[ i ] = this.elemento[ i+1 ];                  }                   this.tamanho--;        }            public aumentarCapadade() {                  if( this.tamanho == this.elementos.length) {                          T[] novosElementos = ( T[] ) new Object[ this.elementos.length*2 ] ;                           for( int i = 0; i < this.tamanho ; i++){                                 novosElementos[ i ]  = this.elementos[ i ];                           }                           this.elementos  = this.novosElementos;                  }              }          public int busca( T elemento) {           for( int i = 0; i< this.tamanho; i++) {                 if( this.elementos[i].equals( elementos ){                         return i;                 }                 return -1;                }       public int tamanho(){              return this.tamanho;        }        public String toString() {  // Não há modificação ;                   StringBuilder s = new StringBuilder;                   s.append( " [");                   for( int i = 0 ; i < this.tamanho-1; i++){                          s.append( this.elementos[ i ] ) ;                          s.append( " , ");                    }                   if( this.tamanho > 0) {                         s.append( this.elementos[ this.tamanho] );                    }                    s.append( "]");                    return s.toString();                   }                  }   Desse maneira temos uma classe genérica que vai apenas permitir um tipo. Pré-finido no código principal. Lista<String> vetor = new Lista<String>( 3 ) ;  Sendo assim será permitido apenas String;

API ArrayList

Como utilizar a classe nativa do Java ArrayList?  Collection são a maioria das estruturas de dados prontos. Na vida real ninguém emprega os algoritmos anteriormente istos emprega-se o ArrayList. cod.:  public class Test12{       plublic static void main( String[] args){            ArrayList arraylist = new  ArrayList<String>();  // Veja podem não passar absolutamente nada ( a capacidade) o tamanho é aumentando a medida que adicionamos            arraylist.add ("A");            arraylist.add( "B");  // função de adicionar.            System.out.println( arraaylist);            arraylist.add( 1, "C"); // Neste caso passamos o posição onde desejamos adicionar o novo elemento;            System.out.println( arraylist );             boolean exist = arraylist.contains( "A"); // Um método semelhante ao busca retornando um true ou false            if( exitt){                 System.out.println( "Elemento presente na list");             }else{                 System.out.println( " Elemento não existe na lista");            arraylist.indexOf( " B");  // Retorna a posição do elemento caso não exista seu valor é -1.            System.out.println( arraylist.get( 1) );  // Retorna o valor da posição indicada caso exista.            arraylist.remove( 1 )             arraylist.remove( "A" ); // Pode-se remover por posição ou por elemento;           System.out.println( arraylist.size() );          }   }

Pronto temos as mesmas funcionalidades das classes criada anteriormente. O código na documentação do ArrayList é diferente mas temos os mesmos fins.   fonte: https://youtu.be/8gAyHJKugGw