Ola, estou com duvida em relacao a usar String ou char[] para guardar uma string.
Eu sei o tamanho da string…
Preciso usar a menor quantidade de memoria possivel…
Devo usar String ou char[]? Ou devo usar byte[]?
Vlw!
Depende de quão restrita é sua memória… uma string guarda internamente um array de chars mas tambem algumas (poucas) outras informações no entanto a máquina virtual java tem algumas otimizações para o armazenamento da mesma especialmente em casos de repetições de strings… então o contexto a ser analizado é mais abrangente do que simplesmente a restrição da memória.
Nossa, vc veio da galera do C né? Hehe…
Pra criar uma string usa a classe String mesmo, se for concatenar usa StringBuilder.
Vc vai pegar essa string de onde?
Seguindo as boas práticas do JAVA eu recomendaria fortemente o uso de String.
usa String acredito que a diferença entre o uso de memoria não seja grande alem do mais
String vc ja vai ter os metodos de comporação e tudo mais
100% String 
[]'s
Faça um benchmark entre as duas formas e depois veja se as mudanças necessárias para trabalhar com char[] ao invés de String não são proibitivas. Se vc tiver 2% a mais de performance compensa? Pensa bem…
Eh q eu achei procurando no google, o tamanho de uma String:
Total String Object incl. Dependent Array === 38±2 + 2*(String length)
Dai conclui q se usasse byte[] seria melhor. Criei uma funcao pra transformar byte[] pra String e uma pra comparar direto byte[] com String. O melhor desempenho, mesmo q seja 2%, eh necessario na minha aplicacao 
To em duvida :!:
Pergunta: por que é que é necessário usar a menor quantidade de memória possível (em vez de usar Strings usar byte[], que introduz na sua aplicação uma dependência de “encoding” e dificulta sua manipulação)?
Dependendo do que você está a fazer, você acabará economizando memória no lugar errado, talvez tornando o consumo até maior que o esperado e deixando sua aplicação muito mais complexa que o necessário.
Nao vai ficar complexa, fiz funcoes pra transformar byte pra string, string pra byte e compara 2 strings.
Acho q vo usar byte[], pq o ganho de memoria eh importante pra mim.
Eh eu vim da galera de C xD
Vlw!
Se você teve que REimplementar tudo, então já ficou complexo.
Poxa, não justificaria nem se você fosse programar em JME…
Abandone essa idéia de programar em Java pensando em C. Não é nem um pouco produtivo ficar lutando contra a linguagem, a não ser que você tenha muito tempo ( e paciência ).
Eu sou da galera de C++ e só uso char * (ou wchar_t *, que é a versão Unicode do char *) só em último caso.
Sempre uso <string> ou <wstring>. (A propósito, também não gosto de CString - já tive muitos problemas com ele, e embora eu saiba exatamente como ele funciona, sei que ele também é usado incorretamente.)
Eh q eu to fazendo um servidor, dai quanto menos memoria melhor…
Em minha experiência, quando você faz um servidor, quanto mais fácil de manter o código, é que é melhor. Normalmente servidores têm montes de memória para gastar (programas clientes é que têm limitações sérias de memória).
Gasto de memória só precisa ser avaliado se você determinou, através de alguma análise, que isso realmente é importante. Parece que você só está achando que vai gastar memória com strings, mas não sabe exatamente quanto.
Nao vai ficar complexo, pq eu n implementei ainda, mas entao, no meu banco de dados compensa fazer esta economia certo?
Mudando de assunto, existe alguma funcao q bloqueie um IP para conexoes TCP/IP via sockets? Antes do server socket dar um accept?
Vlw!
Você quer criar um banco de dados? Então provavelmente vai ter de lidar com dois tipos de strings:
-
A representação String como um array de caracteres (2 bytes por caracter) - isso para efetuar as comparações entre strings e outras coisas mais;
-
A representação String para ser gravada no disco como a representação UTF-8 dos dados Unicode (em média 1 byte por caracter).
Mas as strings em memória, devido à velocidade que você deve ter para poder efetuar as comparações e outras operações, devem ser representadas como String mesmo, não como byte[]. É que todos os problemas de “collation” e outras coisas são mais fáceis de serem resolvidos com String que com byte[] que você tem de converter e desconverter para String.
Acho que o único lugar onde Strings podem ser representadas como byte[] é em um cache em memória que represente um pedaço do arquivo de disco, como temporário. No resto do seu programa, use String mesmo.
Outra pergunta, existe um sleep em micro ou nano segundos em java?
Vlw!
sleep é algo que chama o sistema operacional diretamente. No caso do Windows, Thread.sleep chama (basicamente) a API do Windows “Sleep”, que aceita apenas valores com precisão de milissegundo (mas a exatidão pode ser de apenas dezenas de milissegundos).
Sleep basicamente faz com que o scheduler do Sistema Operacional chaveie para outra thread ou processo e prometa voltar dentro do tempo que você configurou para a sua thread. Pode ser que o SO se atrase porque foi tratar algo mais prioritário ou então porque as interrupções foram desabilitadas por muito tempo, por isso Sleep nunca é muito exato.
No caso do Linux ele até chama “select” ou outras APIs que aceitam valores mais precisos (nanossegundos), mas a exatidão continua sendo de alguns milissegundos.
Então a resposta simples é “não”.
Se você precisar de algo com exatidão maior (microssegundos ou nanossegundos) é preciso ver se nas APIs do Java que lidam com Multimedia existe isso.
http://java.sun.com/javase/6/docs/api/java/lang/Thread.html#sleep(long,%20int) aceita milissegundos e nanossegundos (quem mandou não ter lido o Javadoc? ) mas na prática os nanossegundos são ignorados.
Vlw 
Outra pergunta:
Existe alguma maneira de bloquear conexoes vindas de um IP por Java ou por algum outro programa? (Preferencialmente pelo Java :shock: )
Vlw msm! Flw!