Chip de Elite

Pool de Strings e um mito desmitificado

public class Ex {
String str1 = new String("musica");
String str2 = "musica";

...
}

Por incrível que pareça, essas duas formas de instanciação de String são completamente diferentes.
A variável str1 tem seu valor armazenado no heap de memória reservado para o objeto que a cria. A segunda como não é criada com o operador new, tem seu valor armazenado em uma região especial da memória de JVM chamada de pool de Strings. E você diz, e daí?

O pool de String foi criada para economizar memória. Como?
String str1 = "musica";
String str2 = "musica";
String str3 = "musica";
String str4 = "musica";

Bytes usados somente para conteúdo: 6 bytes.
Todos estão em posicão diferentes no heap. Contudo, eles apontam para o mesmo valor de memória. Assim, temos economia.

String str1 = new String("musica");
String str2 = new String("musica");
String str3 = new String("musica");
String str4 = new String("musica");

Bytes usados somente para conteúdo: 24 bytes.

Agora, porque ter a opção de gastar memória para aparentemente fazer a mesma coisa? Quando Strings são instânciadas sem new, é necessário procurar o valor recebido no pool, assim, é mais custo por ter comparação.

Agora, vou desmitificar um mito do java, a comparação de Strings. Quem disse que só dá para comparar por equals(String)::boolean?

O método intern()::String da classe String permite comparação por != e ==.
A descrição do método diz que ele retorna a forma canônica da String, como se fosse um tipo primitivo. Contudo, www.paste.la/861 dá a entender que ele cria o conteúdo da String no pool.

James Gosling (criador do Java), afirma em seu livro, A linguagem de programação Java, que comparar por intern()::String é mais eficiente.

Exemplo operador de canalização

A pedidos do Yuri e do Dolly eu fiz um exemplo com dois programas.

Em http://phpfi.com/331389, contém um programa em Java que Lê palavras que uma pessoa digitou até que essa palavra seja "parar". Após isso ele exibe na tela o que foi digitado.

Em http://phpfi.com/331392, contém um programa em C++ que faz tb a mesma coisa.

Executando:

C:\caminho> java Ex
carro
casa
parar

carro
casa

Agora, rodando assim:
C:\caminho> java Ex > saida.txt
carro
casa
parar

As palavras foram armazenadas em saida.txt.

Executando o programa em C++, que tem o nome de rec.cpp:
C:\caminho> rec.exe
Recebendo entrada
pipa
pirulito
parar

pipa
pirulito

Agora, executando assim:
C:\caminho> rec.exe < saida.txt
carro
casa

Acho que ficou legal esse exemplo. Espero que tenham gostado. Muito legal essa interação.
Se seu código será utilizado com canalização apenas tome cuidado para que mensagens de impressão erradas não ocorram, para que não afete a saída canalizada.

Exemplo de código possívelmente errado:

#include "stdio.h"

void main(void) {
int i = 0;

while(i < 10) {
printf("%d\n", i);
i++;
}
printf("Total: %d", i); //possivel problema aqui
}

Suponha que é desejado redirecionar a saída para um arquivo. TUDO que for impresso na tela será canalizado.

0
1
2
3
4
5
6
7
8
9
Total: 10

Vêem o problema? As vezes, mensagens que ficam "legais" na impressão na tela (Total 10), quando canalizados desformatam os dados. Se outro programa for ler o arquivo, Total: 10, pode causar um exceção ou um erro lógico.

E aguardem o próximo tópico de Java: Pool de String.

Grafo de lista de adjacências

Neste link:


Em http://phpfi.com/351140 está um grafo de lista de adjacências que eu fiz. Cresce dinamicamente na memória através de linkedlist. A classe implementa uma interface chamada Graph, em http://phpfi.com/331380. Esta foi pensada em que métodos básicos todo grafo deve ter. Métodos como número de arestas incidentes em um vértice e blá blá blá, podem ser inferidos através dos métodos de get. A única coisa necessária para tal inferência é ter suficiência cerebral.

As assinaturas dos métodos foram criadas de modo que os usuários e leitores da classe os entendem-se de modo intuitivo.

Métodos de acesso aos dados do grafo são sincronizados, já que uma estrutura de dados é comumente acessada por Threads.

Implementa Cloneable, para que seja possível clonar o grafo sem que haja referências comuns de memória. E é serializável.

A estrutura pode ser usada como tabela hash!!

Falta chão para terminar a documentação.

Operadores de canalização

Os operadores de canalização são ferramentas dos Sistemas Operacionais extremamente simples, contudo, poderosas.

Tanto para o Windows como para o Unix\Linux existem esses dois operadores "<" ">".
Eles são capazes de redirecionar a saída de um processo para qualquer coisa que possa servir de entrada ou saída.

Exemplo com esse programinha em C++.

#include "iostream"

using namespace std;

int main() {
cout << "Oi";
return 1;
}

Vamos chama-lo de oi.cpp -> compilando -> oi.exe
Quando é executado a seguinte mensagem aparece na tela:
Oi

Se executarmos dessa forma: oi.exe > teste.txt
A saída do programa, que é a tela, é redirecionada para o arquivo teste.txt!!
Assim, é possível criar um programa que tenha saídas completamente diferentes!!!!


oi.exe > prn faz a saída sair na impressora, nunca testei com prn, li isso em um livro.

Não sei se você captou a importância disto. Espero que sim.

O operador "<" faz o contrário, muda a entrada. Assim, ao invés da entrada ser um arquivo é possível redirecionar para a tela.

O legal é que funciona independentemente da linguagem que o programa foi escrito.

Perdeu playboy