SumárioApresentação ................................................................................. xiPrefácio ........................................................................................xiiiAgradecimentos .......................................................................... xvii1 Introdução ............................................................................12 Criar e Destruir Objetos ....................................................5Item 1: Considere os métodos static factory em vez dos construtores .............. 5Item 2: Cogite o uso de um builder quando se deparar com muitosparâmetros no construtor ..................................................................... 10Item 3: Implemente a propriedade de um singleton com um construtorprivado ou um tipo enum ......................................................................18Item 4: Implemente a não instanciação através de construtores privados ...... 20Item 5: Dê preferência à injeção de dependência para integrar recursos ........ 21Item 6: Evite a criação de objetos desnecessários ........................................... 24Item 7: Elimine referências obsoletas de objetos ............................................. 28Item 8: Evite o uso dos finalizadores e dos cleaners ........................................31Item 9: Prefira o uso do try-with-resources ao try-finally .......................... 373 Métodos Comuns para Todos os Objetos .........................41Item 10: Obedeça ao contrato geral ao sobrescrever o equals .........................41Item 11: Sobrescreva sempre o método hashCode ao sobrescrevero método equals ................................................................................. 54Item 12: Sobrescreva sempre o toString ........................................................ 60Item 13: Sobrescreva o clone de modo sensato ............................................... 63Item 14: Pense na possibilidade de implementar a Comparable ...................... 724 Classes e Interfaces ............................................................79Item 15: Reduza ao mínimo a acessibilidade das classes e deseus membros ..................................................................................... 79viii JAVA EFETIVOItem 16: Use os métodos getters em classes públicas e não oscampos públicos ................................................................................. 84Item 17: Reduza a mutabilidade das classes ao mínimo ................................. 86Item 18: Prefira a composição à herança ......................................................... 94Item 19: Projete e documente as classes para a herança ou a iniba ............... 100Item 20: Prefira as interfaces em vez das classes abstratas .......................... 106Item 21: Projete as interfaces para a posteridade ...........................................112Item 22: Use as interfaces somente para definir tipos ...................................114Item 23: Dê preferência às hierarquias de classes em vez dasclasses tagged ...................................................................................116Item 24: Prefira as classes membro estáticas às não estáticas .......................119Item 25: Limite os arquivos fonte a uma única classe de nível superior ....... 1235 Genéricos ..........................................................................125Item 26: Não use tipos brutos ........................................................................ 125Item 27: Elimine as advertências não verificadas ..........................................131Item 28: Prefira as listas aos arrays ............................................................... 134Item 29: Priorize os tipos genéricos ...............................................................138Item 30: Priorize os métodos genéricos ..........................................................143Item 31: Use os wildcards limitados para aumentar a flexibilidadeda API ...............................................................................................147Item 32: Seja criterioso ao combinar os genéricos com os varargs ............... 154Item 33: Pense na possibilidade de usar contêineresheterogêneos typesafe .......................................................................1606 Enums e Anotações ..........................................................167Item 34: Use enums em vez de constantes int ...............................................167Item 35: Use os campos de instância em vez dos valores ordinais ................178Item 36: Use a classe EnumSet em vez dos campos de bits ............................179Item 37: Use EnumMap em vez da indexação ordinal ......................................181Item 38: Emule enums extensíveis por meio de interfaces .............................186Item 39: Prefira as anotações aos padrões de nomenclatura ......................... 190Item 40: Use a anotação Override com frequência ....................................... 199Item 41: Use as interfaces marcadoras para definir tipos ............................. 2017 Lambdas e Streams ..........................................................205Item 42: Prefira os lambdas às classes anônimas .......................................... 205Item 43: Dê preferência às referências para métodos em vezdos lambdas ..................................................................................... 209Item 44: Prefira o uso das interfaces funcionais padrão ................................211Item 45: Seja criterioso ao utilizar as streams ................................................216Item 46: Dê preferência às funções sem efeitos colaterais nas streams ........ 224Item 47: Dê preferência à Collection como um tipo de retorno em vezda Stream ......................................................................................... 230Item 48: Tenha cuidado ao fazer streams paralelas ....................................... 2368 Métodos .............................................................................241Item 49: Verifique a validade dos parâmetros ................................................241Item 50: Faça cópias defensivas quando necessário ...................................... 245Item 51: Projete as assinaturas de método com cuidado ............................... 249Item 52: Utilize a sobrecarga com critério .................................................... 252Item 53: Use os varargs com sabedoria ......................................................... 259Item 54: Retorne coleções ou arrays vazios, em vez de nulos ...................... 262Item 55: Seja criterioso ao retornar opcionais ............................................... 264Item 56: Escreva comentários de documentação para todos oselementos da API exposta ............................................................... 2699 Programação Geral ..........................................................279Item 57: Minimize o escopo das variáveis locais .......................................... 279Item 58: Dê preferência aos loops for-each em vez dostradicionais loops for ...................................................................... 282Item 59: Conheça e utilize as bibliotecas ...................................................... 285Item 60: Evite o float e o double caso sejam necessáriasrespostas exatas ............................................................................... 289Item 61: Dê preferência aos tipos primitivos em vez dos tiposprimitivos empacotados ....................................................................291Item 62: Evite as strings onde outros tipos forem mais adequados .............. 295Item 63: Cuidado com o desempenho da concatenação de strings ............... 298Item 64: Referencie os objetos através das interfaces deles .......................... 299Item 65: Dê preferência às interfaces em vez da reflexão ..............................301Item 66: Utilize os métodos nativos com sabedoria ...................................... 305Item 67: Seja criterioso ao otimizar ............................................................... 306Item 68: Adote as convenções de nomenclatura geralmente aceitas ..............31010 Exceções ............................................................................315Item 69: Utilize as exceções somente em circunstâncias excepcionais .........315Item 70: Utilize as exceções verificadas para condições recuperáveise exceções de runtime para erros de programação ..........................318Item 71: Evite o uso desnecessário das exceções verificadas ....................... 320Item 72: Priorize o uso das exceções padrões ............................................... 323Item 73: Lance exceções adequadas para a abstração ................................... 325Item 74: Documente todas as exceções lançadas por cada método ................. 327Item 75: Inclua as informações a respeito das capturas de falhasnos detalhes da mensagem ............................................................... 329Item 76: Empenhe-se para obter a atomicidade de falha ................................331Item 77: Não ignore as exceções .....................................................................33311 Concorrência ....................................................................335Item 78: Sincronize o acesso aos dados mutáveis compartilhados ......................335Item 79: Evite a sincronização excessiva ....................................................... 340Item 80: Dê preferência aos executores, às tarefas e às streams emvez das threads ................................................................................ 347Item 81: Prefira os utilitários de concorrência ao wait e ao notify ............. 349Item 82: Documente a thread safety ...............................................................355Item 83: Utilize a inicialização preguiçosa com parcimônia .........................358Item 84: Não dependa do agendador de threads .............................................36112 Serialização .......................................................................365Item 85: Prefira alternativas à serialização Java ........................................... 365Item 86: Tenha cautela ao implementar a Serializable ............................... 369Item 87: Pense na possibilidade de usar uma forma serializadacustomizada ..................................................................................... 373Item 88: Escreva métodos readObject defensivamente ................................ 380Item 89: Dê preferência aos tipos enum em vez do readResolvepara controle de instância ................................................................ 385Item 90: Pense em usar proxies de serialização em vez deinstâncias serializadas ..................................................................... 39013 Itens Correspondentes aos Itens da Segunda Edição ....39514 Referências ........................................................................39915 Índice .................................................................................405