JDK1.8.0_144 Download Endereço: //www.vevb.com/softs/551512.html
AbstractMap Abstract Class implementa alguns métodos simples e gerais, que não são difíceis em si. Mas existem dois métodos nesta classe abstrata que vale a pena prestar atenção. Pode-se dizer que a implementação do código-fonte do método de tecla e valores é modelos de estilo de livro didático.
As classes abstratas são geralmente implementadas como um esqueleto para implementar métodos comuns para suas respectivas subclasses. No artigo anterior, explicamos a interface do mapa, e este artigo analisa e estuda a classe abstrata abstrata.
Existem muitas estruturas de dados do tipo de mapa em Java. A AbstractMap, como implementação do esqueleto, implementa alguns métodos da interface do mapa, ou seja, fornece métodos públicos para suas subclasses, e vários mapas sem implementação podem ser diferentes.
Uma classe abstrata não pode criar diretamente instâncias de classes abstratas através da nova palavra -chave, mas pode ter construtores. O AbstractMap fornece um construtor sem parâmetros modificado protegido, o que significa que apenas sua subclasse pode acessar (é claro que é uma classe abstrata, e outras classes não podem ser instantadas diretamente), ou seja, apenas sua subclasse pode chamar esse construtor sem parâmetros.
Uma interface de entrada é definida internamente na interface do mapa. Essa interface é uma implementação interna do mapa do mapa para manter um par de valor-chave-chave, e o valor-chave é armazenado neste mapa.entry. AbstractMap implementa essa interface interna, há dois no total: um é o SimpleEntry mutável e o outro é a imutável e simples e imutável.
Classe estática pública Simpleentry <k, v> implementa a entrada <k, v>, java.io.serializable
A interface map.entry <k, v> é implementada e serializável (pode ser serializada).
Seu método é relativamente simples, todas operações de assumir valores e armazenar valores. A definição de valor -chave é uma modificação final, o que significa que é uma referência imutável. Além disso, seu método setValue é um pouco especial. O valor armazenado não é o valor armazenado, mas o valor antigo retornado. O que você precisa aprender são os métodos iguais e hashcode que ele reescreve.
public boolean é igual (objeto o) {if (! (o instanceof map.entry)) // para determinar se os parâmetros são do tipo map.entry, se for igual, a primeira coisa a fazer é ser o mesmo tipo retorno false; Map.entry <? ,?> e = (map.entry <? ,?>) o; // forçando o tipo de objeto a mapear.Entry Type, o parâmetro usa "?" Em vez de "K, V", porque o tipo de genérico será apagado em tempo de execução. O compilador não sabe que tipo K e V é, retornar eq (key, e.getKey ()) && eq (value, e.getValue ()); // chave e valor chamam o método EQ para julgamento, respectivamente, e iguais são iguais quando ambos retornam. } private estático booleano Eq (objeto O1, objeto O2) {return o1 == null? O2 == NULL: O1.Equals (O2); // Este operador de três itens também é muito simples, mas deve-se notar que, embora O1 e O2 sejam tipos de objetos aqui, o método igual do tipo de objeto é referenciado por "==", então não pense que existe um problema aqui, porque, na realidade, o tipo O1 pode ser o método de sequência. }Para reescrever corretamente o método igual e ser usado corretamente, você geralmente precisa reescrever o método HashCode.
public int hashCode () {return (key == null? 0: key.hashcode ()) ^ (value == null? 0: value.hashcode ()); // Quando os valores de chave e valor não forem nulos, o código de hash será xored. }Classe estática pública SimpimutableEntry <k, v> implementa a entrada <k, v>, java.io.Serializable SimpleMutableEntry
A entrada definida como imutável é realmente imutável porque não fornece o método do SetValue e, naturalmente, não pode ser modificado através do método setValue quando vários threads são acessados simultaneamente. Comparados ao SimpleEntry, suas variáveis de chave e membro do valor são definidas como tipos finais. Chamar o método setValue lançará uma exceção de UnsupportEdOperationException.
Seus métodos iguais e hashcode são consistentes com o SimpleEntry.
Em seguida, verifique quais métodos na interface do mapa são implementados pela Classe Abstract Abstract.
Public int size ()
Um método de entrada de entrada é definido no mapa, que retorna a coleção de conjuntos de mapa.entry. O método de tamanho da coleção de conjuntos é chamado diretamente, que é o tamanho do mapa.
público booleano isempty ()
Chame o método de tamanho acima, igual a 0, está vazio.
Public Boolean ContansKey (chave do objeto)
A implementação deste método é relativamente simples. Ao chamar o método de entrada de entrada, o iterador da coleção de conjuntos é obtido e atravessado com a chave do parâmetro. O mapa pode ser armazenado como o valor chave da NULL. Como Key = NULL é armazenado no mapa com armazenamento especial especial (o valor do HashCode não pode ser calculado), também fizemos uma maneira de determinar se a chave do parâmetro está vazia.
Public boolean containsvalue (valor do objeto)
Esta implementação do método é consistente com o ContainsKey.
public V Get (chave do objeto)
Essa implementação do método é semelhante aos dois acima, a diferença é que o acima é igual ao booleano e esse método retorna o valor.
public V put (K -Key, V Valor)
O método de armazenar pares de valor-chave no mapa não é implementado em detalhes, e uma UNSupportEdOperationException será lançada diretamente.
public V Remover (chave do objeto)
Exclua o par de valores-chave-chave especificado no mapa através da tecla de parâmetro. Este método também é muito simples. Ele também atravessa a coleção de mapa.
public void Putall (mapa <? Extende k ,? estende v> m)
Este método também é muito simples de atravessar o mapa de entrada e apenas chamar o método PUT para salvá -lo.
public void Clear ()
Ligue para o método do conjunto de entrada para obter a coleção Set e ligue para o método Set#clear () para limpá -lo.
Conjunto público <K> KeySet ()
Retorna a coleção de conjuntos de valores de chave do mapa. AbstractMap define uma variável de membro "Conjunto transitório <K> Keyset". No JDK7, a variável de tecla é modificada por volátil, mas no JDK8, ela não é modificada por volátil. É explicado nos comentários sobre a variável de tecla que o método para acessar esses campos não é sincronizado por si só, e o volátil não pode garantir a segurança do encadeamento. A implementação do método Keyset é interessante.
Primeiro de tudo, pense nesse método é retornar o conjunto de valores -chave. Naturalmente, podemos pensar em um simples método de implementação, atravessar a matriz de entrada e retirar o valor da chave e colocá -lo no conjunto, semelhante ao código a seguir:
public Set <K> KeySet () {set <k> ks = null; para (map.entry <k, v> entrada: entrada ()) {ks.add (entrada.getKey ()); } retornar ks;}Isso significa que toda vez que o método do chavet é chamado, ele atravessará a matriz de entrada e a eficiência será bastante reduzida quando o volume de dados for grande. Devo dizer que o código -fonte do JDK está muito bem escrito e não adota o método de Traversal. Se você não atravessa a entrada, como você sabe que o mapa adicionou um par de valor-chave-chave no momento?
A resposta é reimplementar uma nova coleção de conjuntos personalizados dentro do método de tecla, e o método do iterador é reescrito nesta coleção de conjuntos personalizados. Aqui está a chave. O método do iterador retorna a interface do iterador e aqui é reimplementado. Chamando o método do conjunto de entrada e depois chamando seu método iterador. O seguinte é analisado em combinação com o código:
public Set <K> KeySet () {set <k> ks = keyset; // Definido conjunto transitório <k> tecla if (ks == null) {// A primeira chamada é definitivamente nula, crie um exemplo de conjunto através do seguinte código ks = new AbstractSet <K> () {// Crie um conjunto de iteração do ITerator <k> Iterator () {// rewrite the itertator Method of the Set Returator de Returador Iterator <entrada <k, v >> i = entrada (). ITERator (); // Crie um iterador de coleção de conjuntos ITERATOR Public boolean hasNext () {return i.hasnext (); // O julgamento do valor -chave é o julgamento da entrada} public k a próxima () {return i.next (). GetKey (); // O próximo valor de chave é obter a entrada#getKey} public void remover () {i.Remove (); // exclua o valor da chave, exclua a entrada}}; } public int size () {// O método de tamanho do conjunto reescrito retorna abstrataMap.this.size (); // O valor da chave é o tamanho do mapa inteiro, então chame o método de tamanho desta classe. Esta é uma classe interna. Use essa palavra -chave para representar esta classe diretamente. Deve indicar que o método de tamanho no abstrataMap é chamado. Sem isso, significa que é um método estático estático} public boolean isEmpty () {// O conjunto de conjunto reescrito#isEmpty Method retorna abstrataMap.This.isEmpty (); // Para se existe um valor -chave, significa se o mapa está vazio, por isso é apenas para chamar o método isEmpty desta classe} public void clear () {// O conjunto reescrito#Clear Method MethodMap.This.Clear (); // Limpe o valor da chave, é apenas para limpar o mapa, por isso é apenas para chamar o método claro desta classe} public boolean contém (objeto k) {// Rewrite Set#contém o método retornar abstractmap.this.containsKey (k); // julga se o conjunto contém dados k, o que significa se o mapa contém o valor da chave, portanto, basta chamar o método containsky dessa classe}}; chaves = ks; // Atribua esta coleção de conjuntos personalizados ao teclado variável. Ao ligar para o método Keyset novamente no futuro, porque o teclado não é nulo, você só precisa retornar diretamente. } retorna ks;Eu acho que essa é uma implementação muito inteligente. Embora esse método gire em torno do valor da chave, ele pode ser implementado em combinação com a entrada sem atravessar a entrada. Ao mesmo tempo, é mencionado acima que chama o método de iterador de entrada de entrada, que é a melhor prática do modo de método de modelo. Como o InscurtSet não é implementado no AbstractMap, mas é deixado para a sua subclasse para concluir, mas o método do teclado pode ser implementado com um "esqueleto de algoritmo", que é o padrão do método do modelo.
Coleção pública <V> valores ()
Para o método dos valores, você pode consultar completamente o teclado. Os dois têm o mesmo efeito, então não o repetirei aqui para economizar espaço.
Conjunto de resumo público <Entrada <K, V >> Entryset ()
Um método abstrato é entregue à sua subclasse para concluir, indicando que esse método não é particularmente "geral".
BOOLEAN Public Iguals (objeto O)
O mapa estipula que somente quando a chave e o valor de cada par de valores-chave no mapa correspondem a um por um retornará true. No método, primeiro julgue as condições simples. Se as referências forem iguais, retorne diretamente diretamente. Se o parâmetro O não for o tipo de mapa, retorne false diretamente. Se o número de dois mapa for diferente, retorne false diretamente. Somente então iterará sobre a matriz de entrada e comparará se a chave e o valor na entrada correspondem a um por um. O método é simples, mas isso nos dá uma inspiração. No julgamento condicional, devemos primeiro julgar os básicos simples e depois julgar os complexos.
public int hashcode ()
Reescreva o método igual da classe de objeto e reescreva o HashCode também é necessário. A implementação do HashCode pelo AbstractMap é adicionar os valores de hashcode de todos os map.entry (aqui está simples ou simples imutável) até o final, e a soma final é usada como o valor de hashcode do mapa.
public string tostring ()
Não há nada a dizer sobre esse método, é para retirar todos os pares de valor-chave e usar o StringBuilder para constatá-los.
Objeto protegido clone () lança clonenotsupportedException
Implemente uma cópia superficial, porque é uma cópia superficial do teclado e valores variáveis, impedindo os problemas causados pelas duas cópias rasas.