Loading ...
Sorry, an error occurred while loading the content.

Re: [riojug] Construtores

Expand Messages
  • Carlos Miranda
    Uma outra utilidade seria o controle do número de instâncias, através do famoso Singleton ; ) Abçs, Carlos. ... Uma outra utilidade seria o controle do
    Message 1 of 25 , Mar 30, 2006
    • 0 Attachment
       
      Uma outra utilidade seria o controle do número de instâncias, através do famoso Singleton ; )
       
      Abçs,
      Carlos.
       
       
      On 3/30/06, wandersonaldo <aldo_asquatro@...> wrote:
      Eu li que os construtores são apenas para iniciar os membros de um
      objeto recém criado.

      Pergunta, eles teriam outras utilidades, técnicas, etc...





      -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      Rio Java Users Group    www.riojug.org
      E-mail dos Moderadores   riojug-owner@yahoogroups.com

      Patrocínio: Quality Software, SENAC-Rio CIT, Locaweb
      Apoio: Java Magazine, SQL Magazine
      -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      Participe também das outras listas do RioJUG:
      SCJP (groups.yahoo.com/group/scjp_riojug)
      SCWCD (groups.yahoo.com/group/scwcd_riojug)
      -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      Yahoo! Groups Links

      <*> To visit your group on the web, go to:
         http://groups.yahoo.com/group/riojug/

      <*> To unsubscribe from this group, send an email to:
         riojug-unsubscribe@yahoogroups.com

      <*> Your use of Yahoo! Groups is subject to:
         http://docs.yahoo.com/info/terms/





    • Gilberto Oliveira
      Pessoal tenho uma dúvida para construtores. Para criar um objeto sempre fiz: NomeClasse nc = new NomeClasse(); Isso criava um objeto sob a referência nc
      Message 2 of 25 , Feb 12, 2007
      • 0 Attachment
        Pessoal
         
        tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
         
        NomeClasse nc = new NomeClasse();
         
        Isso criava um objeto sob a referência nc correto?
         
        Estudando a classe String, verifiquei que é possível fazer:
         
        String str = "Minha String";
         
        Isso por sí só cria um objeto String "MinhaString", sob a referência 'str'.
        Também da pra fazer do jeito clássico:
         
        String st = new String ("Minha String st").
         
        Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
         
        Pergunta:
         
        a) Isso só pode ser feito com classes empacotadoras?Se não, podem me dar um exemplo com outra classe?
        b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
         
        Abraços

        __________________________________________________
        Fale com seus amigos de graça com o novo Yahoo! Messenger
        http://br.messenger.yahoo.com/

      • Bruno Carlo
        Ola Gilberto, Este tipo de construção, ex.: String str = ola mundo é específica da classe java.lang.String, nas demais vc tem que usar o construtor, isto
        Message 3 of 25 , Feb 12, 2007
        • 0 Attachment
          Ola Gilberto,

          Este tipo de construção, ex.:
          String str = "ola mundo" é específica da classe java.lang.String, nas demais vc tem que usar
          o construtor, isto foi feito assim como uma forma de facilitar o uso da String, mas atrás dos panos
          o Java usa o construtor.

          PS.: se vc tiver usando o Java 5 poderá ver e fazer assim tb, mas só com as classe
          wappers.:
          Integer integer = 5;
          Mas ae é o uso de um mecanismo criado no Java 5 chamado Unboxing/Boxing,
          mas este é outro assunto... se quizer saber mais sobre este recurso dá uma
          olhada em http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#5.1.7

          On 2/12/07, Gilberto Oliveira <gilberto_adm@...> wrote:

          Pessoal
           
          tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
           
          NomeClasse nc = new NomeClasse();
           
          Isso criava um objeto sob a referência nc correto?
           
          Estudando a classe String, verifiquei que é possível fazer:
           
          String str = "Minha String";
           
          Isso por sí só cria um objeto String "MinhaString", sob a referência 'str'.
          Também da pra fazer do jeito clássico:
           
          String st = new String ("Minha String st").
           
          Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
           
          Pergunta:
           
          a) Isso só pode ser feito com classes empacotadoras?Se não, podem me dar um exemplo com outra classe?
          b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
           
          Abraços

          __________________________________________________
          Fale com seus amigos de graça com o novo Yahoo! Messenger
          http://br.messenger.yahoo.com/




          --
          Bruno Carlo
          Analista de Sistemas PL
        • Alberto Ivo
          Na classe String a diferença entre criar dessas duas maneiras é a seguinte: Quando vc cria assim: String nome1 = Java ; vc cria um objeto na memoria
          Message 4 of 25 , Feb 12, 2007
          • 0 Attachment
            Na classe String a diferença entre criar dessas duas maneiras é a seguinte:

            Quando vc cria assim: String nome1 = "Java"; vc cria um objeto na memoria normalmente, porém, se vc criar uma outra String com o mesmo nome, por exemplo: String nome2 = "Java";
            como o valor delas sao iguais, nome1 e nome2 apontarão para o mesmo objeto, o que resultará numa economia de memória.
            Desvantagem:
            se executar o método, por exemplo, nome1.concat(" Rules"); ele concatenará a string "Java Rules", mas quando for pra proxima linha de código, ele volta ao normal "Java". Faz o teste pra vc ver =)

            System.out.printl( nome1 );
            System.out.printl( nome1.concat( " Rules" ) );
            System.out.printl( nome1 );

            A saída será:
            Java
            Java Rules
            Java

            pra vc realmente modificar o valor da variavel, vc deve fazer: nome1 = nome1.concat( " Rules" );

            Já se vc criar do jeito clássico: String nome1 = new String("Java"); e String nome2 = new String("Java"); cada atributo, nome1 e nome2 apontará para um objeto diferente. o que será gasto de memória, claro que nao faz falta com poucos atributos. portanto, para aplicações pequenas e médias, nao tem diferença.

            On 2/12/07, Gilberto Oliveira <gilberto_adm@...> wrote:
            Pessoal
             
            tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
             
            NomeClasse nc = new NomeClasse();
             
            Isso criava um objeto sob a referência nc correto?
             
            Estudando a classe String, verifiquei que é possível fazer:
             
            String str = "Minha String";
             
            Isso por sí só cria um objeto String "MinhaString", sob a referência 'str'.
            Também da pra fazer do jeito clássico:
             
            String st = new String ("Minha String st").
             
            Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
             
            Pergunta:
             
            a) Isso só pode ser feito com classes empacotadoras?Se não, podem me dar um exemplo com outra classe?
            b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
             
            Abraços

            __________________________________________________
            Fale com seus amigos de graça com o novo Yahoo! Messenger
            http://br.messenger.yahoo.com/


          • Leandro Augusto Moreira Pinto
            Olá Alberto, Não existe nenhum método na interface pública da String que permita modificar o seu conteúdo, ou seja, elas são imutáveis. Este método
            Message 5 of 25 , Feb 12, 2007
            • 0 Attachment
              Olá Alberto,

              Não existe nenhum método na interface pública da String que permita modificar o seu conteúdo, ou seja, elas são imutáveis. Este método concat não altera a string, ele cria uma nova e retorna essa string nova.

              Abraços,
              Leandro.

              On 2/12/07, Alberto Ivo <albertoivo@...> wrote:

              Na classe String a diferença entre criar dessas duas maneiras é a seguinte:

              Quando vc cria assim: String nome1 = "Java"; vc cria um objeto na memoria normalmente, porém, se vc criar uma outra String com o mesmo nome, por exemplo: String nome2 = "Java";
              como o valor delas sao iguais, nome1 e nome2 apontarão para o mesmo objeto, o que resultará numa economia de memória.
              Desvantagem:
              se executar o método, por exemplo, nome1.concat(" Rules"); ele concatenará a string "Java Rules", mas quando for pra proxima linha de código, ele volta ao normal "Java". Faz o teste pra vc ver =)


               

              System.out.printl( nome1 );
              System.out.printl( nome1.concat( " Rules" ) );
              System.out.printl( nome1 );

              A saída será:
              Java
              Java Rules
              Java

              pra vc realmente modificar o valor da variavel, vc deve fazer: nome1 = nome1.concat( " Rules" );

              Já se vc criar do jeito clássico: String nome1 = new String("Java"); e String nome2 = new String("Java"); cada atributo, nome1 e nome2 apontará para um objeto diferente. o que será gasto de memória, claro que nao faz falta com poucos atributos. portanto, para aplicações pequenas e médias, nao tem diferença.

              On 2/12/07, Gilberto Oliveira < gilberto_adm@...> wrote:
              Pessoal
               
              tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
               
              NomeClasse nc = new NomeClasse();
               
              Isso criava um objeto sob a referência nc correto?
               
              Estudando a classe String, verifiquei que é possível fazer:
               
              String str = "Minha String";
               
              Isso por sí só cria um objeto String "MinhaString", sob a referência 'str'.
              Também da pra fazer do jeito clássico:
               
              String st = new String ("Minha String st").
               
              Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
               
              Pergunta:
               
              a) Isso só pode ser feito com classes empacotadoras?Se não, podem me dar um exemplo com outra classe?
              b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
               
              Abraços

              __________________________________________________
              Fale com seus amigos de graça com o novo Yahoo! Messenger
              http://br.messenger.yahoo.com/



            • Victor Hugo Muniz Machado
              realmente as Strings sao imutaveis.... ao compilar sua classe todas as String viram StringBuffered, elas sim tem o conteudo que permite edições. Leandro
              Message 6 of 25 , Feb 12, 2007
              • 0 Attachment
                realmente as Strings sao imutaveis....

                ao compilar sua classe todas as String viram StringBuffered, elas sim tem o conteudo que permite edições.

                Leandro Augusto Moreira Pinto <leandroampinto@...> escreveu:
                Olá Alberto,

                Não existe nenhum método na interface pública da String que permita modificar o seu conteúdo, ou seja, elas são imutáveis. Este método concat não altera a string, ele cria uma nova e retorna essa string nova.

                Abraços,
                Leandro.

                On 2/12/07, Alberto Ivo <albertoivo@gmail. com> wrote:
                Na classe String a diferença entre criar dessas duas maneiras é a seguinte:

                Quando vc cria assim: String nome1 = "Java"; vc cria um objeto na memoria normalmente, porém, se vc criar uma outra String com o mesmo nome, por exemplo: String nome2 = "Java";
                como o valor delas sao iguais, nome1 e nome2 apontarão para o mesmo objeto, o que resultará numa economia de memória.
                Desvantagem:
                se executar o método, por exemplo, nome1.concat(" Rules"); ele concatenará a string "Java Rules", mas quando for pra proxima linha de código, ele volta ao normal "Java". Faz o teste pra vc ver =)

                 

                System.out.printl( nome1 );
                System.out.printl( nome1.concat( " Rules" ) );
                System.out.printl( nome1 );

                A saída será:
                Java
                Java Rules
                Java

                pra vc realmente modificar o valor da variavel, vc deve fazer: nome1 = nome1.concat( " Rules" );

                Já se vc criar do jeito clássico: String nome1 = new String("Java"); e String nome2 = new String("Java"); cada atributo, nome1 e nome2 apontará para um objeto diferente. o que será gasto de memória, claro que nao faz falta com poucos atributos. portanto, para aplicações pequenas e médias, nao tem diferença.

                On 2/12/07, Gilberto Oliveira < gilberto_adm@ yahoo.com. br> wrote:
                Pessoal
                 
                tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
                 
                NomeClasse nc = new NomeClasse() ;
                 
                Isso criava um objeto sob a referência nc correto?
                 
                Estudando a classe String, verifiquei que é possível fazer:
                 
                String str = "Minha String";
                 
                Isso por sí só cria um objeto String "MinhaString", sob a referência 'str'.
                Também da pra fazer do jeito clássico:
                 
                String st = new String ("Minha String st").
                 
                Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
                 
                Pergunta:
                 
                a) Isso só pode ser feito com classes empacotadoras? Se não, podem me dar um exemplo com outra classe?
                b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
                 
                Abraços
                ____________ _________ _________ _________ _________ __
                Fale com seus amigos de graça com o novo Yahoo! Messenger
                http://br.messenger .yahoo.com/



                __________________________________________________
                Fale com seus amigos de graça com o novo Yahoo! Messenger
                http://br.messenger.yahoo.com/

              • Gilberto Oliveira
                Lí um tutorial que dizia o seguinte: Quando você cria um objeto String: String str = Minha String ; Você esta criando apenas um objeto e mandando ele para
                Message 7 of 25 , Feb 13, 2007
                • 0 Attachment
                  Lí um tutorial que dizia o seguinte:
                   
                  Quando você cria um objeto String: String str = "Minha String";
                  Você esta criando apenas um objeto e mandando ele para um tipo especial de memória chamado "poll de strings"
                   
                  Quando vc cria um objeto do tipo String: String str = new String("abcde");
                  Voce esta criando dois objetos: A referência "str" é instanciada na memória normal (1o. objeto) o conteúdo "abcde" é instanciado como objeto e colocado na memória "poll de strings"
                   
                  Voces sabem explicar a diferença entre o poll de Strings e a memória chamada "comum"?
                  Perdoem a insistência, mas quero entender o que estou fazendo e não apenas virar um digitador de código. Desde já agradeço a ajuda!

                  Leandro Augusto Moreira Pinto <leandroampinto@...> escreveu:
                  Olá Alberto,

                  Não existe nenhum método na interface pública da String que permita modificar o seu conteúdo, ou seja, elas são imutáveis. Este método concat não altera a string, ele cria uma nova e retorna essa string nova.

                  Abraços,
                  Leandro.

                  On 2/12/07, Alberto Ivo <albertoivo@gmail. com> wrote:
                  Na classe String a diferença entre criar dessas duas maneiras é a seguinte:

                  Quando vc cria assim: String nome1 = "Java"; vc cria um objeto na memoria normalmente, porém, se vc criar uma outra String com o mesmo nome, por exemplo: String nome2 = "Java";
                  como o valor delas sao iguais, nome1 e nome2 apontarão para o mesmo objeto, o que resultará numa economia de memória.
                  Desvantagem:
                  se executar o método, por exemplo, nome1.concat(" Rules"); ele concatenará a string "Java Rules", mas quando for pra proxima linha de código, ele volta ao normal "Java". Faz o teste pra vc ver =)

                   

                  System.out.printl( nome1 );
                  System.out.printl( nome1.concat( " Rules" ) );
                  System.out.printl( nome1 );

                  A saída será:
                  Java
                  Java Rules
                  Java

                  pra vc realmente modificar o valor da variavel, vc deve fazer: nome1 = nome1.concat( " Rules" );

                  Já se vc criar do jeito clássico: String nome1 = new String("Java"); e String nome2 = new String("Java"); cada atributo, nome1 e nome2 apontará para um objeto diferente. o que será gasto de memória, claro que nao faz falta com poucos atributos. portanto, para aplicações pequenas e médias, nao tem diferença.

                  On 2/12/07, Gilberto Oliveira < gilberto_adm@ yahoo.com. br> wrote:
                  Pessoal
                   
                  tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
                   
                  NomeClasse nc = new NomeClasse() ;
                   
                  Isso criava um objeto sob a referência nc correto?
                   
                  Estudando a classe String, verifiquei que é possível fazer:
                   
                  String str = "Minha String";
                   
                  Isso por sí só cria um objeto String "MinhaString", sob a referência 'str'.
                  Também da pra fazer do jeito clássico:
                   
                  String st = new String ("Minha String st").
                   
                  Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
                   
                  Pergunta:
                   
                  a) Isso só pode ser feito com classes empacotadoras? Se não, podem me dar um exemplo com outra classe?
                  b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
                   
                  Abraços
                  ____________ _________ _________ _________ _________ __
                  Fale com seus amigos de graça com o novo Yahoo! Messenger
                  http://br.messenger .yahoo.com/



                  __________________________________________________
                  Fale com seus amigos de graça com o novo Yahoo! Messenger
                  http://br.messenger.yahoo.com/

                • Victor Hugo Muniz Machado
                  eu nunca ouvi fala no seu poll de strings o que sei é.... a classe String é a unica que não precisa do comando new para ter um objeto instanciado, sendo
                  Message 8 of 25 , Feb 13, 2007
                  • 0 Attachment
                    eu nunca ouvi fala no seu "poll de strings"

                    o que sei é....
                    a classe String é a unica que não precisa do comando 'new' para ter um objeto instanciado, sendo assim vc pode ter um objeto da classe String da seguinte forma
                    String str = "Minha String";

                    ou da forma tradicional
                    String str = new String("abcde");

                    so que neste caso especifico da classe String a segunda forma é uma redundancia pois o uso do operador new é totalmente dispensavel

                    outra particularidade é que apartir de uma literal qualquer, chamar metodos, isso é possivel pois java entende esta string como um objeto da classe String
                    "Minha String".equals(variavel);



                    Gilberto Oliveira <gilberto_adm@...> escreveu:
                    Lí um tutorial que dizia o seguinte:
                     
                    Quando você cria um objeto String: String str = "Minha String";
                    Você esta criando apenas um objeto e mandando ele para um tipo especial de memória chamado "poll de strings"
                     
                    Quando vc cria um objeto do tipo String: String str = new String("abcde" );
                    Voce esta criando dois objetos: A referência "str" é instanciada na memória normal (1o. objeto) o conteúdo "abcde" é instanciado como objeto e colocado na memória "poll de strings"
                     
                    Voces sabem explicar a diferença entre o poll de Strings e a memória chamada "comum"?
                    Perdoem a insistência, mas quero entender o que estou fazendo e não apenas virar um digitador de código. Desde já agradeço a ajuda!

                    Leandro Augusto Moreira Pinto <leandroampinto@ gmail.com> escreveu:
                    Olá Alberto,

                    Não existe nenhum método na interface pública da String que permita modificar o seu conteúdo, ou seja, elas são imutáveis. Este método concat não altera a string, ele cria uma nova e retorna essa string nova.

                    Abraços,
                    Leandro.

                    On 2/12/07, Alberto Ivo <albertoivo@gmail. com> wrote:
                    Na classe String a diferença entre criar dessas duas maneiras é a seguinte:

                    Quando vc cria assim: String nome1 = "Java"; vc cria um objeto na memoria normalmente, porém, se vc criar uma outra String com o mesmo nome, por exemplo: String nome2 = "Java";
                    como o valor delas sao iguais, nome1 e nome2 apontarão para o mesmo objeto, o que resultará numa economia de memória.
                    Desvantagem:
                    se executar o método, por exemplo, nome1.concat( " Rules"); ele concatenará a string "Java Rules", mas quando for pra proxima linha de código, ele volta ao normal "Java". Faz o teste pra vc ver =)

                     

                    System.out.printl( nome1 );
                    System.out.printl( nome1.concat( " Rules" ) );
                    System.out.printl( nome1 );

                    A saída será:
                    Java
                    Java Rules
                    Java

                    pra vc realmente modificar o valor da variavel, vc deve fazer: nome1 = nome1.concat( " Rules" );

                    Já se vc criar do jeito clássico: String nome1 = new String("Java" ); e String nome2 = new String("Java" ); cada atributo, nome1 e nome2 apontará para um objeto diferente. o que será gasto de memória, claro que nao faz falta com poucos atributos. portanto, para aplicações pequenas e médias, nao tem diferença.

                    On 2/12/07, Gilberto Oliveira < gilberto_adm@ yahoo.com. br> wrote:
                    Pessoal
                     
                    tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
                     
                    NomeClasse nc = new NomeClasse() ;
                     
                    Isso criava um objeto sob a referência nc correto?
                     
                    Estudando a classe String, verifiquei que é possível fazer:
                     
                    String str = "Minha String";
                     
                    Isso por sí só cria um objeto String "MinhaString" , sob a referência 'str'.
                    Também da pra fazer do jeito clássico:
                     
                    String st = new String ("Minha String st").
                     
                    Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
                     
                    Pergunta:
                     
                    a) Isso só pode ser feito com classes empacotadoras? Se não, podem me dar um exemplo com outra classe?
                    b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
                     
                    Abraços
                    ____________ _________ _________ _________ _________ __
                    Fale com seus amigos de graça com o novo Yahoo! Messenger
                    http://br.messenger .yahoo.com/



                    ____________ _________ _________ _________ _________ __
                    Fale com seus amigos de graça com o novo Yahoo! Messenger
                    http://br.messenger .yahoo.com/

                    __________________________________________________
                    Fale com seus amigos de graça com o novo Yahoo! Messenger
                    http://br.messenger.yahoo.com/

                  • Leandro Augusto Moreira Pinto
                    Oi, Gilberto, O termo correto é pool e não poll. Prefira criar strings da forma tradicional com aspas, ou seja: String nome = Leandro e não String nome =
                    Message 9 of 25 , Feb 13, 2007
                    • 0 Attachment
                      Oi, Gilberto,

                      O termo correto é pool e não poll.

                      Prefira criar strings da forma tradicional com aspas, ou seja:

                      String nome = "Leandro" e não String nome = new String("Leandro");

                      Eu destaco 2 motivos para que vc opte pela primeira opção:
                      1 - É um idiom do Java.
                      2 - Vc compartilha os objetos do pool de strings (Talvez por isso ele tenha se tornado um idiom do Java).

                      O runtime do Java reserva uma área de memória especial que onde ele armazena todas as strings que são criadas do primeiro modo.

                      Se eu faço:

                      String nome1 = "Leandro";
                      String nome2 = "Leandro";

                      As 2 varíaveis apontam para o mesmo objeto e com isso eu economizo memória.

                      Se eu faço:
                      String nome1 = new String("Leandro");
                      String nome2 = new String("Leandro");

                      Cada variável aponta para um objeto diferente.

                      Eis o código de uma classe que ilustra o que eu disse:

                      public class Strings {
                        public static void main(String[] args) {

                          String nome1 = "Leandro";
                          String nome2 = "Leandro";
                         
                          String nome3 = new String("Leandro");
                          String nome4 = new String("Leandro");
                         
                          System.out.println("nome1 == nome2 : " + (nome1 == nome2));
                          System.out.println("nome3 == nome4 : " + (nome3 == nome4));
                          System.out.println("nome1.equals(nome2) : " + nome1.equals(nome2));
                          System.out.println("nome3.equals(nome4) : " + nome3.equals(nome4));
                        }
                      }

                      A saída do programa é:

                      nome1 == nome2 : true
                      nome3 == nome4 : false
                      nome1.equals(nome2) : true
                      nome3.equals(nome4) : true

                      Quando vc precisar criar strings grandes através da concatenação de várias strings dê preferência a utilizar StringBuilder neste processo de criação. Depois da Strings criada, pode continuar a utilizar a própria String.

                      Ex.:
                      Com String:
                          String text = "";
                          for (int i = 0; i < 10000; i++) {
                            text += "Que string grande!\n";
                          }

                      Com StringBuilder:
                          StringBuilder textBuilder = new StringBuilder();
                          for (int i =0; i < 10000; i++) {
                            textBuilder.append("Que string grande!\n");
                          }
                          String text2 = textBuilder.toString();

                      A razão para isso é que o primeiro trecho cria uma nova string a cada iteração do loop. Na primeira:
                      Que string grande!\n
                      Na Segunda:
                      Que string grande!\nQue string grande!\n

                      E por aí vai. O StringBuilder modifica um array de chars que ele armazena internamente. Ele não precisa criar uma nova string a cada append, portanto ele economiza memória.

                      Vc vai encontrar vários textos falando do StringBuffer. O StringBuffer é parecido com o StringBuilder. Existem vários textos sobre ele, porque ele foi criado antes do StringBuilder. O StringBuffer foi criando na versão 1 e o StringBuilder foi criado na versão 5. A diferença entre eles é que o StringBuffer é thread-safe e StringBuilder não é. Dê preferência a utilizar StringBuilder, pois ele é mais rápido do que o StringBuffer.

                      Abraços,
                      Leandro.

                      On 2/13/07, Victor Hugo Muniz Machado <victorhugomuniz@...> wrote:

                      eu nunca ouvi fala no seu "poll de strings"

                      o que sei é....
                      a classe String é a unica que não precisa do comando 'new' para ter um objeto instanciado, sendo assim vc pode ter um objeto da classe String da seguinte forma
                      String str = "Minha String";

                      ou da forma tradicional
                      String str = new String("abcde");

                      so que neste caso especifico da classe String a segunda forma é uma redundancia pois o uso do operador new é totalmente dispensavel

                      outra particularidade é que apartir de uma literal qualquer, chamar metodos, isso é possivel pois java entende esta string como um objeto da classe String
                      "Minha String".equals(variavel);



                      Gilberto Oliveira <gilberto_adm@yahoo.com.br> escreveu:

                      Lí um tutorial que dizia o seguinte:
                       
                      Quando você cria um objeto String: String str = "Minha String";
                      Você esta criando apenas um objeto e mandando ele para um tipo especial de memória chamado "poll de strings"
                       
                      Quando vc cria um objeto do tipo String: String str = new String("abcde");
                      Voce esta criando dois objetos: A referência "str" é instanciada na memória normal (1o. objeto) o conteúdo "abcde" é instanciado como objeto e colocado na memória "poll de strings"
                       
                      Voces sabem explicar a diferença entre o poll de Strings e a memória chamada "comum"?
                      Perdoem a insistência, mas quero entender o que estou fazendo e não apenas virar um digitador de código. Desde já agradeço a ajuda!

                      Leandro Augusto Moreira Pinto <leandroampinto@ gmail.com> escreveu:
                      Olá Alberto,

                      Não existe nenhum método na interface pública da String que permita modificar o seu conteúdo, ou seja, elas são imutáveis. Este método concat não altera a string, ele cria uma nova e retorna essa string nova.

                      Abraços,
                      Leandro.

                      On 2/12/07, Alberto Ivo < albertoivo@...> wrote:
                      Na classe String a diferença entre criar dessas duas maneiras é a seguinte:

                      Quando vc cria assim: String nome1 = "Java"; vc cria um objeto na memoria normalmente, porém, se vc criar uma outra String com o mesmo nome, por exemplo: String nome2 = "Java";
                      como o valor delas sao iguais, nome1 e nome2 apontarão para o mesmo objeto, o que resultará numa economia de memória.
                      Desvantagem:
                      se executar o método, por exemplo, nome1.concat(" Rules"); ele concatenará a string "Java Rules", mas quando for pra proxima linha de código, ele volta ao normal "Java". Faz o teste pra vc ver =)

                       

                      System.out.printl( nome1 );
                      System.out.printl( nome1.concat( " Rules" ) );
                      System.out.printl( nome1 );

                      A saída será:
                      Java
                      Java Rules
                      Java

                      pra vc realmente modificar o valor da variavel, vc deve fazer: nome1 = nome1.concat( " Rules" );

                      Já se vc criar do jeito clássico: String nome1 = new String("Java"); e String nome2 = new String("Java"); cada atributo, nome1 e nome2 apontará para um objeto diferente. o que será gasto de memória, claro que nao faz falta com poucos atributos. portanto, para aplicações pequenas e médias, nao tem diferença.

                      On 2/12/07, Gilberto Oliveira < gilberto_adm@...> wrote:
                      Pessoal
                       
                      tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
                       
                      NomeClasse nc = new NomeClasse();
                       
                      Isso criava um objeto sob a referência nc correto?
                       
                      Estudando a classe String, verifiquei que é possível fazer:
                       
                      String str = "Minha String";
                       
                      Isso por sí só cria um objeto String "MinhaString", sob a referência 'str'.
                      Também da pra fazer do jeito clássico:
                       
                      String st = new String ("Minha String st").
                       
                      Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
                       
                      Pergunta:
                       
                      a) Isso só pode ser feito com classes empacotadoras?Se não, podem me dar um exemplo com outra classe?
                      b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
                       
                      Abraços
                      __________________________________________________
                      Fale com seus amigos de graça com o novo Yahoo! Messenger
                      http://br.messenger.yahoo.com/



                      __________________________________________________
                      Fale com seus amigos de graça com o novo Yahoo! Messenger
                      http://br.messenger.yahoo.com/

                      __________________________________________________
                      Fale com seus amigos de graça com o novo Yahoo! Messenger
                      http://br.messenger.yahoo.com/


                    • Luiz Esmiralha
                      Para mais informações: http://www.precisejava.com/javaperf/j2se/StringAndStringBuffer.htm Abraço, Luiz
                      Message 10 of 25 , Feb 13, 2007
                      • 0 Attachment
                        Para mais informações:

                        http://www.precisejava.com/javaperf/j2se/StringAndStringBuffer.htm

                        Abraço,
                        Luiz

                        On 2/13/07, Gilberto Oliveira <gilberto_adm@...> wrote:
                        >
                        >
                        > Lí um tutorial que dizia o seguinte:
                        >
                        > Quando você cria um objeto String: String str = "Minha String";
                        > Você esta criando apenas um objeto e mandando ele para um tipo especial de memória chamado "poll de strings"
                        >
                        > Quando vc cria um objeto do tipo String: String str = new String("abcde");
                        > Voce esta criando dois objetos: A referência "str" é instanciada na memória normal (1o. objeto) o conteúdo "abcde" é instanciado como objeto e colocado na memória "poll de strings"
                        >
                        > Voces sabem explicar a diferença entre o poll de Strings e a memória chamada "comum"?
                        >
                        > Perdoem a insistência, mas quero entender o que estou fazendo e não apenas virar um digitador de código. Desde já agradeço a ajuda!
                        >
                        > Leandro Augusto Moreira Pinto <leandroampinto@...> escreveu:
                        >
                        >
                        >
                        > Olá Alberto,
                        >
                        > Não existe nenhum método na interface pública da String que permita modificar o seu conteúdo, ou seja, elas são imutáveis. Este método concat não altera a string, ele cria uma nova e retorna essa string nova.
                        >
                        > Abraços,
                        > Leandro.
                        >
                        >
                        > On 2/12/07, Alberto Ivo <albertoivo@...> wrote:
                        > >
                        > >
                        > >
                        > >
                        > >
                        > > Na classe String a diferença entre criar dessas duas maneiras é a seguinte:
                        > >
                        > > Quando vc cria assim: String nome1 = "Java"; vc cria um objeto na memoria normalmente, porém, se vc criar uma outra String com o mesmo nome, por exemplo: String nome2 = "Java";
                        > > como o valor delas sao iguais, nome1 e nome2 apontarão para o mesmo objeto, o que resultará numa economia de memória.
                        > > Desvantagem:
                        > > se executar o método, por exemplo, nome1.concat(" Rules"); ele concatenará a string "Java Rules", mas quando for pra proxima linha de código, ele volta ao normal "Java". Faz o teste pra vc ver =)
                        >
                        >
                        >
                        >
                        > >
                        > >
                        > >
                        > >
                        > >
                        > > System.out.printl( nome1 );
                        > > System.out.printl( nome1.concat( " Rules" ) );
                        > > System.out.printl( nome1 );
                        > >
                        > > A saída será:
                        > > Java
                        > > Java Rules
                        > > Java
                        > >
                        > > pra vc realmente modificar o valor da variavel, vc deve fazer: nome1 = nome1.concat( " Rules" );
                        > >
                        > > Já se vc criar do jeito clássico: String nome1 = new String("Java"); e String nome2 = new String("Java"); cada atributo, nome1 e nome2 apontará para um objeto diferente. o que será gasto de memória, claro que nao faz falta com poucos atributos. portanto, para aplicações pequenas e médias, nao tem diferença.
                        > >
                        > >
                        > > On 2/12/07, Gilberto Oliveira < gilberto_adm@...> wrote:
                        > > >
                        > > >
                        > > > Pessoal
                        > > >
                        > > > tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
                        > > >
                        > > > NomeClasse nc = new NomeClasse();
                        > > >
                        > > > Isso criava um objeto sob a referência nc correto?
                        > > >
                        > > > Estudando a classe String, verifiquei que é possível fazer:
                        > > >
                        > > > String str = "Minha String";
                        > > >
                        > > > Isso por sí só cria um objeto String "MinhaString", sob a referência 'str'.
                        > > > Também da pra fazer do jeito clássico:
                        > > >
                        > > > String st = new String ("Minha String st").
                        > > >
                        > > > Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
                        > > >
                        > > > Pergunta:
                        > > >
                        > > > a) Isso só pode ser feito com classes empacotadoras?Se não, podem me dar um exemplo com outra classe?
                        > > > b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
                        > > >
                        > > > Abraços
                        > > > __________________________________________________
                        > > > Fale com seus amigos de graça com o novo Yahoo! Messenger
                        > > > http://br.messenger.yahoo.com/
                        > > >
                        > > >
                        > >
                        > >
                        > >
                        >
                        >
                        >
                        >
                        >
                        > __________________________________________________
                        > Fale com seus amigos de graça com o novo Yahoo! Messenger
                        > http://br.messenger.yahoo.com/
                      • Gilberto Oliveira
                        Obrigado a todos que ajudaram! Consegui entender como funciona e posso seguir com os estudos! Abraços Leandro Augusto Moreira Pinto
                        Message 11 of 25 , Feb 13, 2007
                        • 0 Attachment
                          Obrigado a todos que ajudaram! Consegui entender como funciona e posso seguir com os estudos!
                           
                          Abraços


                          Leandro Augusto Moreira Pinto <leandroampinto@...> escreveu:
                          Oi, Gilberto,

                          O termo correto é pool e não poll.

                          Prefira criar strings da forma tradicional com aspas, ou seja:

                          String nome = "Leandro" e não String nome = new String("Leandro");

                          Eu destaco 2 motivos para que vc opte pela primeira opção:
                          1 - É um idiom do Java.
                          2 - Vc compartilha os objetos do pool de strings (Talvez por isso ele tenha se tornado um idiom do Java).

                          O runtime do Java reserva uma área de memória especial que onde ele armazena todas as strings que são criadas do primeiro modo.

                          Se eu faço:

                          String nome1 = "Leandro";
                          String nome2 = "Leandro";

                          As 2 varíaveis apontam para o mesmo objeto e com isso eu economizo memória.

                          Se eu faço:
                          String nome1 = new String("Leandro");
                          String nome2 = new String("Leandro");

                          Cada variável aponta para um objeto diferente.

                          Eis o código de uma classe que ilustra o que eu disse:

                          public class Strings {
                            public static void main(String[ ] args) {

                              String nome1 = "Leandro";
                              String nome2 = "Leandro";
                             
                              String nome3 = new String("Leandro");
                              String nome4 = new String("Leandro");
                             
                              System.out.println("nome1 == nome2 : " + (nome1 == nome2));
                              System.out.println("nome3 == nome4 : " + (nome3 == nome4));
                              System.out.println("nome1.equals( nome2) : " + nome1.equals( nome2));
                              System.out.println("nome3.equals( nome4) : " + nome3.equals( nome4));
                            }
                          }

                          A saída do programa é:

                          nome1 == nome2 : true
                          nome3 == nome4 : false
                          nome1.equals( nome2) : true
                          nome3.equals( nome4) : true

                          Quando vc precisar criar strings grandes através da concatenação de várias strings dê preferência a utilizar StringBuilder neste processo de criação. Depois da Strings criada, pode continuar a utilizar a própria String.

                          Ex.:
                          Com String:
                              String text = "";
                              for (int i = 0; i < 10000; i++) {
                                text += "Que string grande!\n";
                              }

                          Com StringBuilder:
                              StringBuilder textBuilder = new StringBuilder( );
                              for (int i =0; i < 10000; i++) {
                                textBuilder. append("Que string grande!\n");
                              }
                              String text2 = textBuilder. toString( );

                          A razão para isso é que o primeiro trecho cria uma nova string a cada iteração do loop. Na primeira:
                          Que string grande!\n
                          Na Segunda:
                          Que string grande!\nQue string grande!\n

                          E por aí vai. O StringBuilder modifica um array de chars que ele armazena internamente. Ele não precisa criar uma nova string a cada append, portanto ele economiza memória.

                          Vc vai encontrar vários textos falando do StringBuffer. O StringBuffer é parecido com o StringBuilder. Existem vários textos sobre ele, porque ele foi criado antes do StringBuilder. O StringBuffer foi criando na versão 1 e o StringBuilder foi criado na versão 5. A diferença entre eles é que o StringBuffer é thread-safe e StringBuilder não é. Dê preferência a utilizar StringBuilder, pois ele é mais rápido do que o StringBuffer.

                          Abraços,
                          Leandro.

                          On 2/13/07, Victor Hugo Muniz Machado <victorhugomuniz@ yahoo.com. br> wrote:
                          eu nunca ouvi fala no seu "poll de strings"

                          o que sei é....
                          a classe String é a unica que não precisa do comando 'new' para ter um objeto instanciado, sendo assim vc pode ter um objeto da classe String da seguinte forma
                          String str = "Minha String";

                          ou da forma tradicional
                          String str = new String("abcde");

                          so que neste caso especifico da classe String a segunda forma é uma redundancia pois o uso do operador new é totalmente dispensavel

                          outra particularidade é que apartir de uma literal qualquer, chamar metodos, isso é possivel pois java entende esta string como um objeto da classe String
                          "Minha String".equals(variavel) ;



                          Gilberto Oliveira <gilberto_adm@yahoo.com.br> escreveu:
                          Lí um tutorial que dizia o seguinte:
                           
                          Quando você cria um objeto String: String str = "Minha String";
                          Você esta criando apenas um objeto e mandando ele para um tipo especial de memória chamado "poll de strings"
                           
                          Quando vc cria um objeto do tipo String: String str = new String("abcde");
                          Voce esta criando dois objetos: A referência "str" é instanciada na memória normal (1o. objeto) o conteúdo "abcde" é instanciado como objeto e colocado na memória "poll de strings"
                           
                          Voces sabem explicar a diferença entre o poll de Strings e a memória chamada "comum"?
                          Perdoem a insistência, mas quero entender o que estou fazendo e não apenas virar um digitador de código. Desde já agradeço a ajuda!

                          Leandro Augusto Moreira Pinto <leandroampinto@ gmail.com> escreveu:
                          Olá Alberto,

                          Não existe nenhum método na interface pública da String que permita modificar o seu conteúdo, ou seja, elas são imutáveis. Este método concat não altera a string, ele cria uma nova e retorna essa string nova.

                          Abraços,
                          Leandro.

                          On 2/12/07, Alberto Ivo < albertoivo@gmail. com> wrote:
                          Na classe String a diferença entre criar dessas duas maneiras é a seguinte:

                          Quando vc cria assim: String nome1 = "Java"; vc cria um objeto na memoria normalmente, porém, se vc criar uma outra String com o mesmo nome, por exemplo: String nome2 = "Java";
                          como o valor delas sao iguais, nome1 e nome2 apontarão para o mesmo objeto, o que resultará numa economia de memória.
                          Desvantagem:
                          se executar o método, por exemplo, nome1.concat(" Rules"); ele concatenará a string "Java Rules", mas quando for pra proxima linha de código, ele volta ao normal "Java". Faz o teste pra vc ver =)

                           

                          System.out.printl( nome1 );
                          System.out.printl( nome1.concat( " Rules" ) );
                          System.out.printl( nome1 );

                          A saída será:
                          Java
                          Java Rules
                          Java

                          pra vc realmente modificar o valor da variavel, vc deve fazer: nome1 = nome1.concat( " Rules" );

                          Já se vc criar do jeito clássico: String nome1 = new String("Java"); e String nome2 = new String("Java"); cada atributo, nome1 e nome2 apontará para um objeto diferente. o que será gasto de memória, claro que nao faz falta com poucos atributos. portanto, para aplicações pequenas e médias, nao tem diferença.

                          On 2/12/07, Gilberto Oliveira < gilberto_adm@ yahoo.com. br> wrote:
                          Pessoal
                           
                          tenho uma dúvida para construtores. Para criar um objeto sempre fiz:
                           
                          NomeClasse nc = new NomeClasse() ;
                           
                          Isso criava um objeto sob a referência nc correto?
                           
                          Estudando a classe String, verifiquei que é possível fazer:
                           
                          String str = "Minha String";
                           
                          Isso por sí só cria um objeto String "MinhaString", sob a referência 'str'.
                          Também da pra fazer do jeito clássico:
                           
                          String st = new String ("Minha String st").
                           
                          Testei dessa forma mais direta com as classes 'empacotadoras' e funcionou do mesmo jeito.
                           
                          Pergunta:
                           
                          a) Isso só pode ser feito com classes empacotadoras? Se não, podem me dar um exemplo com outra classe?
                          b) Existe algum padrão para criação de objetos ou havendo possibilidade de se utilizar essa "criação direta", tanto faz usar um ou outro?
                           
                          Abraços
                          ____________ _________ _________ _________ _________ __
                          Fale com seus amigos de graça com o novo Yahoo! Messenger
                          http://br.messenger .yahoo.com/



                          ____________ _________ _________ _________ _________ __
                          Fale com seus amigos de graça com o novo Yahoo! Messenger
                          http://br.messenger.yahoo.com/

                          ____________ _________ _________ _________ _________ __
                          Fale com seus amigos de graça com o novo Yahoo! Messenger
                          http://br.messenger.yahoo.com/


                          __________________________________________________
                          Fale com seus amigos de graça com o novo Yahoo! Messenger
                          http://br.messenger.yahoo.com/

                        Your message has been successfully submitted and would be delivered to recipients shortly.