1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

java strings duvda???

Discussão em 'Programação' iniciada por chrno, 3 de Novembro de 2007. (Respostas: 24; Visualizações: 2352)

  1. chrno

    chrno Power Member

    boas
    alguem me sb dizer como e k se faz s=x,sendo que s é 1a string e x é um inteiro, em java??
    obrigado
    cumps
     
  2. Demasiado confuso...
     
  3. Gurzi

    Gurzi Power Member

    toString() ?
     
  4. HecKel

    HecKel The WORM

    Se for int não dá o toString, pois int é um tipo e não um objecto.

    chrno, de facto tens o post muito confuso, ainda não percebi bem se queres inserir um inteiro numa variável do tipo string, se queres concatenar ou que raio queres. Recomendava-te a escreveres em português correcto e a detalhares mais a tua dúvida para te podermos ajudar.
     
  5. OdracirPT

    OdracirPT Power Member

    Já agora aproveito este tópico para perguntar o mesmo:

    Como inserir um inteiro numa variável do tipo string?:(

    Presumo que também seja essa a pergunta do chrno.

    Obrigado.
     
  6. Código:
    String s = "" + n;
    Em que n é o inteiro a transformar em string. ;)
     
  7. OdracirPT

    OdracirPT Power Member

    Obrigado.

    Como faço depois o return desse valor da string? Já coloquei return, mas dá-me erro.
     
  8. chrno

    chrno Power Member

    peço desculpa pelo portugues e k tou a meio dum trabalho e tava a stressar. sorry
    exactamente eu keria saber como igualar uma string a um inteiro. por exemplo:
    s(string)=15;
    ou seja de forma a k a string contenha o valor 15.
    obrigado
    cumps
     
  9. HecKel

    HecKel The WORM

    Então tens a resposta aqui:
     
  10. arkannis

    arkannis Power Member

    Queres o quê? Usar o inteiro que está na string para fazer contas, por exemplo?
    Isso assim é completamente absurdo!
    Porque raio é que irias querer guardar um inteiro numa String e depois usar esse inteiro para fazer contas?

    Se é para usar a string para fazer print, por exemplo, é so usa-la normalmente.
    String s = "" + n;
    System.out.print(s);

    se for outra coisa qualquer obscura:
    http://java.sun.com/docs/books/tutorial/java/data/index.html
     
  11. chrno

    chrno Power Member

    ok
    obrigado
    cumps
    :001:
     
  12. Se a ideia é essa é ainda mais simples:

    Código:
    System.out.println(n);
     
  13. chrno

    chrno Power Member

    num era bem essa a ideia e k tenhu 1 metod k recebe normalmente strings, estas k sao resultado de outro metodo.
    mas ha 1 caso em k preciso de chamar este metodo com outro metodo cujo resultado e int. isto e um bocado confuso mas n tou a ver outra forma de explicar
    cumps
     
  14. AliFromCairo

    AliFromCairo Power Member

    Código:
    // int para String
    int i = 20;
    String s = String.valueOf(i);
     
    // String para int
    String s = "20";
    int i = Integer.parseInt(s);
    
     
  15. Consu

    Consu Power Member

    Cuidado com atribuições. Se não há alocação de memória podem ocorrer erros. Se calhar era o que estava a acontecer com o return.

    String s = new String( "" + n );

    Já que o Java tem o Garbage Collector não precisas de ter preocupar com remover a memória alocada.

    AliFromCairo mais uma vez simples e conciso e eu a alertar para detalhes. :p
     

  16. isto é desnecessário.. a forma que indicaram ("" + n) funciona perfeitamente
    em java, não precisas de operador new para Strings (facilidades da linguagem)
     
  17. Consu

    Consu Power Member

    "Creating Strings

    The most direct way to create a string is to write:
    String greeting = "Hello world!";
    In this case, "Hello world!" is a string literal—a series of characters in your code that is enclosed in double quotes. Whenever it encounters a string literal in your code, the compiler creates a String object with its value—in this case, Hello world!"

    http://java.sun.com/docs/books/tutorial/java/data/strings.html



    Parece que o Java faz isso implicitamente, cria o novo objecto quando encontra um literal. Mesmo assim, creio que é uma boa prática usar o operador new, e dizer explicitamente que se está a criar uma nova string.
     
  18. theforbidden1

    theforbidden1 Banido

    eh!? Java não é C++. ninguem usa o new para inicializar strings... Os objectos que deixam de estar referenciados são eliminados automaticamente quando o Garbage Colector (GC) é chamado (ou a Maquina Virtual de java o chama ou o programador força o uso do GC)
     
  19. ^J^

    ^J^

    É ineficiente utilizar ("" + n).
    Se a ideia é concatenar Strings, é sempre melhor usar um StringBuilder (1.5) ou um StringBuffer (que apesar de ser sincronizado é preferivel ao +).

    Código:
    // concatenação mais eficiente:
    long numCogumelos = 1000000000000;
    StringBuilder sb = new StringBuilder(20*numCogumelos);
    sb.append("1 cogumelo trá-lá-lá\n");
    for (long i = 2; i < numCogumelos; i++) {
      sb.append(i).append(" cogumelos trá-lá-lá\n");
    }
    String bueCogumelos = sb.toString();
    
    Repara no método conveniente StringBuilder.append(int) entre outros...
    Já se escreveu muito sobre isto e é só perguntar ao google por "string concatenation and performance" ou experimentar o código de cima versus o equivalente com o operador "+" para se ver que realmente compensa usar o buffer.

    O mundo era um sitio mais acolhedor se isto fosse verdade, mas infelizmente a implementação de Strings em java (ainda) não é perfeita e podem surgir fugas de memória cuja única solução, ou a recomendada é: utilizar o construtor para alocar uma nova String explicitamente.

    Passo a explicar:

    Imagina que estás a utilizar o método split, substring ou algo do género, e queres reutilizar essas partes da String em novos objectos ou noutras Strings.
    O que te vai acontecer é que, a cadeia original nunca é libertada pelo gc porque as referências para a String original mantêm-se.
    Agora imagina que estás a fazer isso a partir de um Tera cogumelo que tínhas guardado num ficheiro, ou pior, que essas partes faziam parte de uma stream de cogumelos que não param de chegar...

    Estás a ver onde quero chegar? essas Strings nunca vão passar pelo gc e às tantas estás sem heap. Já me aconteceu e perdi muito tempo para descobrir o que se estava a passar...

    Isto é um bug e está avaliado: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4513622
    Repara no workaround que eles sugerem:
    Código:
    //instead of 
    foo = bar.substring(0,x);
    // use 
    foo = new String(bar.substring(0,x));
    // but: substring is supposed to return a new String anyway!
    
    ... a esperança segundo eles, é que seria suposto, por isso um dia, isso vai acontecer, mas por enquanto...
    Podemos pensar que isto é uma excentricidade, mas se pensarmos outra vez, no fundo o que é que mais fazemos quando programamos? não é manipular Strings?

    oops, não é bem assim...

    Código:
    String a = "cogumelo";
    String b = "cogumelo";
    System.out.println(String.valueOf(a == b));
    // true - a e b são exactamente o mesmo objecto, ou seja,
    // não foi alocado um novo objecto para b,
    // apesar de termos usado um literal para o inicializar
     
    b = new String(a.substring(0,1));
    a = a.substring(0,1);
    System.out.println(String.valueOf(a == b));
    // false - porque apesar de serem a mesma cadeia, b foi criado invocando o construtor.
    // se o gc passasse agora por "cogumelo" não reciclava essa memória, 
    // pois parte ainda está a ser referenciada por a!!!
     
    a = new String("cogumelo");
    b = new String("cogumelo");
    System.out.println(String.valueOf(a == b));
    // false - são objectos diferentes pois chamámos o construtor explicitamente.
    // agora sim, se o gc passar pelo "cogumelo" inicial é provável que seja reciclado
     
    a = "cogumelo";
    System.out.println(String.valueOf(a == b));
    // false - o objecto a continua a ser diferente de b
     
    b = "cogumelo";
    System.out.println(String.valueOf(a == b));
    // true - são o mesmo e um só. será magia?
    
    Quanto à dúvida original do tópico, a forma mais correcta de converter de e para String, int, float, double, boolean, ..., é esta:

    Existe ainda o método valueOf(String) nas classes Boolean, Integer, Double, Float, ... que permitem exactamente converter uma String para uma instância dessa classe.

    Cumprimentos.
     
  20. chrno

    chrno Power Member

    obrigado
    mt + informado agora. eu tinha de entregar um trab hj em k acabei por fazer int+"" msm assim obrigado ja fico esclarecido pa proxima.
    cumps
     

Partilhar esta Página