java基础09-集合类

集合类

他们都在 java.util包里

Iterator（迭代器）

主要用于遍历Collection集合中的元素
GOF给迭代器模式的定义为：提供一种方法访问一个容器对象的各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。

Collection

单列集合，用来存储一个一个的对象

List （有序可重复）

• ArrayList(常用)
  list接口中最主要的实现类
  object[]数组存储，效率高，线程不安全 不同步
  源码分析：
  jdk7中
  ArrayList list=new ArrayList();//底层创建了长度为10 的object数组elementData
  list.add(123);//elementData[0]=new Integer(123);
  ....
  list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容；默认情况下，扩容为原来的1.5倍，同时需要将数组中的数据复制到新的数组中。
  建议：在开发中使用带参的构造器 ArrayList list=new ArrayList（int capacity）；
  jdk 8 ArrayList的变化
  ArrayList list=new ArrayList();//底层object[] elementData初始化为{}，没有创建长度
  list.add(123)；//第一次调用add()时，底层才创建长度为10的数组，并将原来数据123添加到了elementData中
  ....
  后续的添加和扩容操作与jdk 7 无异。
  总结：jdk7中的ArrayList的对象创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

• 常用方法
  增 add(object ogj)
  删 remove(int index)/remove(object obj)
  改 set(int index,object ele)
  查 get(int index)
  插 add(int index,object ele)
  长度 size()
  遍历 1)Iterator迭代器方式
  2)增强for循环
  3）普通的循环
  

• LinkedList(常用)
  双向链表存储，对于频繁插入，删除，修改，使用linkedList比ArrayList高
  源码分析：
  jdk7和8无异
  LinkList list=new LinkList（）；//内部声明了Node类型的first和last属性，默认为null
  list.add（123);//将123封装到node中，创建了node对象
  
  其中，node定义：体现了LinkList的双向链表的说法

  • getFirst（）
  • getLast（）
  • removeFirst()
  • addFirst()
  • ........

• Vector
  list接口中古老的实现类
  object[]数组存储，效率低，线程安全，同步
  源码分析：
  jdk7和jdk8中通过vector（）构造器创建对象是，底层创建了长度为10的数组
  在扩容方面，默认扩容为原来的数组的2倍。

Set(无序不可重复)

• HashSet(常用):作为Set接口主要实现类，线程不安全的；可以存储null值

• linkedHashSet：作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历
  linkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个
  引用，记录此数据前一个和后一个数据
  优点：对于频繁的遍历操作，LinkHashSet效率要高于HashSet

• TreeSet：可以按照添加对象的指定属性，进行排序
  向TreeSet中添加数据时要求的是相同类的对象（数据类型相同）
  两种排序方式：自然排序（实现Compareable接口）和定制排序（Comparator）
  自然排序中：比较两个对象是否相同的标准是：compareTo()返回0，不
  再是equals（）
  自然排序中：比较两个对象是否相同的标准是：compare()返回0，不
  再是equals（）
  Set接口中没有外定义新的方法，使用的是Collection中声明的方法
  要求： 向Set中添加数据，其所在的类一定要重写hashCode（）和equals（）

  以HashSet为例说明：
  无序性：不等于随机性。存储的诗句在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
  不可重复性：保证添加的元素按照equals()判断是，不能返回true。即：相同的元素只能添加一次。
  二、添加元素的过程，以HashSet为例
  我们向HashSet中添加元素a，首先调用元素a所在类的HashCode（）方法，计算元素a 的哈希值，此哈希值接着通过某种算法算出在HashSet底层数组中的存放位置（即：索引值）,判断数组中此位置上是已经有元素：
  如果此位置上没其他元素，则元素a添加成功----->情况1
  如果此位置上有其他元素b(或者以链表的形式存在的多个元素)，则比较元素a的与元素b的hash值：
  如果hash值不相同，则元素a添加成功。------>情况2
  如果hash值相同，进而需要调用a的equals（）方法：
  equals（）返回true,元素a添加失败
  equals（）返回false，则元素a添加成功。----->情况3
  对于情况2和3而言，元素a与已经存在指定索引位置上数据以链表的方式存储。
  jdk 7：元素a放到数组中，指向原来的元素
  

jdk 8：原来的元素放在数组中，指向元素a

Map

双列数据，储存key-value对的数据

• HashMap（重点）：作为Map的主要实现类，线程不安全，效率高，储存null的key和value

  • LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。
    原因：在原有的HashMap底层结构的基础上，添加了一对空指针，指向前一个和后一个数
    据，对于频繁的遍历操作，此类执行效率高于HashMap。

• TreeMap：保证按照添加的key-value对进行排序，，实现排序遍历，此时考虑key的自然排序和定制排序。底层使用的是红黑树

• Hashtable：作为古老的实现类，线程安全的，效率低，不能储存null的key和value

  • Properties:常用于处理配置文件，key和value都是String类型
  • JDK1.7 数组+链表
  • JDK1.8 hash表=数组+链表+红黑数

• 二、Map结构的理解
  Map中的key：无序，不可重复，使用Set存储所有的key，key所在的类要重写equals()和
  hashCode()(以hashMap为例)
  Map中的value：无序，可重复，使用Collection存储所有的value
  一个键值对：key-value构成了一个Entry对象
  Map中的entry：无序，不可重复，使用Set存储所有的entry
  

• HashMap底层实现原理，以jdk7为例
  

  HashMap map= new HashMap（）；
  在实例化以后，底层创建了长度是16的一维数组Entry[] table
  ......可能已经执行过多次put......
  map.put(key1,value1).....
  首先，调用key1所在的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到
  Entry数组所在的存放位置。
  如果此位置上的数据为空，此时key1-value1添加成功！-----情况1
  如果此位置上的数据不为空，（意味着此位置上存在一个或者多个数据（以链表的形式在）），
  比较key1和已经存在的一个或者多个数据的哈希值：
  如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1- value1添加成功！
  ----情况2
  如果key1的哈希值和已经存在的某一个数据（key2-value2）的哈希值相同，继续比较：
  调用key1所在类的equals（key2）方法：
  如果equals()返回false，此时key1- value1添加成功！-----情况3
  如果equals()返回true，使用value1替换value2

补充：关于情况2和情况3：此时key1-vaue1和原来的数据都是以链表的方式存储。
在不断的添加过程中，会涉及到扩容问题，默认的扩容方式：扩容为原来的容量的2倍，并将原来的数据复制过来。

jdk 8 相较与jdk7在底层实现方面的不同：
1.new HashMap（）：底层没有创建一个长度为16的数组
2.jdk8 底层的数组是 Node[],而非Entry[]
3.首次调用put()方法时，底层创建长度为16的数组
4.jdk7底层数据只有：数组+链表。
jdk8底层数据有：数组+链表+红黑树
当数组的某一个索引位置上元素以链表的形式存在的数据个数>8 且当前数组的长度 > 64
时，此时此索引位置上的所有数据改为使用红黑树

Map遍历

public class BianLi {
@Test
public void test() {
    Map map = new HashMap();
    map.put("aa",222);
    map.put("bb",123);
    map.put(23,142);
    map.put("cc",555);

    //遍历所有的key  keySet（）
    Set set = map.keySet();
  Iterator iterator = set.iterator();
  while(iterator.hasNext()){
      System.out.println(iterator.next());
  }
    System.out.println();
  //遍历所有的value集，values()
    Collection values = map.values();
    for (Object obj: values) {
        System.out.println(obj);
    }
    System.out.println();
    //方式1：entrySet（）
    Set set1 = map.entrySet();
    Iterator iterator1 = set1.iterator();
    while(iterator1.hasNext())
    {
        Object obj=iterator1.next();
        //entrySet集合里都是entry
        Map.Entry entry= (Map.Entry) obj;
        System.out.println(entry.getKey()+"-------->"+entry.getValue());
    }
  //方式2
    Set set2 = map.keySet();
    Iterator iterator2 = set2.iterator();
    while(iterator2.hasNext()){
        Object key = iterator2.next();
        Object value = map.get(key);
        System.out.println(key+"======"+value);
    }
}

}

Map常用方法

添加：put(Object key,Object value)
删除：remove（Object key）
修改：put(Object key,Object value)
查询：get（Object key）
长度：size（）
遍历：keySet()/values()/entrySet()

Collections工具类

Collections:操作Collection和、Map的工具类

泛型<>

所谓泛型，就是允许在定义类，接口时通过一个标识标识类的某个属性的类型或者是某个方法的返回值及参数类型。

1.jdk5.0新增的特性
2.在集合中使用泛型
1）集合接口或者集合类在jdk5.0是都修改为待泛型的结构
2）在实例化集合时，可以指明具体的泛型类型
3）指明完以后，在集合类或者接口中凡是定义类或者接口时，内部结构（比如：方法，构造器，属性等）使用到类型的位置，都指定为实例化的泛型类型。比如：add(E e)---->实例化以后：add(Integer e)
4）注意点：泛型必须是类，不能使基本数据类型。需要用到基本数据类型的位置，拿包装类来替换。
5）如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型

• 约束，避免类型转换之间的问题