集合体系：
Collection：单列集合顶层接口 遍历方式：增强for Iterator 集合转数组
List：存取有序 元素可以重复 有序就有索引 有索引就可以通过索引操作元素。 遍历方式：普通for 增强for Iterator ListIterator 集合转数组
ArrayList：不安全 效率高 数组结构 增删慢 查询快
LinkedList：不安全 效率高 链表结构 增删快 查询慢
Vector：数组结构 安全 效率低
Set：存取无序 元素唯一。 遍历方式：增强for Iterator 集合转数组
HashSet：哈希结构 存取无序 元素唯一
LinkedHashSet
TreeSet：二叉树结构 可以排序
Map：双列集合 键唯一 值可以重复 遍历方式：根据键找值 根据键值对找键和值
HashMap：底层的哈希结构 保证键的唯一
LinkedHashMap：存入和取出的顺序相同，同事键也是通过哈希算法保证元素唯一性的
TreeMap：底层的二叉树结构 保证键的排序和唯一
Map：双列集合 ：
Map双列集合 Collection是单列集合
键不可以重复，值可以重复
数据结构针对键有效
方法：
添加功能
V put(K key,V value):添加元素。
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
删除功能
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回
判断功能
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
获取功能
Set<Map.Entry<K,V>> entrySet():获取所有的键值对的集合
V get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
Collection<V> values():获取集合中所有值的集合
长度功能
int size()：返回集合中的键值对的个数
代码演示：
public static void demo1() {
Map<String, Integer> map = new HashMap<>();
Integer i1 = map.put("张三", 23); //如果键是第一次存储，就直接存储元素，返回null
Integer i2= map.put("李四", 24);
Integer i3 = map.put("王五", 25);
Integer i4 = map.put("赵六", 26);
Integer i5 = map.put("张三", 26); //相同的键不存储,值覆盖,把被覆盖的值返回
System.out.println(map); //{赵六=26, 张三=26, 李四=24, 王五=25}
System.out.println(i1); //null
System.out.println(i2); //null
System.out.println(i3); //null
System.out.println(i4); //null
System.out.println(i5); //23 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
}
public static void demo2() {
Map<String, Integer> map = new HashMap<>();
map.put("张三", 23);
map.put("李四", 24);
map.put("王五", 25);
map.put("赵六", 26);
Integer value = map.remove("张三"); //根据键删除元素,返回键对应的值
System.out.println(value); //23
System.out.println(map.containsKey("张三")); //false 判断是否包含传入的键
System.out.println(map.containsValue(100)); //false 判断是否包含传入的值
System.out.println(map); //{赵六=26, 李四=24, 王五=25}
}
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("张三", 23);
map.put("李四", 24);
map.put("王五", 25);
map.put("赵六", 26);
Collection<Integer> c = map.values(); //获取集合中所有值的集合
System.out.println(c); //[26, 23, 24, 25]
System.out.println(map.size()); //4
}
遍历：
方式一(☆☆☆☆)：通过keySet()获取所有键的集合，然后遍历键的集合，获取到每一个键，然后通过getKey()方法
获取每一个值，这样把键和值一一对应的找出来了 就遍历了集合
需要用到的方法：
V get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
代码演示：
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("张三", 23);
map.put("李四", 24);
map.put("王五", 25);
map.put("赵六", 26);
//获取所有的键
/*
Set<String> keySet = map.keySet(); //获取所有键的集合
Iterator<String> it = keySet.iterator(); //获取迭代器
while(it.hasNext()) { //判断集合中是否有元素
String key = it.next(); //获取每一个键
Integer value = map.get(key); //根据键获取值
System.out.println(key + "=" + value);
}
*/
//使用增强for循环遍历
for(String key : map.keySet()) { //map.keySet()是所有键的集合
System.out.println(key + "=" + map.get(key));
}
}
方式二：通过entrySet()获取所有的键值对的集合，然后遍历键值对的集合，获取每一个键值对，
然后根据键值对来获取每一个键和值，这样把键和值一一对应的找出来了 就遍历了集合
需要用到的方法：
Set<Map.Entry<K,V>> entrySet():获取所有的键值对的集合
Map.Entry接口里面的
K getKey()：获取键值对中的键
V getValue()：获取键值对中的值
代码演示：
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("张三", 23);
map.put("李四", 24);
map.put("王五", 25);
map.put("赵六", 26);
//Map.Entry说明Entry是Map的内部接口,将 键和值的键值对 封装成了Entry对象,并存储在Set集合中
/*
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
//获取每一个 键值对 对象
Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
while(it.hasNext()) {
//获取每一个键值对对象
Map.Entry<String, Integer> en = it.next(); //父类引用指向子类对象
//Entry<String, Integer> en = it.next(); //直接获取的是子类对象
String key = en.getKey(); //根据键值对对象获取键
Integer value = en.getValue(); //根据键值对对象获取值
System.out.println(key + "=" + value);
}
*/
for(Entry<String, Integer> en : map.entrySet()) {
System.out.println(en.getKey() + "=" + en.getValue());
}
}
Map.Entry原理：Entry是Map接口里面的一个内部接口， 他的实现类是 Map子类里面的一个静态的内部类
代码演示：主要看一下结构 每行代码的含义不需要去研究
public interface Map<K,V> { //Map接口
/*省略代码*/
interface Entry<K,V> { //Map.Entry是Map下面的一个内部接口
K getKey(); //Map.Entry接口的抽象方法
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
}
}
public class HashMap<K,V> /*省略代码*/{ //HashMap类
/*省略代码*/
static class Entry<K,V> implements Map.Entry<K,V> { //Entry是Map的子类 里面的一个静态的成员内部类并且实现了Map.Entry接口
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
/*省略代码*/
}
/*省略代码*/
}
|
收藏
淘帖
踩
