índice
Introduzir
- Coleções e matrizes são estruturas que podem armazenar vários dados, chamados de contêineres Java para abreviar
- Recursos de dados de armazenamento em array:
- Uma vez que o array é inicializado, o comprimento do array é determinado
- Uma vez que a matriz é definida, o tipo de dados que pode armazenar os elementos é determinado
- Desvantagens de armazenar dados em matrizes:
- Comprimento imutável
- Os métodos fornecidos na matriz são limitados, o que é inconveniente para operações como adição e exclusão, e a eficiência não é alta
- É difícil obter o número de elementos válidos na matriz
- Incapaz de atender às necessidades desordenadas e não repetitivas
Um, estrutura de coleção Java
Interface de coleção: coleção de coluna única, armazenamento de objetos um por um
Interface de lista: dados ordenados e repetíveis (pode ser entendido como uma matriz dinâmica)
ArrayList 、 LinkedHashSet 、 Vector
Interface do conjunto: dados não ordenados e não repetíveis (podem ser entendidos como um conjunto na matemática do ensino médio)
HashSet 、 LinkedHashSet 、 TreeSet
Interface do mapa: coleta de duas colunas, armazenamento de um par de dados (valor-chave) (pode ser entendido como uma função)
HashMap 、 LinkedHashMap 、 TreeMap 、 HashTable 、 Propriedades
Dois, método de interface de coleta
Olhando para a interface Collection, podemos ver que existem 15 métodos abstratos para a classe de implementação implementar, 13 deles são explicados em detalhes abaixo
1 boolean add(E e) 向集合中添加元素，只能添加引用类型，不能添加基本类型
2 boolean addAll(Collection c) 将形参集合的元素添加到当前集合
3 void clear() 删除当前集合所有元素
4 boolean comtains(Object obj) 会调用obj对象所在类的equals方法，判断形参传入集合中的值是否在当前集合内
5 boolean contains(Collection coll) 判断形参coll的元素是否都在当前集合内
6 boolean equals(Object o) 判断当前集合和形参集合元素是否相等
7 int hashCode() 返回当前集合的hashCode值
8 boolean isEmpty() 判断当前集合是否为空
9 boolean remove(Object obj) 从当前集合删除obj元素
10 boolean removeAll(Collection coll) 从当前集合删除coll集合的所有元素
11 boolean retainAll(Collection coll) 求两个集合的交集，并返回给当前集合
12 int size() 返回当前集合的长度
13 Object[] toArray() 将当前集合转换为数组
Três, interface do iterador
O objeto Iterator é chamado de iterador, que é usado principalmente para percorrer os elementos na coleção da coleção e também pode excluir elementos da coleção enquanto atravessa
Iterator só se aplica à travessia de coleção
O objeto da coleção obterá um objeto iterador totalmente novo sempre que o método iterator () for chamado e o cursor padrão estiver antes do primeiro elemento da coleção
Collection coll = new ArrayList();
Iterator iterator = coll.iterator();
//遍历集合
while(iterator.hasNext()){
iterator.next();
}
hasNext() 判断是否还有下一个元素
next() 指针下移、下移后将集合位置上的元素返回
Quatro, subinterface de coleção 1: Lista
ListAs classes de implementação de interfaces comumente usadas são:ArrayListLinkedListVectorSemelhanças e diferenças:
Mesmo: todas as três classes implementam a interface List
ArrayList Como a principal classe de implementação de List, o thread não é seguro, eficiente e a camada inferior usa armazenamento Object [] LinkedList A camada inferior usa uma lista duplamente vinculada para armazenar, adicionar e excluir com frequência Vetor Como uma classe de implementação antiga de List, thread safety, baixa eficiência e armazenamento de Object [] na parte inferior
Métodos comuns da interface List
void add(int index,Object ele) 在index位置插入ele元素
boolean addAll(int index,Collection eles) 从index位置开始将eles中的所有元素添加进来
Object get(int index) 获取index位置的元素
int indexOf(Object obj) 返回obj第一次出现的索引
int lastIndexOf(Object obj) 返回obj在当前集合最后一次出现的索引
Object remove(int index) 移除index位置的元素，并返回该元素
Object set(int index,Object obj) 设置index位置的元素为obj
list subList(int fromIndex,int toIndex) 返回从fromIndex到toIndex的子集合
Percurso de lista (três maneiras)
ArrayList list = new ArrayList();
list.add(123);
list.add("asd");
//方式一：Iterator方式
Iterator iterator = list.iterator();
while(iterator.hasNext()){
iterator.next();
}
//方式二：增强for循环
for(Object obj : list){
System.out.println(obj);
}
//方式三：普通for循环
for(int i = 0; i < list.size ; i++){
System.out.println(list.get(i));
}
Análise do código-fonte ArrayList:
ArrayList arr = new ArrayList(); //底层创建长度为10的Object[]数组
arr.add(123); //elementDate[0] = 123
...
arr.add(11);
//如果此次添加元素导致底层elementDate数组容量不够，则扩容，默认情况下扩容为原来的1.5倍，同时将原数组的元素复制到新数组中
int newCapacity = oldCapacity + (oldCapacity >> 1);
elementData = Arrays.copyOf(elementData, newCapacity);
ArrayList arr = new ArrayList();//底层并没有创建长度为10的数组
arr.add(123); //第一次调用add方法时，才创建长度为10的数组
后续和7之前一样
总结：
7类似于饿汉式、8类似于懒汉式，节省内存
Cinco, subinterface de coleção 2: Definir
A interface Set é uma subinterface da interface Collection. Ela não fornece métodos adicionais . Todos os métodos declarados por Collection são usados.
As coleções de conjuntos não podem conter os mesmos elementos
1. Compreensão de Set
1.1 Desordem
Os elementos armazenados não são adicionados na ordem do índice da matriz na parte inferior, mas são determinados de acordo com o valor hash da matriz
1.2, não repetibilidade
1.3, o processo de adição de elementos ao conjunto
Etapa 1: adicione o elemento a ao hashSet. Primeiro chame o método hashCode da classe em que a está localizado para calcular o valor de hash e, em seguida, use esse valor de hash para calcular o valor do índice do elemento armazenado na matriz por meio de um determinado algoritmo .
Passo 2: Após obter o valor do índice, julgar se existe um elemento na posição, se não houver nenhum elemento nesta posição, a adição foi bem-sucedida
Se houver um elemento nesta posição, primeiro compare a e o valor hash do elemento nesta posição
Se o valor do hash for diferente, o elemento a é adicionado com sucesso
Etapa 3: se os valores de hash forem iguais, chame o método equals da classe onde a é e passe outros elementos para os parâmetros formais do método equals
Se o método retornar verdadeiro, o elemento a não foi adicionado
Se o método retornar falso, a adição foi bem-sucedida (armazenada em uma lista vinculada)
2 、 treeSet
1. Os elementos adicionados ao treeSet devem ser objetos da mesma classe (para que o tamanho possa ser comparado)
Dois, dois métodos de classificação
Classificação natural (implementar interface comparável)
O critério para comparar dois objetos com o mesmo não é mais igual, mas o método compareTo retorna 0
Classificação personalizada
O critério para comparar se dois objetos são iguais não é igual, mas
Seis, interface do mapa
1. Estrutura do quadro da interface do mapa
| ------ Mapa: Armazene os dados dos pares de valores-chave
| ------ HashMap: Como a principal classe de implementação do Map; thread não é seguro; alta eficiência
| ------ LinkedHashMap
| ------ TreeMap: pode ser classificado (classificado por chave)
| ------ Hashtable: como uma classe de implementação antiga de Map; thread-safe; baixa eficiência
| ------ Propriedades: comumente usados para processar arquivos de configuração; pares de valores-chave são todos tipos de String
O princípio de implementação subjacente do HashMap?
2. Compreensão do valor-chave
① Chave no mapa: não ordenado, não repetível (armazenado com conjunto) A classe onde está localizada deve substituir o método equals e o método hashCode (para HashMap)
② Valor no mapa: não ordenado, repetível (armazenado na coleção) O método equals da classe deve ser reescrito (para HashMap)
③ Um par de valor-chave constitui um objeto de entrada (armazenado com conjunto)
O par de valor-chave colocado em put é realmente armazenado no objeto Entry. A entrada tem dois atributos, chave e valor
A entrada está desordenada e não pode ser repetida
3. O princípio de implementação subjacente do HashMap
以JDK7说明
HashMap map = new HashMap(); 实例化以后，底层创建了长度为16的数组Entry[] table
map.put(key,value);
首先调用key所在类的hashCode方法，计算key的哈希值，此哈希值经过某种算法计算后，得到key在Entry[]中的存放位置
如果此位置数据为空，则键值对添加成功
如果此位置数据不为空（意味着此位置存放一个或多个数据（链表存储）），比较当前key和这些数据的哈希值，
如果key的哈希值与已经存在的数据局哈希值都不相同，则键值对添加成功
如果key的哈希值与已经存在的某个key的哈希值相同，则调用key所在类的equal方法
返回true，用value去替换已经存在key的value值
返回false，则键值对添加成功
默认扩容方式为原来的2倍，并且赋值过来
8与7的不同点
1 在new时，底层并没有创建长度为16的数组
2 jdk8底层的数组是 Node[],而非Entry[]
3 首次调用put方法时，底层创建长度为16的数组
4 JDK8底层使用 数组+链表+红黑树（当数组的某个索引位置上以链表形式存在的数据个数>8且当前数组长度>64，此时索引位置上的所有数据改为使用红黑树存储）
4. Métodos comuns na interface do mapa
V put(K key,V value) 向map中添加数据
V remove(Object key) 通过指定key移除键值对
void clear() 清空map集合
Object get(Object key) 通过key获取指定value
Boolean containsKey(Object key) 是否包含指定的key
Boolean containsValue(Object value) 是否包含指定的value
int size() 返回map键值对的个数
Boolean isEmpty() 判断map是否为空
Boolean equals(Object obj) 判断两个map是否相等
5. Mapa transversal
//遍历所有key
Set keySet = map.keySet();
Iterator iterator = keySet.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
//遍历所有value
Collection values = map.values();
Iterator iterator1 = values.iterator();
while(iterator1.hasNext()){
System.out.println(iterator1.next());
}
//遍历所有键值对
Set set = map.entrySet();
for (Object o : set){
Map.Entry entry = (Map.Entry) o;
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
Sete, ferramentas de coleta
Coleções é uma classe de ferramenta que pode manipular Conjunto, Lista e Mapa
reverse(List) 反转List中元素的顺序
shuffle(List) 对List集合中的元素进行随机排序
sort(List) 根据元素的自然排序对List集合元素进行升序排序
sort(List,Comparator) 根据指定的Comparator产生的顺序对List进行排序
swap(List,int,int) 将指定List集合中的i处元素和j处元素进行交换
int frequency(Collection Object) 返回指定元素出现的次数
void copy(List dest,List src) 将原集合复制带目标集合