java se 集合 笔记

/**
 * 集合 ：  ---》存储对象的 容器 
 * 
 * 两个大接口
 * 1.collection
 * list<小接口>  有序，可以重复  【动态数组】
 * Set <小接口>  无序 ，不能重复 
 * 2.Map 具有映射关系 的   key-value对   键值对 
 * 
 * 3.类：collections 工具类 
 * 
 * 
 * 存储对象可以用    数组或者 集合 。
 * 
 * 数组 存储对象：    Student[] st =new Student[100];
 *   弊端： ① 一旦声明  ，数组的长度不可变。 
 *   ②真实存放对象的个数 不可知 。
 *  
 * 
 * 
 * 
 * 
 * @author Administrator
 *

 */

/**
 * collection 接口下的 小接口    List 
 * List接口的实现类     存放 有序   可重复的数据  容器。   
 *      ArrayList【主要实现类 】      线程不安全 ， 最主要的实现类 
 *      
 *      LinkedList[频繁 增加、删除集合时]使用此实现类  。  内存中 片段存储  各个片段用指针联系。
 *      
 *      Vector 比较老得实现类，  线程安全 ，已经过时。  不常用。<弃用 >
 *      
// ArrayList  与 LinkedList类可以 无缝切换使用，  只是 在频繁对集合元素删除 添加时 使用 LinkedList
 * 
 *  
 *  
 * @author Administrator
 *     添加进list的元素【对象】 一定要重写 equals()方法  ！！！！！！  remove()  removeAll() retainAll()  contains() 
 *     equals() contains()等 比较相等都要用到对象的equals()方法
 */

/**
 * 
 * Collection接口   中另一个 子接口   
 * Set接口     无序  不可重复      Set 中常用的方法都是Collection下定义的。 
 * 实现类 ：  HashSet 主要实现类         LinkedHashSet     TreeSet
 * 
 * Set 中元素(对象)  都是无序的  [不是随机的！！！]  不可重复的
 *    1、无序性 ！= 随机性    真正的无序性 指的是 元素在底层存储的位置是无序的。    底层存储的位置  无序 由 hashcode值决定。  
 *    2、不可重复性   当向Set中 添加进相同的元素的时候  后面的不能添加进去。
 *    
 *    Set 实现类   HashSet        LinkedHashSet 
 *    HashSet 主要使用的实现类。
 *    LinkedHashSet  添加元素 效率略低于HashSet  每添加一个元素 都要在元素前后添加指针，是双向链表的形式。
 *       遍历元素 效率略高于 HashSet， 也是由于有双向链表，可以前后指针指向 遍历效率略高。
 *    
 *    添加到Set中的元素  不仅要重写 equals()方法，  还要重写 hashcode方法！！！
 *     只重写 equals()方法 不起作用，相同的自定义类对象仍然可以添加进去。
 *     
 *     Set 中存储 不相同的元素， 为了提高 效率 ， 避免每次添加元素时都跟已有元素进行比较 的低效率    ，采用了 哈希算法，
 *     即 每次添加元素之前 ，进行一次hashcode()的算法 生成一个值， 看有没有重复的值 即可  ， 避免跟每个元素进行比较。
 *     一般情况下 重写 equals()和 hashcode()方法  保持这两种方法的一致性， 
 *     即  元素相同 则  hashcode()值 保持一致，equals()方法返回true;
 *       元素不相同 hashcode()值不一致，equals()方法返回false;
 *     
 *     由于 Set集合中 添加元素时 先比较hashcode值 ，如果不重写 hashCode()方法  则内容相同的两个元素的 hashCode值不同，仍然可以添加到Set
 *     
 *     所以 在使用Set集合 存储元素时  ，必须要同时 重写 hashCode() 和 equals()方法 ！！！ 
 *     此处 存储到List的元素 只需要重写equals()方法即可，  注意两者区别。     
 *     
 *      应用实例
Person1  p1 =new  Person1("GGF",25);
Person1  p2 =new  Person1("GGF",25);
// 当不重写  equals()和 hashCode()方法时 。 P1 !=P2 
// 当重写  equals()   不重写 hashCode()方法时 。 P1 =P2   但是在向Set中添加时  计算的哈希值不同，仍然认为是2个不同元素    
// 当重写  equals()   也重写 hashCode()方法时 。 P1 =P2   在向Set中添加时hashCode()  计算的哈希值相同，equals()也相同 ，认为是相同的元素，不允许重复添加      
 *
 *    
// LinkedHashSet  遍历顺序是按照添加元素的先后顺序，但是  LinkedHashSet 依然是无序的   无序 ：指的是 元素的存储位置无序，跟遍历顺序无关！！！  
// 只是在添加元素时 每个元素都有前后的指针 [双向链表]
 *
 *
 *
 *
 * 
 * @author Administrator
 *
 */

/**
 * 数组 既可以 存放 基础数据类对象 ，又可以存放引用数据类型的对象
 * 集合  ：  java中 集合只能存放 引用数据类型  ！！不能存放  基础数据类型 。      
 * [jdk1.5后   基础数据类型可以自动装箱  成包装类，存放基础类型其实是其包装类对象。] 
 * 
 * 
 * 
 * Collection 接口下第二大接口 Set 子接口
 *     Set 子接口 实现类  HashSet  LinkedHashSet  TreeSet;   Set是    无序的     存储的元素 不可重复的。
 *     
 *     Set中存放的对象 不仅要重写 equals()方法 ，  因为元素时无序的   在存储时先用 存储对象的hashCode值 去比较，  所以 还要重写  hashCode方法。
 *     
 *     
 *     
 *     HashSet----最常用 。 存放 无序【无序不代表 遍历结果随机， 遍历结果是根据元素hashCode值计算的  固定顺序的】  不可重复的 元素 
 *     
 *     LinkedHashSet----增减元素慢  遍历元素快，   遍历的结果跟添加的顺序一致：不代表是有序的！！！
 *     父接口 Set是无序的，指的 元素存储位置是无序的。 跟遍历的结果顺序无关 。
 *  
 *     TreeSet   -----  必须存放同一类型的对象   并且   实现自然排序接口  或者 制定排序接口   
 *               -----  必须要 存储的对象    重写 Comparable接口 的 compareTo(Object obj) 方法    ，返回0表示俩对象相等。
 * String 和基本数据类型的包装类 均已  重写了 Comparable接口的  compareTo(Object obj)并且是由小到大排列
 *   排序方式分为 自然排序和 指定排序 。
 *     自然排序是 对象重写compareTo()之后 指定排序的属性【可以指定多个属性 分多级排序】。
 * 
 * 
 *   compareTo()方法 与 hashCode()方法  equals()方法必须保持一致。
 * 
 *    重写 Comparable接口的 compareTo()方法   ，如果是基础数据类型，  返回  return    当前this对象的属性 减去  obj对象的属性，


public int compareTo(Object o) {
// TODO Auto-generated method stub
if(o instanceof Person2){
Person2 p =(Person2)o;
// 按照年龄从小到大排序。  基础数据类型  两者相减， 是从小到大排序，  前面加负号 - 则表示从大到小排序。
// return this.age-p.age;
// 按照年龄从大到小排序
   return -(this.age-p.age);
//             按照名称排序                      String类型， 引用数据类型             调用如下 已经重写compareTo()过的方法。 从小到大排序  遍历输出     。     
//        return this.name.compareTo(p.name);
   

 * @author Administrator
 *
 */

/**
 * TreeSet  除了  自然排序   还有 定制排序  
 *          自然排序  排序对象 实现了 Comparable接口的compareTo()方法 
 *          订制排序  实现了Comparator接口的compare(Object obj1,Object obj2)方法;
 *
 * 实际开发中当能操作TreeSet存储的对象类时，  在存储对象上实现Comparable接口  重写 compareTo()方法
 *  如果不能操作集合中存储对象类时，  使用订制排序，   Set  set = new TreeSet(Comparator c);  
 *       定制排序 ： 在重写 Comparator接口的compare(Object obj1,Object obj2)方法 指定排序规则。
 * 
 * 如果集合中存储对象也指定自然排序   ，那么  订制排序     优先级高于 自然排序。
 * 
 * @author Administrator
 *
 */

/**
 * TreeSet  练习 
 * 
 *       TreeSet 存储的对象类型必须相同 
 *       
 *       TreeSet  要存入Set中的对象 (对象中引用的类型 类     也必须重写equals()方法)   
 *       必须指定排序   [自然排序接口，  和定制排序接口 两种方式选一]
 *       
 *       
 *       如果集合中存储的对象          既实现接口Comparable 自然排序  ,  
 *                      也 调用带 Comparator接口的TreeSet()构造器   定制排序 ，那么  订制排序     优先级高于 自然排序。
 *       
 * 
 * 
 * @author Administrator
 *
 */

/**
 * 
 * Map 接口 
 * Hashtable  也是一个古老的 实现类， 是线程安全的。   弃用  ---不推荐在程序中使用了。
 *           子类   properties  常用来处理属性文件  key-value值都是String类型的
 * 
 * 
 * 
 * @author Administrator
 *
 */

/**
 * Map接口  
 * 
 * 
 * LinkedHashMap实现类 
 * 
 * LinkedHashMap 使用链表维护，添加进Map的顺序， 故遍历Map时 是按照添加顺序遍历的。
 *
 * 跟LinkedHashSet 一样 使用双向链表， 插入添加操作慢,遍历速度快。
 * 
 * 
 * 
 *      遍历顺序跟 添加顺序一致   . 存放仍然无序， 用链表指针相互连接。  不代表是有序的！！！！。  参考 HashSet  LinkedHashSet 。
 * 
 * 
 * 
 * 
 * @author Administrator
 *
 */

/**
 * 集合  中与 Collection 接口并列的接口 -------  Map接口
 * 
 * Map接口 
 * 1、HashMap        主要实现类      
 * 2、LinkedHashMap ---参考LinkedHashSet 的存储结构
 * 3、TreeMap  ---参考 TreeSet类 的使用
 * 以上实现类结构 与  Set接口 接口类似。
 * 
 * 
 * 4、Hashtable  古老的实现类   线程安全                 key和value中均不能存放 null      ----弃用
 * 5、Poperties  常用于处理属性文件， 键值对 都是String类型的。
 * 
 *
 * Map  存储的 是 key - value  键值对  每个键值对 是一个   Entry 
 * 
 * Map 中键值对：   key  --keySet集合
 *           value ---collection集合
 * 
 * 
 * key键 是一个Set集合，key中不允许有重复值 !!!!添加元素时 put      若key重复             则 新添加的 替换原有的 key--value 对   
 * value值 一个collection集合  可以有重复值 。
 * 
 * 
 *   添加元素时  put 如果放入 与集合中key重复【不管value值是否重复 】的 Entry  则 集合中已有相同key值的Entry会被覆盖 。
 *  
 *   map 一般用 String类型 作为 key值。
 *   
 *   存入map中的元素 要重写  equals()和 hashCode()方法。
 *      
 *      
 *      map.put(Object key,Object value);   添加 Entry
 *      map.remove(Object key);     根据key 删除 一个元素 key-value键值对 , 返回值是 对应的value值
map.get(Object key);   根据key值获取value值
 *
 *
 * 判断是否包含， 会调用相应对象的equals()方法 ，所以 map中存储的 key 和value 对象  均需要重写 equals() 和 hashMap()方法
 * 
map.containsKey(Object key);  对应的key集合中    是否包含 key  
map.containsValue(Object value);  对应的value集合中   是否包含value
 *
 *
map.clear();//清空一个map集合
 * map.isEmputy();//是否是空
 * map.equals(Object  obj);//判断是否相等
 *     
 *     
 *     
 *     map的遍历的方法       存放元素  仍然是无序的。
 * map.keySet();    遍历    键key   返回一个Set集合
 * map.values();    遍历   value值      返回一个 collection集合
 * 
 *     map.entrySet();  遍历   键值对   key-value 返回一个Set集合
 * 
 * @author Administrator
 *
 */

/**
 * 
 * Map接口的实现类 
 * TreeMap类 ，    ----------参考TreeSet
 *      按照添加进Map的元素 key  对象  的  指定属性   进行排序，要求 key必须是同一个类的对象， 
 *      排序方式 ： 自然排序 vs 定制排序
 *      
 *      
 *      
 * 
 * 
 * @author Administrator
 *
 */

/**
 * 操作集合的工具类
 * 
 *  
 *  
 * 操作Collection以及Map的工具类 ，Collections是一个类， 可以操作 Collection接口和 Map接口
 * 
 * 
 * Collections中常用的方法  
 * 
 * Collections.sort(list);  //排序
 * Collections.reverse(list); //翻转
 * Collections.shuffle(list); //随机排序
 * Collections.sort(List list,  Comparator c);  //自定义 Comparator接口实现类 设置排序方式。参考TreeSet 中使用  Comparator
 * Collections.swap(list, 1, 3);   //交换list集合中的两个元素
 * 
//ArrayList 是线程不安全的,  用Collections.synchronizedList(list) 转换为线程安全的。
List list2 = Collections.synchronizedList(list);

//把一个集合复制到另一个集合  Collections.copy(dest, src);   dest是目标集合   src是源
List list1 = Arrays.asList(new Object[list.size()]);
Collections.copy(list1, list);

//取集合中的最大值 。
Object obj = Collections.max(list);
// 根据 自定义Comparator接口的实现类定义的排序 规则 返回 集合中collection集合中的最大值
Collections.max(list, Comparator);

//取集合中的最小值 。
Object obj1 = Collections.min(list);
// 根据 自定义Comparator接口的实现类定义的排序 规则 返回 集合中collection集合中的最小值
Collections.min(list, Comparator);

//返回一个对象在集合中出现的次数。
int in =Collections.frequency(list, 123);

// 把集合中所有的old 替换成 new
Collections.replaceAll(list, old, new);

 * 
 * 
 * 
 * 
 * @author Administrator
 *
 */