Vamo que vamo.

O Blog-Health-o-Meter indica: Este blog é fantástico!.

Números apetitosos

Um Boeing 747-400 transporta 416 passageiros. Este blog foi visitado cerca de 1,600 vezes em 2010. Ou seja, cerca de 4 747s cheios.

Em 2010, escreveu 21 novos artigos, nada mau para o primeiro ano! Fez upload de 2 imagens, ocupando um total de 220kb.

The busiest day of the year was 6 de julho with 33 views. The most popular post that day was List, Set, Map o que é e como usar?.

De onde vieram?

Os sites que mais tráfego lhe enviaram em 2010 foram javafree.uol.com.br, google.com.br, obama-scandal-exposed.co.cc, pt-br.wordpress.com e android-vs-ipad.co.cc

Alguns visitantes vieram dos motores de busca, sobretudo por o que é encapsulamento, diferença entre list set, linkedhashset o que é, set ordenado e o que é encapsulamento?

Atracções em 2010

Estes são os artigos e páginas mais visitados em 2010.

List, Set, Map o que é e como usar? abril, 2010
7 comentários

O que é Encapsulamento? É util? abril, 2010

Certificações Java setembro, 2010

Guia de Estudos – SCJP setembro, 2010
1 comentário

Argumentos relacionados a memória da JVM junho, 2010
2 comentários

Referência é como um terror assolando os códigos do Java, é ótimo ter referência nos objeto e trabalhar com elas… mas é perigoso ao mesmo tempo. A String e os Numbers provam isso a cada dia, como pode ser complicado trabalhar com o operador mágico e confuso “==”.

Como isso é confuso não? Com String nunca se usa o ==, mas nunca mesmo. Mas por que?

Toda string criada é guardada em um pool de strings na jvm, mas as referências mudam e como mudam.

– “aa” == “aa”, false.
– “aa”.equals(“aa”), true.

E quando falamos de inteiros? Ai complica…
– 1 == new Integer(1), true.
– 1 == 1, true.
– new Integer(1) == new Integer(1), false.
– new Integer(1).equals(new Integer(1)), true.

Mesmo vale para todos os outros Number’s.

Outra observação extremamente importante é:

Quando temos polimorfismo, ou seja:

public static boolean equals(Object o) {
    return o.equals(new Integer(1));
}

public static void main(String[] args) {
    System.out.println(equals(new Integer(1)));
}

Qual é o retorno desse método? FALSE!!!!
Isso em termos é um completo absurdo, deveria retornar de acordo com a classe final, mas enfim, não funciona. Se usar Generics funciona.

Então para constar, esse é o tipo de resultado que pode complicar e muito na hora de debbugar um código por se tratar de um erro complicado de se encontrar…

Fiquem ligados

Esse entrySet é uma implementação do Map.Entry que vem para otimizar a velocidade das consultas de tal forma que traga os valores e a chave sem se preocupar com necessariamente com hash’s.

A importância deste é para quando se realiza iterações de alta escala e se requer muitos registros dentro desse mapa e com isso se gera uma boaaa otimização.

Outro ponto é nunca instanciar o mapa para copiar valores e depois remover, como exemplo:

Map<Integer, String> mapCopy = new HashMap<Integer, String>(map);
mapCopy.keySet().retainAll(keySetFilter); //nunca!! muito lento!

Façam a cópia filtrando com if’s/contains adicionando ao novo mapa e com isso ganham mais da metade em performance e CPU Time.

Quando lemos um “BeanService” sabemos que se trata de um serviço, um
provedor de funcionalidades.

Quando lemos um “SQLFactory” entendemos que é uma fábrica de criação de
SQLs.

Vejo muitos mal usos dessas nomenclaturas visando deixar o código mais
“chique”, não dá pra entender, talvez pela ausência do conhecimento de
inglês?

Temos sempre que ao Nomear um POJO ter o cuidado de adequar o
nome ao seu conteúdo, se notar que a coesão do mesmo está fugindo do
escopo da classe, ou passe está parte para outra classe ou mude o nome da mesma
para abranger estes novos requisitos…

Quando um projeto cresce muito e tem essas variantes tristes se torna complicado de reutilizar o código por que você se quer imagina o que se trata.

Então, de forma resumida, nomenclaturas mal elaboradas causam falta de coesão e falha na reutilização do código.

Acho que é mais uma opinião minha, enfim segue como sugestão.

Basicamente deve-se existir já um estudo prévio do conteúdo, ou seja, Java.

Se você já programa java a algum tempo não deve ter dificuldade de fazer esta prova, a parte que se diz mais difícil é Threads. Mais a que eu fui mal mesmo é a parte que não se usa muito, como empacotamento (jars etc)….
Essas coisas acabam ficando de lado né? :).

Eu li o livro “SCJP Sun Certified Programmer for Java 6 Exam 310-065” em inglês mesmo que acho mais fácil a leitura… (acaba por trazer os mesmos termos que são usados e conhecidos).

Tem também o “Certificação Sun para Programador Java 5 – Guia de Estudo” que é a versão 5 do livro que é tranqüila mesmo para a certificação da 6, que trás poucas diferenças (Queue e outra collection que não me recordo).

Lendo este livro já deve bastar, mas recomendo também a série Head’s First que aborda de uma forma mais alegre os temas, mas não é focado na certificação.

Ponto principal do estudo é realizar simulados, que são muito próximos da realidade das provas, isso ajuda muito e normalmente os simulados são bem mais difíceis. Passando bem nos simulados você está pronto para fazer as provas ;).

Software que recomendo para simulados é o EnthuWare que o próprio MOCK deles é parecido com o da certificação.

Todo caso existem outros grátis (fiz um apanhado da net então não sei se todos estão rolando):

http://www.javaranch.com/mock.jsp
http://www.geocities.com/SiliconValley/Orchard/9362/java/javacert/index.html
http://www.examulator.com/phezam/login.php
http://www.danchisholm.net/
http://www.jchq.net/mockexams/exam1.htm
http://www.jchq.net/mockexams/exam2.htm
http://www.jchq.net/mockexams/exam3.htm
http://www.javaranch.com/maha/_Mock_Exams/JohnJuntMockExam.htm
http://www.javacertificate.com
http://www.javaranch.com/maha/_Mock_Exams/MindQ_s_…a_Programmer_Practice_Test.htm
http://www.geocities.com/skmajji/Main.html
http://www.angelfire.com/or/abhilash/Main.html
http://www.tipsmart.com/javacert/ptp/basics.htm
http://www.geocities.com/online_java_certification/
http://www.4tests.com/exams/examdetail.asp?eid=61
http://www.geocities.com/sahirshah/applets/mocktest.html
http://www.certificacaojava.com.br/certificacaojava/
http://www.valoxo.ch/jr/mocks/mock01a.html
http://www.jdiscuss.com/
http://www.akgupta.com/Java/mock_exam.htm
http://www.tarcisiolopes.com/javacert/quest001.htm
http://javaquestion.tripod.com/id10.html
http://valiveru.tripod.com/java/jvaltest.html
http://www.ii.uib.no/~khalid/pgjc/jcbook/engine.html
http://www.ejavaguru.com/scjp5freemockexam.php

Se alguém tiver mais alguma dúvida ou sugestão ou mesmo sucesso com ajuda do meu guia, comentem ai :).

Quando se usa esse padrão geralmente se cria muitos códigos aninhados, talvez abusando um pouco dessa flexibilidade que ele promove. Exemplo:

StringBuilder sb = new StringBuilder()
.append(" SELECT * FROM usuarios ")
.append(" WHERE usuarios.codigo = ?");

Imagine agora esse código sofre um “Format code” no eclipse por exemplo, vai bagunçar tudo. Agora imagine milhares de select’s em uma classe DAO gigantes que sofreram esse “Format code”, fica inviável a manutenção dos mesmos sem reformatar tudo. Aconselho que não usem a interface fluente para este tipo de tarefas e não abusem do uso dela, ela foi criada para facilitar alguns comandos sequenciados, como por exemplo:

numero.soma(numero1).menos(numero2);

Mais um exemplo de leitura difícil com uso da interface fluente:

Antes:

list.addAll(removeDuplicates(mapQueryParameters(session.createQuery(hql.toString()), parameters).setFirstResult(numPag * tamPag).setMaxResults(tamPag).list()));

Depois:

Query query = session.createQuery(hql.toString());
parameters.mapQuery(query);
query.setFirstResult(numPag * tamPag).setMaxResults(tamPag);
list.addAll(removeDuplicates(query.list()));

Então pensem bem quando e como usar…

Dentro da Sun Microsystem (atualmente do grupo da Oracle) existem diversas certificações voltadas ao Java, a grade antes da entrada da Oracle era composta de:

• SCJA: Sun Certified Java Associate
• SCJP: Sun Certified Java Professional
• SCJD: Sun Certified Java Developer
• SCWCD: Sun Certified Web Component Developer
• SCBCD: Sun Certified Business Component Developer
• SCDJWS: Sun Certified Developer for Java Web Services
• SCMAD: Sun Certified Mobile Application Developer
• SCEA: Sun Certified Enterprise Architect

Existem algumas modificações feitas pela Oracle, adições e “separações” mas que ainda não considero importante.

SCJA é dispensável, totalmente. A SCDJWS também não demonstra muita utilidade, já é abordada no estudo da SCBCD.

A mais fácil dentre elas é sem dúvidas a SCWCD. A mais difícil é a SCEA não tirando os méritos da SCBCD.
É importante se certificar a empresa ganha muito com isso e você profissionalmente nem se fala.
Atualmente eu sou certificado em SCJP e SCBCD, estou planejando a SCWCD mas vou terminar TCC primeiro.
Vou demonstrar o caminho que tracei para passar com sucesso na SCJP e na SCBCD.

Troquei o tema, espero que este esteja mais adequado leitura e um pouco mais “moderno”.

A partir de agora estarei tentando me tornar mais ativo em relação ao Blog.

Então aguardem por novos posts :).

JVM’s de 32 bits tem uma limitação de 1280m de memória Heap (-Xmx) sendo isso um problema quando a aplicação J2EE tem grande número de acessos e usa bastante memória (por exemplo com uso do Hibernate).

Isso causa muitos problemas sendo a melhor e mais fácil solução uma migração para uma JVM de 64bits que não “existe” limitação de memória podendo utilizar a memória a seu máximo. Se a maquina ainda for Sun existem outras opções que podem ser úteis.

Só para explicitar a vantagem, talvez imaginária para alguns, servidores não chegam só a 16gb de memória como podem imaginar… Podem chegar a absurdos 4TB de memória (
Sun SPARC Enterprise M9000 Server
)

Isso torna as aplicações bem viáveis sem pensar no lado financeiro não?