java集合基础总结

问题:
集合和数组的区别?
集合：
* 1：长度可以发生改变。
* 2：只能存储对象类型（引用类型）。
* 3：可以存储任意类型的对象。
* 数组：
* 1：长度固定。
* 2：可以存储基本类型，也可以存储对象类型。
* 3：只能存储同一种类型的元素。
* 由于数据结构不同，java对应的提供了多种集合。
* 但是，不管你是哪种集合，你都应该具备存储功能，获取功能，删除功能等功能。
* 把这些相似的功能进行提取，就最终形成了集合的继承体系结构。
* Collection接口:
Collection接口没有具体的实现：主要功能：
1:添加功能

     boolean add(Object e):往集合中添加一个元素。      boolean addAll(Collection c):往集合中添加一个集合的元素。 

2:删除功能

      void clear():移除集合中的所有元素。       boolean remove(Object o):移除集合中指定的一个元素。       boolean removeAll(Collection c):移除集合中指定的一个集合的元素。      a.removeAll(b);删除a中存在的b元素 

3:判断功能

     boolean contains(Object o):判断集合中是否包含指定的元素。      boolean containsAll(Collection c):判断集合中是否包含指定的一个集合的元素。      boolean isEmpty():判断集合是否为空。 

• 4:遍历功能

    Iterator iterator() 迭代器。用于获取集合中的元素。` 

• 5:长度功能

        `int size():获取集合中元素的个数。` 

• 6:移除功能

         boolean retainAll(Collection c)         移除此collection 中未包含在指定 collection 中的所有元素。         保留相同的         如果此 collection 由于调用而发生更改，则返回 true

• 7:集合转数组
  Object[] toArray():把集合转换为数组返回Object[]。
• Colletion接口的常用子接口:
  1)List接口:
• List接口的特有的方法：
  List的特有功能：

          A:添加功能 *                void add(int index,Object element):在指定的位置添加元素。                  //指定位置添加是防止出现越界的情况 *           B:获取功能 *                Object get(int index):根据给定的索引，获取元素。 *           C:列表迭代器 *                ListIterator listIterator() *           D:删除功能 *                Object remove(int index):删除指定索引位置的元素，并返回该元素。 *           E:修改功能 *                Object set(int index,Object element):用指定的元素修改指定位置的元素，并把修改前的元素返回。

• List的三个儿子：
  ArrayList: 底层数据结构是数组。查询快。增删慢 。线程不安全。效率高
  Vector (用的非常少 ): 底层数据结构是数组。查询快。增删慢 。线程安全。效率低
  LinkedList: 底层数据结构是链表。查询慢。增删快 。线程不安全。效率高
  查询多：用ArrayList 增删多：用LinkedList
  LinkedList的特有功能：

  A:添加元素 * public void addFirst(Object e) * public void addLast(Object e) * B:删除元素 * public Object removeFirst() * public Object removeLast() * C:获取元素 * public Object getFirst() * public Object getLast()

*用LinkedList模拟栈数据结构的集合：(先进后出，后进先出)

 public class MyStack {                 private LinkedList link;                 public MyStack() {                     link = new LinkedList();                }                 public void add(Object obj) {                     link.addFirst(obj);                }                 public Object get() {                     // return link.getFirst();                     return link .removeFirst();                }                 public boolean isEmpty() {                     return link .isEmpty();                }            }

2)Set接口：
Set接口的实现:
A.HashSet:

 //创建HashSet集合对象        HashSet<String> hs = new HashSet<String>();         //将元素写入HashSet对象         hs.add( "hello");         hs.add( "world");         hs.add( "java");         hs.add( "hello");         hs.add( "java");         //遍历元素         Iterator it = hs.iterator();         while(it .hasNext()){            System. out.println(it .next());             //输出  hello   world  java        }

我们发现HashSet不能保存重复的String元素,那么问题来了。HashSet是如何保证元素的的唯一性的呢？
我们来试一试用HashSet保存自定义对象，是否能做到元素唯一呢？ps:如果两个自定义对象的成员变量全部相同。则我们说明它们是同一个对象。
//创建HashSet集合对象

        HashSet<Student> hs = new HashSet<Student>();         //创建Student类的实例        Student s1 = new Student("hello" ,23);        Student s2 = new Student("world" ,21);        Student s3 = new Student("java" ,13);        Student s4 = new Student("hello" ,23);         //将Student元素写入HashSet对象         hs.add( s1);         hs.add( s2);         hs.add( s3);         hs.add( s4);         //遍历元素         for(Student s : hs ){            System. out.println(s );             //我们发现 相同的 s1和s4都被写入到集合中        }

如果两个自定义对象的成员变量全部相同，它们不一定是一个对象。只不过我们的需求是要去成员变量全部相同的就是同一个对象。。。于是，我们重写object类的equals()方法
但结果是，我们重写了equals()方法后却发现并没有去掉重复的元素.

结论：HashSet的底层其实是HashMap.
HashSet集合的底层数据结构是哈希表。
哈希表结构是一个元素是链表的数组。存储的时候是以对象哈希值为数组索引进行存储的
* 哈哈希表的存储依赖两个方法：
* hashCode()和equals()。
* 执行顺序：
* 首先判断对象的哈希值是否相同，
* 如果相同，就继续执行equals()方法。
* 如果equals()方法返回true，说明元素重复了。新添加的value覆盖掉原来的value。返回原来的value。。。key不变
* 如果equals()方法返回false，说明元素没有重复的，就添加到集合中，但与此元素位于同一个bucket中。形成Entry链，最早放入在bucket中的Entry则位于其Entry链的最底层。遍历的时候遍历这个Entry链,位于最底层的最后被找到
* 如果不同，就直接添加到集合中。
*
* 以后你看到HashXxx结构的集合，要知道，这种结构底层是哈希表。(是一个元素是链表的数组)
* 它依赖hashCode()和equals()方法。
* 自动生成即可。
* TreeSet:
无序，唯一。但它可以按照某些规则进行排序。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，
* 具体取决于使用的构造方法。
*
* 无参构造方法，默认采用的是自然排序。
TreeSet如何保证元素的唯一性和排序的呢?？？

默认情况下，要想实现自然排序，元素所属的类（String已经实现了）就必须实现Comparable接口。（注意：Comparable接口后面的泛型要写入要比较的对象类型，默认的是Object）
Comparable的方法 compareTo(Student o)

{String的compareTo方法compareTo()的返回值是整型,它是先比较对应字符的大小(ASCII码顺序),如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的
差值,如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方 全比较完,这时就比较字符的长度. }

唯一：根据次方法的返回值是否是0来决定。如果返回值是0，说明元素重复，就不再添加元素。
排序：
* 正：说明数据大，往后放。
* 0：说明重复。不添加。
* 负：说明数据小，往前放。
TreeSet采用无参构造时，就要让ThreeSet保存的对象继承Compareable并实现下面的方法

public int compareTo(Student o) {         int num1 =this.age - o.age;         int num2 = num1==0?this .name .compareTo(o.name):num1;         return num2 ;        }

当使用TreeSet的另一个构造方法时public TreeSet(Comparator comparator)
自己定义一个类实现Comparator接口。此时其中的 compare方法的参数是两个，其他的与comparable的compareTo一模一样
Set小结:
* |–HashSet 无序，唯一。
* |–LinkedHashSet 有序，唯一。
* 底层数据结构是链表和哈希表组成。
* 由链表保证元素有序。
* 由哈希表保证元素唯一。
* Map集合:
Map和Collection集合的区别?
* Map:
* a:存储的是键值对元素。
* b:键是唯一的。
* c:值是可重复的。
* Collection:
* a:存储的是单个的元素。
* b:Collection的儿子Set集合是唯一的。
* c:Collection的儿子List集合可以重复。
Map集合的数据结构和Set集合是一致的。
但是，这种数据结构只针对Map集合的键有效，跟值无关。
Map集合的主要功能:
Map集合的功能：
*

      A:添加功能 *                V put(K key,V value):如果键不存在，就是添加功能。如果键存在，就是修改功能。返         回的是被修改前的值。  *           B:删除功能 *                void clear():清空集合中的所有键值对元素。 *                V remove(Object key):根据键删除键值对元素，并把值返回。 *          C:判断功能 *               boolean containsKey(Object key):判断集合中是否包含指定的键。 *               boolean containsValue(Object value):判断集合中是否包含指定的值。 *               boolean isEmpty():判断集合是否为空。 *          D:获取功能 *               Set<Map.Entry<K,V>> entrySet():??? *               V get(Object key):根据键去集合中获取值。 *               Set<K> keySet():返回的是集合中所有键的元素。 *               Collection<V> values():返回的是集合中所有值的元素。 *          E:长度功能 *               int size():集合中的键值对元素的对数。

HashMap 与 TreeMap
HashMap遍历元素:

Map<Integer,String> map = new HashMap<Integer,String>();         map.put(1, "a");         map.put(2, "b");         map.put(3, "c");         map.put(4, "d");         map.put(5, "e");         //遍历获取所有的值，使用 values()方法 返回Collection类型        Collection<String> col =  map.values();         for(String s : col ){               System. out.println(s );        }         //遍历获取所有的健，使用 keySet()方法 返回Set类型        Set<Integer> set = map.keySet();         for(Integer s : set ){            System. out.println(s );        }最终版的遍历:    Set<Integer> set = map.keySet();         for(Integer s : set ){            String value = map.get( s);            System. out.println(s +"--" +value );        }

TreeMap :
注意TreeMap保持的元素是有序的。注意健的类型要实现Comparable接口。或者参数传递Comparator的子类。
TreeMap的特殊遍历

         map.put("as1" ,1);         map.put( "cs2",2);         map.put( "es3",3);         map.put( "bs4",4);         map.put( "ds5",5);         //Set<Map.Entry<K,V>> entrySet()        Set<Map.Entry<String, Integer>> set = map.entrySet();         for(Map.Entry<String, Integer>  me : set){            System. out.println(me .getValue()+"--"+ me.getKey());        }

Hashtable与HashMap：
Hashtable:是Map接口的一个具体实现类。JDK1.0出现的。1.2之后改进为实现Map接口。
* HashMap是用来替换Hashtable。
* 问题:HashMap和Hashtable的区别?
* A:HashMap 线程不安全，效率高。允许null键和null值。
* B:Hashtable 线程安全， 效率低。不允许null键和null值。