Ótima lista de frameworks e componentes feita pelo Fernando Franzini como ajuda na hora de arquitetar um sistema , segue a excelente lista :

Container IoC

Spring – http://www.springsource.org/
Guice – http://picocontainer.codehaus.org/
PicoContainer – http://code.google.com/p/google-guice/
EJB – www.oracle.com/technetwork/java/javaee/ejb/index.html
CDI – http://www.oracle.com/technetwork/articles/java/cdi-javaee-bien-225152.html

Persistência

Hibernate – http://www.hibernate.org/
Spring Data – http://www.springsource.org/
iBatis – http://www.mybatis.org/
Torque – http://db.apache.org/torque/
Castor – http://www.castor.org/
Cayenne – http://cayenne.apache.org/

Gerenciador de Transação

Spring AOP transaction – http://www.springsource.org/
EJB (JTA) www.oracle.com/technetwork/java/javaee/ejb/index.html

Agendamento de Tarefas

Timer Task JSE - http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/threads/timer.html
Quarts – http://quartz-scheduler.org/
EJB Timer Service – http://docs.oracle.com/javaee/6/tutorial/doc/bnboy.html

Validação

Commons Validator – http://commons.apache.org/validator/
Java Bean Validator – http://docs.oracle.com/javaee/6/tutorial/doc/gircz.html

Chamadas Assíncronas

JSE Executor Services - http://docs.oracle.com/javase/tutorial/essential/concurrency/exinter.html
EJB Asynchronous Method Invocation – http://docs.oracle.com/javaee/6/tutorial/doc/gkkqg.html
EJB Message-Driven Bean – http://docs.oracle.com/javaee/6/tutorial/doc/gipko.html

Kit de Interface Gráficas Desktop

Swing – http://docs.oracle.com/javase/tutorial/uiswing/
SwingX – http://swingx.java.net/
JGoodies – http://www.jgoodies.com/
SWT – http://www.eclipse.org/swt/
SWT OPAL – http://code.google.com/a/eclipselabs.org/p/opal/

RAD Interface Gráficas Desktop

Eclipse Windows Builder – http://www.eclipse.org/windowbuilder/
NetBeans Matisse – http://netbeans.org/features/java/swing.html

Framework Web

Click – http://click.apache.org/
Wicket – http://wicket.apache.org/
Spring MVC – http://www.springsource.org/
Struts – http://struts.apache.org/
Mentawai – http://www.mentaframework.org/
JSF – www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html
GWT – https://developers.google.com/web-toolkit/
Vaadin – https://vaadin.com/home
VRaptor - http://vraptor.caelum.com.br/

Framework Web Full Stack

Grails – http://grails.org/
Ruby On Rails – http://rubyonrails.org/
OpenXava – http://www.openxava.org/

Provedores de JSF

Mojorra – http://javaserverfaces.java.net/
MyFaces – http://myfaces.apache.org/
ADF – www.oracle.com/technetwork/developer-tools/adf/overview/index.html

Componentes JSF

RichFaces – http://www.jboss.org/richfaces
PrimeFaces – http://primefaces.org/
OpenFaces – http://openfaces.org/
IceFaces – http://www.icesoft.org/
EasyFaces – http://www.easyfaces.com.br
Gmaps4jsf – http://code.google.com/p/gmaps4jsf/

Extensões JSF

PrettyFaces - http://ocpsoft.org/prettyfaces/
Omnifaces – https://showcase-omnifaces.rhcloud.com/

Soluções Web Mobile

JSF RichFaces Mobile – http://www.jboss.org/richfaces
JSF PrimeFaces Mobile – http://primefaces.org/
JSF OpenFaces Mobile – http://openfaces.org/
JSF IceFaces Mobile – http://www.icesoft.org/
Spring Mobile – http://www.springsource.org/
JQuery Mobile – http://jquery.com/
DOJO Mobile – http://dojotoolkit.org/

Autenticação e Autorização Web

Spring Security – http://www.springsource.org/
JGuard – http://jguard.xwiki.com/xwiki/bin/view/Main/WebHome
JEE Container Managed Security (Configuração particular). Tomcat – http://tomcat.apache.org/tomcat-7.0-doc/realm-howto.html

JEE Web Container Standalone

Tomcat – http://tomcat.apache.org/
Jetty – http://jetty.codehaus.org/jetty/
JBoss – http://www.jboss.org/

JEE EJB Container (Web Profile e JEE Full)

Tomee – http://openejb.apache.org/apache-tomee.html
Simpas – http://siwpas.mechsoft.com.tr/
Resin – http://www.caucho.com/resin-application-server/
JBoss – http://www.jboss.org/
Glassfish – http://glassfish.java.net/
Webshere – http://www-142.ibm.com/software/products/br/pt/appserv-was
WebLogic – http://www.oracle.com/us/products/middleware/application-server/weblogic-suite/index.html?ssSourceSiteId=ocombr
Geronimo – http://geronimo.apache.org/

Relatórios

iReport – http://jasperforge.org/projects/ireport
DynamicReport – http://dynamicreports.sourceforge.net/
Birt – http://www.eclipse.org/birt/phoenix/
iText – http://itextpdf.com/
PDFBox – http://pdfbox.apache.org/

Gerador de Gráficos Charts

JFreechart - http://www.jfree.org/jfreechart/
HighCharts - http://www.highcharts.com/

Web Services REST

Jersey – http://jersey.java.net/
Restlet – http://www.restlet.org/
RestEasy – http://www.jboss.org/resteasy/
Serfj – http://serfj.sourceforge.net/
CXF – http://cxf.apache.org/

Web Services SOAP

Metro – http://jax-ws.java.net/
Axis – http://axis.apache.org/axis/
XFire – http://xfire.codehaus.org/
CXF – http://cxf.apache.org/

JavaScript

DOJO Toolkit – http://dojotoolkit.org/
JQuery – http://jquery.com/
Ext-JS – http://docs.sencha.com/ext-js/4-0/
DWR – http://directwebremoting.org/dwr/index.html

Integração com Redes Sociais

Spring Social – http://www.springsource.org/

Cache

Space4J – http://www.space4j.org/
Memcache – http://memcached.org/
Ecache – http://ehcache.org/
Prevayler – http://prevayler.org/
JBoss Infinispan – http://www.jboss.org/infinispan.html

NoSQL

MongoDB – http://www.mongodb.org/
Neo4j – http://neo4j.org/
Db4o – http://www.db4o.com/
MemcachedDB – http://memcachedb.org/
CouchDB – http://couchdb.apache.org/
Project Voldemort – http://project-voldemort.com/
MarkLkogic Server – http://www.marklogic.com/
BaseX – http://basex.org/
SimpleDB – http://aws.amazon.com/simpledb/
HBase – http://hbase.apache.org/
Casandra – http://cassandra.apache.org/
Hypertable – http://hypertable.org/
OrientBD – http://www.orientechnologies.com/

SGDB Java Embutidos

HyperSQL – http://hsqldb.org/
JavaDB – www.oracle.com/technetwork/java/javadb/overview/index.html
Apache Derby – http://db.apache.org/derby/
H2Database – http://www.h2database.com

Testes

DBUnit – http://www.dbunit.org/
JUnit – http://www.junit.org/
EJBUnit – http://ejb3unit.sourceforge.net/
JSFUnit – http://www.jboss.org/jsfunit/

Loggin

jse – http://docs.oracle.com/javase/7/docs/api/java/util/logging/package-summary.html
Log4J – http://logging.apache.org/index.html

Testes Cargas e Perfomance

JMeter – http://jmeter.apache.org/
WebLoad – http://www.webload.org/

JSON

JSON – http://www.json.org/java/
XStream – http://xstream.codehaus.org/json-tutorial.html
Google-JSON – http://code.google.com/p/google-gson/

Boletos Bancário

Boletos Bancário – http://www.boletobancario.com.br
Bopepo – www.jrimum.org/bopepo/
Stella – github.com/caelum/caelum-stella/wiki/Gerando-boleto

Manipulaçao de Arquivos MS Office

Apache POI – http://poi.apache.org/
JExcelApi - http://jexcelapi.sourceforge.net/
Docx4j – http://dev.plutext.org/trac/docx4j
Java Docx – http://www.javadocx.com/
Aspose – http://www.aspose.com/categories/java-components/aspose.total-for-java/default.aspx

Gerais

Maven – Gerenciador de dependências – http://maven.apache.org/
E-mail – Gerenciador de emails – www.oracle.com/technetwork/java/javamail/index.html
JLicense – Gerenciador de licenciamento de uso de software –http://www.websina.com/products/jlicense.html

Créditos a Lista : Fernando Franzini

Para quem está querendo tirar essa certificação recomendo este livro como fonte de estudo.

Link Amazon : Clique aqui.

Introdução

A grande mudança no iOS 5 foi o novo recurso adicionado chamado de contador automático de referência (ARC - Automatic Counting Reference).ARC é uma característica do novo compilador LLVM 3.0 que acaba completamente com o gerenciamento de memória manual.Usar o ARC em seus projetos é extremamente simples.Você mantém o mesmo código, como de costume, exceto que você não precisa realizar chamadas a release , retain ou ao autorelease.O ARC realiza todas essas tarefas pra você :).
Com o ARC habilitado , o compilador irá inserir automaticamente retain,release e autorelease nos lugares corretos em seu programa.

Como o ARC funciona?

Você provavelmente já está familiarizado com o gerenciamento de memória manual, que funciona basicamente assim:

• Se você precisa manter um objeto , você deve retê-lo (retain), a menos que já foi retido para você.
• Se você quiser parar de usar um objeto , você precisa para liberá-lo (release), a menos que já foi liberado para você ( com o autorelease).

Acho que para todos no começo , essa tarefa de entender o gerenciamento de memória manual é algo difícil,mas com o tempo se torna natural manter o balanceamento dos retains e releases .Exceto quando você esquece de realizar essa tarefa rs
Os princípios de gerenciamento de memória manual não são difíceis, mas é muito fácil cometer um erro. E esses pequenos erros podem ter consequências terríveis. O seu aplicativo irá falhar em algum ponto, porque você lançou um objeto muitas vezes e suas variáveis ​​estão apontando para dados que já não é válido, ou você vai ficar sem memória, porque se você não liberar os objetos acontecem os famosos leaks.
O Static Analyzer do Xcode é uma grande ajuda para encontrar esses problemas , mas o ARC vai um passo além.O ARC evita problemas de gerenciamento de memória completamente ,inserindo o retain e o release pra você.
É importante perceber que a ARC é uma característica do compilador do Objective-C e, portanto, todo o trabalho do ARC é feito na compilação do seu programa. O ARC não é uma característica de tempo de execução (com exceção de uma pequena parte, o sistema de weak pointer), nem é um garbage collector.

Ponteiros mantém os objetos em memória

As novas regras que você tem que aprender para o ARC são bastante simples. Com o gerenciamento de memória manual você precisava dar um retain no objeto para mantê-lo em memória. Isso já não é necessário, tudo que você precisa é fazer um ponteiro para o objeto.
Enquanto há uma variável que aponta para um objeto, esse objeto permanece na memória. Quando o ponteiro chega um novo valor ou deixa de existir, o objeto associado é liberado (release). Isto é válido para todas as variáveis​​:variáveis ​​de instância, propriedades, e até mesmo,variáveis ​​locais.
Veja o seguinte exemplo :

1

     NSString * firstName = self.textField.text;

A variável firstName é um ponteiro para o objeto string “Ray” que guarda o valor do campo de texto.Essa variável agora também é proprietário do objeto string “Ray”.

Um objeto pode ter mais de um dono. Até que o usuário não mude o conteúdo do UITextField,a propriedade self.textField.text também é um proprietário do objeto string “Ray”. Existem dois ponteiros para manter esse objeto em memória :
Momentos depois, o usuário vai digitar algo novo no campo de texto e sua propriedade de texto agora aponta para um novo objeto string. Mas o objeto string original ainda tem um proprietário (a variável firstName) e, portanto, permanece na memória.

Somente quando firstName recebe um novo valor também, ou sai do escopo - porque é uma variável local e o método termina, ou porque é uma variável de instância e o objeto a que ela pertence é desalocado .O objeto string não tem mais proprietários, o seu retain count é 0 e ele é desalocado.

Chamamos ponteiros como firstName e textField.text de strong porque mantém os objetos vivos (em memória). Por padrão, todas as variáveis ​​de instância e variáveis ​​locais são ponteiros strong.
Há também um ponteiro chamado de weak. Variáveis ​​que são weak ainda pode apontar para objetos, mas eles não se tornam proprietários.
Veja o seguinte exemplo :

1

__weak NSString * weakName = self.textField.text;

A variável weakName aponta para o mesmo objeto string “Rayman” que a propriedade self.textField.text aponta , mas ela não é proprietária do objeto.
Se o campo de texto alterar o conteúdo, então o objeto string “Rayman” não tem mais donos e é desalocado.

Quando isso acontece, o valor de weakName torna-se automaticamente nulo.Note que este é extremamente conveniente, pois impede ponteiros weak de apontar para a memória liberada.
Você provavelmente não vai usar muito os ponteiros weaks. Eles são principalmente úteis quando dois objetos têm uma relação parent-child. O parent vai ter um ponteiro strong para seu child - e, portanto, é o “dono” - mas, a fim de evitar ciclos de propriedade, o child só tem um ponteiro weak de volta para seu parent.
Um exemplo disto é o padrão delegate. Seu UIControllerView pode possuir um UITableView através de um ponteiro strong. Já o data source e o delegate apontam para o UIControllerView mas são weaks ponteiros.

Veja o seguinte exemplo :

1
2

__weak NSString *str = [[NSString alloc] initWithFormat:...];
NSLog(@"%@", str);  // a saída será "(null)"

Não existe um dono para o objeto string (porque str é fraco) e o objeto será desalocado imediatamente após ele ser criado. O Xcode vai dar o seguinte aviso quando você faz isso ,porque provavelmente não é o que você quer fazer.

1

(“Warning: assigning retained object to weak variable; object will be released after assignment”).

Você pode usar a palavra-chave __strong para falar que uma variável é um ponteiro strong:

1

__strong NSString *firstName = self.textField.text;

As variáveis ​​são strong por default e o __strong pode ser omitido. Propriedades também podem ser strong e weak. A notação para propriedades é:

1
2

@property (nonatomic, strong) NSString *firstName;
@property (nonatomic, weak) id <MyDelegate> delegate;

O ARC vai remover um monte de lixo do seu código. Você não tem que pensar sobre quando usar o release ou quando usar o retain, apenas sobre como os objetos se relacionam entre si.

Traduzido de : http://www.raywenderlich.com/5677/beginning-arc-in-ios-5-part-1.