Pontos de conhecimento básico de Java (classes comuns, coleções)

1. Classes comumente usadas

1. Comparador

Comparador e comparação comparável:
1. Comparável é uma interface de classificação; se uma classe implementa a interface Comparável, significa "a classe suporta classificação".
(Atua na classe de entidade)

2. Comparador é um comparador; se precisarmos controlar a ordem de uma determinada classe, podemos criar um "comparador desta classe" para classificar.
(Atua na classe de classificação)

Resumo: Comparável é equivalente a "comparador interno" e Comparador é equivalente a "comparador externo".

2. Classe interna

1. O membro da classe interna é
definido na classe e serve como um membro da classe.
Autoridade de acesso: A classe interna pode acessar as propriedades e métodos da classe externa.Se a classe externa deseja acessar os membros da classe interna, ela deve primeiro criar um objeto da classe interna para acessá-lo.
Crie um objeto: new Outer (). New Inner ()

2. A classe interna local é
definida no método e serve como uma variável do método.Nota: A classe interna local é como uma variável local no método.Ela não pode ter modificadores públicos, protegidos, privados e estáticos.

3. Classe interna
anônima Uma classe interna anônima é geralmente usada como um método para passar parâmetros.É usada para herdar classes abstratas ou implementar interfaces, em vez de subclasses ou classes de implementação, e não requer a definição de métodos adicionais. Jdk8 pode usar expressões Lambda para simplificar.

4. Classe interna
estática Uma classe interna estática pode ser entendida como um membro estático da classe.
A classe interna estática não precisa depender do objeto da classe externa, você pode criar seu próprio objeto diretamente.
Não é possível acessar as propriedades ou métodos do membro não estático da classe externa. Como a classe interna estática não depende do objeto externo, você mesmo pode criar o objeto. Portanto, se não houver nenhum objeto externo, você pode chamar o objeto externo membro da instância, o que cria uma contradição, porque o membro da instância externa deve haver objetos externos.

3. Embalagem

O conceito de classes de empacotamento:
Como os tipos de dados básicos não têm o conceito de classes e objetos, a filosofia de design do Java é que tudo é um objeto.
Portanto, uma classe própria é adaptada especificamente para cada tipo de dados básico, chamada de classe de empacotamento.

2. A aplicação da classe de embalagem.
Uma vez que os tipos de dados básicos não podem ser armazenados na coleção, o list.add (6) que vimos; na verdade, os tipos de armazenamento são todos os tipos de embalagem. O processo de atualização dos tipos de dados básicos para as classes de empacotamento é chamado de "boxing", o oposto é chamado de "unboxing";
1. Os tipos de dados básicos de classe de empacotamento-unboxing são executados automaticamente
2. Up
-casting-down-casting classe pai-filho 3. Tipo coercivo conversão-conversão automática byte-short-int-long float-double

3. O método de construção da
classe de empacotamento 1. Todas as classes de empacotamento podem usar os tipos de dados básicos correspondentes como parâmetros para construir suas instâncias

2. Além da classe Character, outras classes de empacotamento podem usar uma string como parâmetro para construir sua instância

Nota
1. Quando o parâmetro do método de construção da classe Booleana é do tipo String, se o conteúdo da string for verdadeiro (independentemente do caso), o objeto Booleano representa verdadeiro, caso contrário, representa falso

2. Quando o parâmetro do método de construção da classe de empacotamento Number (exceto Character e Boolean outras classes de empacotamento) é do tipo String, a string não pode ser nula e a string deve ser analisável nos dados do tipo de dados básico correspondente, caso contrário, a compilação não será passar, NumberFormatException será lançada no tempo de execução

Resumo:
1. Os métodos de construção de classes de empacotamento geralmente têm sobrecargas.O parâmetro de um método de construção é o tipo de dados básico correspondente, e o parâmetro do outro método de construção é o tipo de string.

4. Métodos comumente usados ​​de classes de empacotamento
1.XXXValue (): as classes de empacotamento são convertidas em tipos básicos (métodos de instância)
byteValue (), intValue (), longValue (), shortValue (), doubleValue (), floatValue ()
charValue ( ), booleanValue ()

2.toString (): retorna os dados de tipo básico representados pelo objeto de pacote na forma de uma string (tipo básico -> string)
(método estático)
3. parseXXX (): converte a string para os dados de tipo de dados básicos correspondentes ( exceto para Character) (String -> tipo básico) (método estático)

4. valueOf () (método estático)
(1) Todas as classes de empacotamento têm os seguintes métodos (tipo básico -> classe de empacotamento)
public static Type valueOf (type value)
(2) Exceto para a classe Character, outras classes de empacotamento têm o seguinte métodos (
String- > classe de embalagem) public static Type valueOf (String s)

4. Métodos comumente usados ​​de string:

1. Comprimento do comprimento ();

2. Splicing str.concat (str2);

3. Formato:
// Método 1
System.out.printf ("Olá a todos, meu nome é% s, eu sou este ano:% d anos, meu depósito é:% f% n", "Cao Cao", 36.999,99 );

// Método dois
String s = String.format ("Olá a todos, meu nome é% s, eu sou este ano:% d anos, meu depósito é:% f", "Cao Cao", 36.999,99);
System.out .println (s);

4.charAt (índice) retorna o caractere no índice especificado

5.indexOf (str) retorna o índice da primeira ocorrência da string especificada nesta string

6.compareTo (str2) compara duas strings

7.equals () 和 equalsIgnoreCase ()

8.getBytes () usa o conjunto de caracteres padrão para transformar a string em uma matriz de bytes, que será usada no fluxo IO

9.toCharArray () Converte uma string em uma matriz de caracteres

10. Interceptação: subString ()

11. Converta para minúsculas emLowerCase () paraUpperCase ()

12. Corte em branco () antes e depois da interceptação

13. Substituir: substituir ()

14. Dividir: dividir ()

15. Correspondências regulares (String reg) retorna booleano

5. Regular

1. Conceito:
expressão regular, também conhecida como expressão regular. (Inglês: Expressão regular, geralmente abreviado como regex). Expressões regulares são geralmente usadas para recuperar e substituir texto que atenda a um determinado padrão (regra). Suporta expressões regulares: PHP, Java, Python, JavaScript, etc. Com expressões regulares, escrever código é mais conciso, geralmente duas ou três linhas de código podem atingir o objetivo.

2. Regras:

1. Qualquer caractere significa corresponder a qualquer caractere correspondente, como a corresponde a a, 7 corresponde a 7 e -matches.

2. [] significa corresponder a qualquer um dos caracteres entre colchetes, como [abc] corresponder a a ou b ou c.

3. -O significado dentro e fora dos colchetes é diferente. Por exemplo, quando está fora, vai corresponder -, se dentro dos colchetes [ab] significa combinar qualquer uma das 26 letras minúsculas; [a-zA-Z] corresponde a um total de 52 letras maiúsculas e minúsculas Qualquer uma das letras; [0-9] corresponde a qualquer um dos dez dígitos.

4. ^{O significado dentro e fora dos colchetes é diferente. Se estiver fora, significa o início. Por exemplo,} 7 [0-9] significa que a correspondência começa com 7 e o segundo dígito é uma string de qualquer número; se está entre colchetes, significa Qualquer caractere diferente desse caractere (incluindo números, caracteres especiais), como [^ abc] significa corresponder a qualquer caractere diferente de abc.

5. . Significa combinar qualquer personagem.

6. \ d significa número.

7. \ D significa não um número.

8. \ w representa letras, números e sublinhados, [a-zA-Z0-9_].

9. \ W significa que não é composto de letras, números e sublinhados.

10. [\ u4e00- \ u9fa5] corresponde a caracteres chineses

11. ?: Indica 0 ou 1 ocorrência.

12. + Significa uma ou mais ocorrências.

13. * Significa 0, 1 ou mais ocorrências.

14. {n} significa n ocorrências.

15. {n, m} significa n ~ m ocorrências.

16. {n,} significa que aparece n vezes ou mais.

3. Uso:
// O caractere a ser correspondido
String str = "8";
// Expressão regular
String regex = "[0-9]";
//
Padrão p = Pattern.compile (regex);
Matcher m = p. matcher (str);
System.out.println (m.matches ());
// Método dois
System.out.println (Pattern.matches (regex, str));
// Método três
System.out.println (str. correspondências (regex));

Extensão: Afirmar, prever, excluir
// Um ​​determinado site exige apenas o registro da conta: letras e números, não as duas letras, nem os dois números, e exige o início da letra, o comprimento é entre 6-12,
estático público void main (String [] args) { Scanner sc = new Scanner (System.in); // Assertion, prediction (?! Regular) Excluir String correspondente regular s = ""; while (! s.matches (" ¹ (?) ! [a-zA-Z] {5,11} $) [a-zA-Z0-9] {5,11} ")) { System.out.println (" Digite o número da conta registrada: "); s = sc.next (); } System.out.println ("Registrado com sucesso!"); }

6.StringBuffer 和 StringBuild

1. Diferença:
StringBuffer é mais seguro e
StringBuilder é mais rápido

Diagrama de estrutura de herança:

2. O mesmo
uso de StringBuffer e StringBuilder é o mesmo

3. Métodos comuns
// 1.
append ()

// 2. Insira
insert ()

// 3. Inverter
reverso ()

7. Matemática e Aleatório

1. Métodos comuns de matemática
: arredondar para cima / para baixo, arredondar teto () chão () redondo ()

Valor absoluto abs ()

Número aleatório aleatório () Faixa: [0,1) decimal

Pow da função de potência (a, b)

sqrt () raiz quadrada

2. Métodos comuns aleatórios

8. Aula de data

1. Data

1. Criar um objeto Date da hora atual
// Cria um objeto Date representando a data atual do sistema
Date d = new Date ();

2. Crie um objeto Date da hora que especificamos:
Use o método de construção parametrizado Date (int ano, int mês, int dia) para construir o objeto da classe Date da data especificada. O parâmetro year na classe Date deve ser o real necessidade de representar 1900 é subtraído do ano e o valor após 1 é subtraído do mês real que precisa ser representado.

// Cria um objeto Date representando 12 de junho de 2014
Date d1 = new Date (2014-1900, 6-1, 12); (observe as configurações de parâmetro)

3. Obtenha as informações contidas em um objeto de data corretamente, como:
Date d2 = new Date (2014-1900, 6-1, 12);
// Obtenha o ano (observe que o ano deve ser adicionado a 1900, para que é o objeto de data d2 Representado ano)
int ano = d2.getYear () + 1900;
// Obtenha o mês (observe que o mês deve ser adicionado por 1, de modo que seja o mês representado pelo objeto de data d2)
int month = d2.getMonth () + 1;
// Obter a data
int date = d2.getDate ();
// obter a hora
int hour = d2.getHours (); // não definir o padrão como 0
// obter o minuto
int minuto = d2.getMinutes ();
// obter o segundo
int segundo = d2.getSeconds ();
// Obter o dia da semana
int day = d2.getDay ();
Nenhum dado no método de construção será o padrão para a hora atual.

2. Calendário

1. A função da classe Calendar é muito mais forte do que a da classe Date, levando em consideração questões como fuso horário.

2. A classe Calendar é uma classe abstrata que fornece o método getInstance para criar objetos.

// 1. Crie um objeto Calendar representando a data atual do sistema
Calendar c = Calendar.getInstance (); // O padrão é a data atual

// 2. Criar um objeto
Calendar Calendar c1 = Calendar.getInstance ();
c1.set (2014, 5-1, 9);

// 3. Crie um objeto Calendar com uma data especificada - Método two
c1.set (Calendar.DATE, 10);
c1.set (Calendar.YEAR, 2015);

// 4. Obtenha o tempo

// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;（MONTH+1）
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几
int day = c1.get(Calendar.DAY_OF_WEEK);

// 5. Associado à data

setTime (nova data ())

3.SimpleDateFormat

// 1. Crie um objeto de formatação
SimpleDateFormat f = new SimpleDateFormat ("aaaa-MM-dd HH: mm: ss");

// 2. Chame o formato ou método de análise para converter entre String e Data

9. Números

1.BigDecimal

Métodos comuns:

//
Adicione os valores no objeto BigDecimal e retorne o objeto BigDecimal add (BigDecimal)

// Subtrai o valor do objeto BigDecimal e retorna o objeto BigDecimal
subtrai (BigDecimal)

// Multiplique os valores no objeto BigDecimal e retorne o objeto BigDecimal
multiplique (BigDecimal)

// Divide o valor no objeto BigDecimal e retorna a
divisão do objeto BigDecimal (BigDecimal)

BigDecimal b1 = novo BigDecimal (“0,03”);
BigDecimal b2 = novo BigDecimal (“0,02”);
System.out.println (b1.subtract (b2));

// Compare o resultado de saída
BigDecimal b1 = new BigDecimal (0,03);
BigDecimal b2 = new BigDecimal (0,02);
System.out.println (b1.subtract (b2));

2. BigInteger
Se a operação de um inteiro excedeu o intervalo de long, BigInteger pode ser usado neste momento. Visto que não é um tipo de dados básico, ± * / não pode ser usado e o método de operação é o mesmo acima.

long l = 999999999999999999l;

BigInteger in1 = novo
BigInteger (“99999999999999999999999999999999999999999999999999”);

BigInteger in2 = novo
BigInteger (“99999999999999999999999999999999999999999999999998”);

System.out.println (in1.subtract (in2));

Conversão entre decimal e binário

BigInteger in = new BigInteger (“10001110”, 2);

System.out.println (in.intValue ()); // Binário é convertido em decimal

System.out.println (in.toString (2)); // Conversão decimal para

System.out.println (in.toString (3));

3. DecimalFormat
double pi = 3.1415927; // Pi
// Pega um inteiro
System.out.println (new DecimalFormat ("0"). Format (pi)); // 3

// Pega um inteiro e dois decimais
System.out.println (new DecimalFormat ("0,00"). Format (pi)); // 3,14

// Pegue dois inteiros e três casas decimais, e a parte insuficiente do inteiro é preenchida com 0.
System.out.println (new DecimalFormat ("00.000"). Format (pi)); // 03.142

// Pega todas as partes inteiras
System.out.println (new DecimalFormat ("#"). Format (pi)); // 3

// Conta em porcentagem e leva duas casas decimais
System.out.println (new DecimalFormat ("#. ##%"). Format (pi)); // 314,16%

long c = 299792458; // velocidade da luz

// Exibe em notação científica e
usa cinco casas decimais System.out.println (new DecimalFormat ("#. ##### E0"). Format ©); // 2.99792E8

// Exibe como uma notação científica de número inteiro de dois dígitos e
usa quatro casas decimais System.out.println (new DecimalFormat ("00. #### E0"). Format ©); // 29.9792E7

// Cada três dígitos são separados por vírgulas.
System.out.println (new DecimalFormat (", ###"). Format ©); // 299.792.458

// Incorpore o formato ao texto
System.out.println (new DecimalFormat ("A velocidade da luz é por segundo, ### metros."). Format ©);

Em segundo lugar, a estrutura de coleta

1. Recipiente:

variável

Recursos da matriz: tipo fixo, comprimento fixo

As características da classe: diferentes tipos de atributos de membro, que juntos descrevem uma classe de entidade

Características da coleção: o tipo não é fixo, o comprimento não é fixo e todos os dados são armazenados à vontade

2. Reconhecer a estrutura de herança da estrutura de coleção:

3.ArrayList

A coleção não tem comprimento fixo:

Método comum

4.LinkedList

O princípio de armazenamento é uma lista encadeada. Há um pré-nó e um pós-nó antes e depois dos elementos, que são usados ​​para conectar o elemento anterior e o próximo elemento no conjunto, e então "lado a lado" para formar um conjunto de dados em cadeia.

Método único

5. Comparação de duas coleções de listas

1. A interface List armazena um conjunto de objetos que não são únicos (podem ser repetidos) e ordenados (pedido de inserção)

2. ArrayList implementa uma matriz de tipo de objeto de comprimento variável, aloca espaço contínuo na memória e atravessa elementos e acessa elementos aleatoriamente com mais eficiência

3. LinkedList adota o método de armazenamento de lista vinculada, que é mais eficiente ao inserir e excluir elementos

4. Compare a diferença entre as duas estruturas visualizando o código-fonte do método de adição. Armazenamento em cadeia e armazenamento em array

A razão para a eficiência diferente:
Linkedlist afetará apenas os dois elementos adjacentes ao excluir e adicionar operações.

Como Arraylist é uma matriz por natureza, os valores de endereço de todos os elementos subsequentes serão alterados ao executar as operações de exclusão e adição.

6. Definir coleção

1. Recursos de interface Se:

Armazene um conjunto de objetos exclusivos (elementos duplicados não são permitidos), não ordenados (sem índice de índice), HashSet é uma classe de implementação comumente usada da interface Set.

2. Manipular os dados da coleção Set

(1) Novos elementos

(2) Excluir elementos

3. Percorra a coleção Set
1. Aprimore o for
2. Iterator (corrigido com o loop while)

7. Coleção de mapas

1. A interface Map é especializada no processamento de dados de mapeamento de valor-chave e pode realizar a operação do valor de acordo com a chave

2. Crie um objeto HashMap que é comumente usado para implementar a interface do Mapa e armazená-lo nos dados

3. Exclua os dados

4. Modifique os dados

5. Percorra os dados da coleção de mapas:

1. Percorrer todas as chaves
2. Percorrer todos os valores
3. Percorrer todos os pares de valores-chave

Resumo dos métodos comumente usados:

Resumindo

Acima estão todos os pontos de conhecimento de classes e coleções comumente usadas, principalmente conceitos relacionados e métodos de uso de classes e coleções comumente usadas.

---

1. a-zA-Z ↩︎