quais dessas linhas sao validas?
- long l[] = new long[(long)100];
- short s[] = new short[(short)100];
- char c[] = new char[‘b’];
- int i1[] = new int[]{1,2,3,4,5};
- int i2[] = new int[5]{1,2,3,4,5};
- int i3 = new int[]{1,2,3,4,5}[2];
Será que é a opção 1 ?? (long l[] = new long[(long)100]) :shock:
Todas, menos a 1 e a 5.
A primeira, pq o inicializador da array espera um int (e não um long), e a quinta, pq se vc está declarando quais são os elementos da array, não faz sentido colocar o tamanho (lembre-se que arrays são imutáveis :))
a 1 e a 5 tudo bem, essas eu sabia que nao funcionava
mas a 6 eu achei bem estranho, nao cheguei testar aqui
mas nunca vi algo parecido, principalmente porque na primeira parte nao esta informando que sera um array
int i3 = new int[]{1,2,3,4,5}[2];o certo nao seria int i3[] =…???
Nao… vc nunca vai ver essa construção num programa de verdade, pq ela é bem idiota:
O que isso faz:
- cria um novo array de ints, com os valores 1, 2, 3, 4 e 5
- pega o 3o valor da array
- declara uma variável int, i
- atribui o 3o valor da array em i
Ou seja, i vale 3 
humm, muito interessante
entao na verdade o i nao é uma array e sim o i é um dado primitivo com o valor de 3.
boa questão pra certificação, eu rodaria legal nela :lol:
Uma melhor ainda pra certificação é: o int[] que foi criado é coletável pelo GC? E se fosse um [] de Objects?
boa pergunta… acredito que o array de int[] nao vai ser coletado… se fosse de objetos seria coletado… certo?
Eu acho que todos os dois são coletados pelo GC…
O array de objetos com certeza que vai. O de int eu também acho que vai ser, pq o array vai ser alocado dinamicamente, apesar de ser de um tipo primário
Eu acho que vai. Como se pode ler em http://java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html :
Como depois não há referencias para ele, acho que é perfeitamente elegivel para o GC. No caso de ser um array de Objects, acredito que o GC vai verificar se alguns dos Objects do array está sendo referenciado por alguem. Nesse caso, confesso que estou com duvida. Creio que seja um caso parecido com:
public class Teste1 {
public static void main(String[] args) {
Teste2 teste2 = new Teste2();
Teste1 teste1 = teste2.teste;
teste2 = null;
// aqui.
}
}
class Teste2 {
public Teste1 teste;
public Teste2() {
this.teste = new Teste1();
}
}Em “aqui”, o objeto que era referenciado por teste2 é elegivel para o GC? Eu acho que não… mas não tenho certeza.
Até mais.
Acho q ele (teste2.teste) não é elegível para o GC não, pois haverá uma referência para ele (teste1). O objeto teste2 pode ser recolhido pelo GC, mas o teste2.teste continua.
Eu acho
[quote=“baiano_mg”]Acho q ele (teste2.teste) não é elegível para o GC não, pois haverá uma referência para ele (teste1).
[/quote]
Tranquilo… isso é facil de perceber.
[quote=“baiano_mg”]
O objeto teste2 pode ser recolhido pelo GC, mas o teste2.teste continua.
Eu acho[/quote]
Bom, o objeto referenciado por teste2 encapsula o outro que é referenciado por teste1. Então, se teste2 for coletado, o outro tambem irá para as cucuias, certo?! Mas, não é para isso acontecer já que ainda há uma referencia valida para ele, no caso teste1.
É aí que eu vejo semelhança com a questão levantada pelo cv sobre arrays: se um elemento do array ainda é referenciado por alguem, mas o array não, o array será coletado? Eu acho que não. Quer dizer, sei lá.
Ah… acabei de perceber que escolhi extremamente mal os nomes das variaveis e classes do meu exemplo. :oops:
Ficou uma misturebada só.
Até mais.
Nesse caso eu acho q funciona assim…
Quando nao se tem referencia pra um objeto (o1) que eh composto de varios outros objetos, o1 eh elegivel ao GC, mas os objetos que ele referencia e sao referenciados por outros objetos nao serao deletados.
Ou seja, se o1 tem referencia para um o2 que eh referenciado em outro objeto, tudo de o1 eh deletado, menos o2.
acho q eh isso
escrever sem acento eh horrivel
Hum, então, se funcionar assim, o GC é um mais inteligente do que eu pensava. Pelo que eu saiba(?), quando um objeto(o1) encapsula outro(02), o2 fica dentro(literalmente) de o1, certo?! Se for assim, alguem poderia me explicar, caso a explicação do baiano_mg esteja certa, como ele “desencapsula” o2?
Até.
É que ele não fica dentro literalmente, isso só acontece com tipos primários (int, double, char …). Com objetos só fica encapsulada a referência ao objeto. 
Ah… esclareceu a minha duvida então. 
Obrigado…
Até mais.