java集合-iterable

Iterable与Iterator的关系

1. 通过看源码我们可以发现iterable封装了iterator接口的
2. 如果实现了iterable接口，就可以使用iterator迭代器

iterator与ListIterator的关系

1. iterator方法（next()，hasNext()，remove()）
2. ListIterator是iterator的子接口
3. ListIterator比iterator多了三个方法（previous()：移动到后一个元素，hasPrevious()：判断是否还有元素，add()：添加元素）

collectoin与iterable的关系

1. Collection继承了iterable
2. 只要继承了collection都有iterator迭代器

collectoin与List和Set的关系

List和Set都继承了collection接口，也就都有iterator迭代器

List

List是一个有序，允许重复的集合

ArrayList

底层数据结构是数组，查询快，增删慢，线程不安全，效率高

vector

底层数据结构是数组，查询快，增删慢，线程安全，效率低

LinkedList

底层数据结构是链表，查询慢，增删快，线程不安全，效率高

Set

Set是一个无序，不允许重复的集合

HashSet

1. HashSet:不能保证元素的顺序；不可重复；不是线程安全的；集合元素可以为 NULL;
2. 其底层其实是一个数组，存在的意义是加快查询速度。我们知道在一般的数组中，元素在数组中的索引位置是随机的，元素的取值和元素的位置之间不存在确定的关系，因此，在数组中查找特定的值时，需要把查找值和一系列的元素进行比较，此时的查询效率依赖于查找过程中比较的次数。而 HashSet 集合底层数组的索引和值有一个确定的关系：index=hash(value),那么只需要调用这个公式，就能快速的找到元素或者索引。
3. 对于 HashSet: 如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。
   • 当向HashSet集合中存入一个元素时，HashSet会先调用该对象的hashCode（）方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置
     • 如果 hashCode 值不同，直接把该元素存储到 hashCode() 指定的位置
     • 如果 hashCode 值相同，那么会继续判断该元素和集合对象的 equals() 作比较
       • hashCode 相同，equals 为 true，则视为同一个对象，不保存在 hashSet（）中
       • hashCode 相同，equals 为 false，则存储在之前对象同槽位的链表上，这非常麻烦，我们应该约束这种情况，即保证：如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

• 常见的hashcode算法
  Boolean： hashcode= f?0:1
  char，int，short，byte： hashcode=(int)f
  long： hashCode (int)(f^(f>>>32))
  float ： hashCode=Float.floatToIntBits(f)
  double ： long l = Double.doubleToLongBits(f);hashCode = (int)(1^(1>>>32)) ;
  普通的引用类型 ： hashCode=f.hashCode()

LinkedHashSet

底层采用 链表 和 哈希表的算法。链表保证元素的添加顺序，哈希表保证元素的唯一性

TreehSet

有序；不可重复，底层使用 红黑树算法，擅长于范围查询。

• 如果使用 TreeSet() 无参数的构造器创建一个 TreeSet 对象, 则要求放入其中的元素的类必须实现 Comparable 接口所以, 在其中不能放入 null 元素
• 必须放入同样类的对象.(默认会进行排序) 否则可能会发生类型转换异常.我们可以使用泛型来进行限制
• 自动排序：添加自定义对象的时候，必须要实现 Comparable 接口，并要覆盖 compareTo(Object obj) 方法来自定义比较规则
  • 如果 this > obj,返回正数 1
  • 如果 this < obj,返回负数 -1
  • 如果 this = obj,返回 0 ，则认为这两个对象相等
• 两个对象通过 Comparable 接口 compareTo(Object obj) 方法的返回值来比较大小, 并进行升序排列
  • 
• 定制排序: 创建 TreeSet 对象时, 传入 Comparator 接口的实现类. 要求: Comparator 接口的 compare 方法的返回值和 两个元素的 equals() 方法具有一致的返回值

     public static void main(String[] args) {
         Person p1 = new Person(1);
         Person p2 = new Person(2);
         Person p3 = new Person(3);
          
         Set<Person> set = new TreeSet<>(new Person());
         set.add(p1);
         set.add(p2);
         set.add(p3);
         System.out.println(set);  //结果为[1, 2, 3]
     }
  
 }
  
 class Person implements Comparator<Person>{
     public int age;
     public Person(){}
     public Person(int age){
         this.age = age;
     }
     @Override
     /***
      * 根据年龄大小进行排序
      */
     public int compare(Person o1, Person o2) {
         // TODO Auto-generated method stub
         if(o1.age > o2.age){
             return 1;
         }else if(o1.age < o2.age){
             return -1;
         }else{
             return 0;
         }
     }
      
     @Override
     public String toString() {
         // TODO Auto-generated method stub
         return ""+this.age;
     }
 }

• 当需要把一个对象放入 TreeSet 中，重写该对象对应的 equals() 方法时，应保证该方法与 compareTo(Object obj) 方法有一致的结果

以上三个 Set 接口的实现类比较：

• 共同点：1、都不允许元素重复
  　　　　2、都不是线程安全的类，解决办法：Set set = Collections.synchronizedSet(set 对象)

• 不同点： HashSet:不保证元素的添加顺序，底层采用 哈希表算法，查询效率高。判断两个元素是否相等，equals() 方法返回 true,hashCode() 值相等。即要求存入 HashSet 中的元素要覆盖 equals() 方法和 hashCode()方法

LinkedHashSet:HashSet 的子类，底层采用了 哈希表算法以及 链表算法，既保证了元素的添加顺序，也保证了查询效率。但是整体性能要低于 HashSet

TreeSet:不保证元素的添加顺序，但是会对集合中的元素进行排序。底层采用 红-黑 树算法（树结构比较适合范围查询）

Map

key-value 的键值对，key 不允许重复，value 可以

1. 严格来说 Map 并不是一个集合，而是两个集合之间 的映射关系。

1. 这两个集合没每一条数据通过映射关系，我们可以看成是一条数据。即 Entry(key,value）。Map 可以看成是由多个 Entry 组成。

3、因为 Map 集合即没有实现于 Collection 接口，也没有实现 Iterable 接口，所以不能对 Map 集合进行 for-each 遍历。