java strings duvda???
- Autor do tópico chrno
- Data Início
Mr. Brightside
Banido
Demasiado confuso...
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.
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.
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.
Mr. Brightside
Banido
Como inserir um inteiro numa variável do tipo string?
Código:
String s = "" + n;Em que n é o inteiro a transformar em string.
Obrigado.Código:String s = "" + n;
Em que n é o inteiro a transformar em string.
Como faço depois o return desse valor da string? Já coloquei return, mas dá-me erro.
HecKel
The WORM
Então tens a resposta aqui:
Em que n é o inteiro a transformar em string.Código:String s = "" + n;
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
Mr. Brightside
Banido
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);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.
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.
isto é desnecessário.. a forma que indicaram ("" + n) funciona perfeitamente
em java, não precisas de operador new para Strings (facilidades da linguagem)
"Creating Strings
The most direct way to create a string is to write:
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.
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.
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)
É 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.