Ocjp 76%

16 de novembro de 2010 11 respostas

Zabimaru 16 de novembro de 2010

Olá Galera,

Bem é com muito alegria que também estou aqui para falar que passei na prova, agradeço a galera do guj, amigos, família e é claro a paciência da minha namorada, ti AMU loira…rsss
Depois de muito estudar e parar, estudar e parar, finalmente peguei firme e passei na prova, fiz a danada no sábado de manhã e devo dizer que estava muito nervoso, a ponto de ter dor de barriga e de desligar o pc com o joelho, bati no fio, pensem num cara em choque, kkkk.

Bem apesar do meu score, a prova não estava tão díficil não. Que eu contei e que eu estava com medo caíram “apenas” 7 questões de drag and drop, as quais não foram complicadas não.
Dessas caiu a única sobre IO.
Não teve questões sobre assert e nem sobre regex.
E é claro que caíram questões de Generics, Collections e Threads.
Humm…nem lembro a prova toda…mas caíram 2 lá que eram ferradas de TreeSet e uma também com looping rotulado que pelo amor. Caíram muitos que tinham lógica grande mas no fim você tinha que prestar atenção num NullPointer ou Erro de Compilação.
Ficar de olho em OO, modificadores e construtores. Um detalhe foi que eu terminei a prova em 1hr e 30min, ainda sai para ir no banheiro e beber água.

Esqueci de colocar minha preparação para a prova. Como todos fazem eu também li o livro para a certificação, li o SCJP 5 da Katy e deve dizer que eu o acho o melhor para a certificação. Eu tinha lido antes no começo do ano, mas parei de estudar então tive que ler de novo.
Quanto a simulados eu fiz principalmente o testkiller, comecei a fazer o ExamLab, mas estava tão díficil que eu desanimei e parei na metade, pensei que nunca passaria, então não pensem que a prova é igual o ExamLab, ele é muito mais díficil. Não fiz nenhum outro simulado apenas o TestKiller e fazia pequenos simulados na net, tipo em sites e procurava saber o que eu errei.
Sempre que eu não entendia o que tinha errado numa questão eu codificava-a. Uma forma que me ajudou muito também foi o seguinte, quando eu fiz o testkiller fazia assim:

1 - A - ok
2 - B - não ok - Chamando start para a Thread 2x

Assim eu sabia o que eu errei em cada questão e depois de 1 mês estudando e revisando eu refazia o testkiller da mesma forma e comparava com erros e acertos. Então não pense em decoreba é entender e aprender. Na hora da prova você vai ate pensar, puts deveria ter decorado as questões de tão parecidas, mas afinal a certificação não é apenas para “ter”. Eu estudei durante 4 meses, mas não pensem em se matar, ficava sempre que podia com a namorada, jogava meu MMORPG, saía, ia beber tudo normal e sempre que tinha um tempinho no serviço ou em casa estudava, aos sábados claro e alguns domingos eu tirava o dia todo, mas nunca fiquei o feriado prolongado inteiro estudando, por exemplo. Qualquer dúvida é só postar ai galera.

Vlw ai e agora tá completo o post…haha… 8)

11 Respostas

romarcio 16 de nov. de 2010

Parabéns.

Consigo imaginar o nervosismo, hehe.

Essas de drag and drop, foram mais teóricas ou de montar partes de código?

lokits5 16 de nov. de 2010

Parabens !!

o que vc achou mais dificl de se resolver!

abrxx

Zabimaru 16 de nov. de 2010

@romarcio

Caíram ambas tinham teóricas e também para você montar o código, a única de IO, por exemplo, era para montar código

@lokit"s

Cara o que eu achava e ainda acho complicado são as de Collections (principalmente quando elas estao também com Generics), caíram 2 de TreeSet por exemplo que eu “brisei”, não tinha nem idéia para a resposta, chutômero rulez.

lokits5 16 de nov. de 2010

Foram mais ou - assim as questôes de Collections

kkkkkkkkk se não sabe chuta msm rs

Loop típico em uma Collection, usando o Iterator:

Iterator it = colecao.iterator();   
while (it.hasNext()) {   
    String item = (String) it.next();   
    System.out.println(item);   
}  
Iterator it = colecao.iterator();
while (it.hasNext()) {
    String item = (String) it.next();
    System.out.println(item);
}

Loop típico em um Map, usando o Iterator:

Map mapa = new HashMap();   
Iterator itChaves = mapa.keySet().iterator();   
while (itChaves.hasNext()) {   
    Object chave = itChaves.next();   
    Object valor = mapa.get(chave);   
    System.out.println(chave + " = " + valor);   
}  
Map mapa = new HashMap();
Iterator itChaves = mapa.keySet().iterator();
while (itChaves.hasNext()) {
    Object chave = itChaves.next();
    Object valor = mapa.get(chave);
    System.out.println(chave + " = " + valor);
}

Usando um iterator para retirar elementos de uma coleção:

Iterator it = listaCores.iterator();   
while (it.hasNext()) {   
    String item = (String) it.next();   
    if (item.charAt(0) == \'v\') { //retirando as cores que começam com \'v\'  
        it.remove();   
    }   
}  
Iterator it = listaCores.iterator();
while (it.hasNext()) {
    String item = (String) it.next();
    if (item.charAt(0) == \'v\') { //retirando as cores que começam com \'v\'
        it.remove();
    }
}

Utilizando um TreeSet para listar o conteúdo de um Map/Properties de maneira ordenada:

Properties p = new Properties();   
//...   
Iterator it = new TreeSet(p.keySet()).iterator(); //ordena as chaves antes de criar o iterator   
while (it.hasNext()) {   
    String key = (String) it.next();   
    System.out.println(key + "=" + p.getProperty(key));   
}  
Properties p = new Properties();
//...
Iterator it = new TreeSet(p.keySet()).iterator(); //ordena as chaves antes de criar o iterator
while (it.hasNext()) {
    String key = (String) it.next();
    System.out.println(key + "=" + p.getProperty(key));
}

Inicialização de uma Collection:

// Versão normal:   
List listaCores = new ArrayList();   
listaCores.add("vermelho");   
listaCores.add("verde");   
listaCores.add("amarelo");   
listaCores.add("branco");   
  
// Versão abreviada utilizando um array   
List listaCores = new ArrayList(Arrays.asList(new String[] {   
    "vermelho", "verde", "amarelo", "branco" }));  
// Versão normal:
List listaCores = new ArrayList();
listaCores.add("vermelho");
listaCores.add("verde");
listaCores.add("amarelo");
listaCores.add("branco");

// Versão abreviada utilizando um array
List listaCores = new ArrayList(Arrays.asList(new String[] {
    "vermelho", "verde", "amarelo", "branco" }));

Criando e ordenando uma Collection:

List listaCores = new ArrayList(Arrays.asList(new String[] {   
    "vermelho", "verde", "amarelo", "branco" }));   
  
Collections.sort(listaCores);  
List listaCores = new ArrayList(Arrays.asList(new String[] {
    "vermelho", "verde", "amarelo", "branco" }));

Collections.sort(listaCores);

Criando e ordenando uma Collection:

List listaCores = new ArrayList(Arrays.asList(new String[] {   
    "vermelho", "verde", "amarelo", "branco" }));   
  
Collections.sort(listaCores);  
List listaCores = new ArrayList(Arrays.asList(new String[] {
    "vermelho", "verde", "amarelo", "branco" }));

Collections.sort(listaCores);

Intersecção de conjuntos utilizando Set:

Set coresQuentes = new HashSet(Arrays.asList(new String[] {   
    "vermelho", "laranja", "amarelo" }));   
  
Set conjuntoCores = new HashSet(Arrays.asList(new String[] {   
    "vermelho", "verde", "amarelo", "branco" }));   
  
conjuntoCores.retainAll(coresQuentes); // conjuntoCores == {"vermelho", "amarelo"}  
Set coresQuentes = new HashSet(Arrays.asList(new String[] {
    "vermelho", "laranja", "amarelo" }));

Set conjuntoCores = new HashSet(Arrays.asList(new String[] {
    "vermelho", "verde", "amarelo", "branco" }));

conjuntoCores.retainAll(coresQuentes); // conjuntoCores == {"vermelho", "amarelo"}

Zabimaru 17 de nov. de 2010

@lokits

Então caíram mais parecidas com essa:

public String umaString;
public Classe(String umaString) { this.umaString = umaString; }
public static void main(String[] args) {
Set<Object> hash = new HashSet<Object>();
Classe teste1 = new Classe(?bla?);
String outraString = new String(?bla?);
hash.add(teste1 ); 
hash.add(outraString);
System.out.println(hash.size()); 
}


//ou algo assim

List<A> bla = new ArrayList<A>

//ai perguntava o que poderia ser add nesse cara

List<Object>
List<? extends A>
List<? extends B> //sendo que B extends A
List<A>
List<B> //que eu me lembro são +/- essas