黑马程序员--【学习日记六】——集合框架(一)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

知识列表

• 集合概述
• Collection中的基本方法
• List集合共性方法
• ArrayList
• LinkedList
• HashSet
• TreeSet

1）集合概述

集合长度可变，用于存储对象，可以存储不同类型的对象。

collection：List、Set

List：ArrayList、LinkedList、Vector

Set：TreeSet、HashSet

Collection 
     |--List:元素是有序的，元素可以重复。因为该集合体系有索引。 
           |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。 
           |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。 
           |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

    |--Set：元素是无序，元素不可以重复

 

2）Collection中的基本方法：

Collection定义了集合框架的共性功能。 
1，添加 
      add(e); 
      addAll(collection);

集合中存储的都是对象的引用，并非对象实体。

add方法的参数类型是Object。以便于接收任意类型对象。

2，删除 
      remove(e); 
      removeAll(collection); 
      clear();

3，判断。 
      contains(e); 
      isEmpty();

4，获取 
      iterator(); 
      size();

5，获取交集 
      retainAll();

6，集合变数组 
      toArray();

  1: class  CollectionDemo
  2: {
  3:     public static void main(String[] args) 
  4:     {
  5:         method_get();
  6:     }
  7:     public static void method_get()
  8:     {
  9:         ArrayList al = new ArrayList(); 
 10: 
 11:         //1，添加元素。
 12:         al.add("java01");//add(Object obj);
 13:         al.add("java02");
 14:         al.add("java03");
 15:         al.add("java04"); 
 16: 
 17:         /*
 18:         Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。 
 19: 
 20:         while(it.hasNext())
 21:         {
 22:             sop(it.next());
 23:         }
 24:         */ 
 25: 
 26:         for(Iterator it = al.iterator(); it.hasNext() ; )
 27:         {
 28:             sop(it.next());
 29:         }
 30:     } 
 31: 
 32:     public static void method_2()
 33:     {
 34:         ArrayList al1 = new ArrayList(); 
 35: 
 36:         al1.add("java01");
 37:         al1.add("java02");
 38:         al1.add("java03");
 39:         al1.add("java04");
 40:         ArrayList al2 = new ArrayList(); 
 41: 
 42:         al2.add("java03");
 43:         al2.add("java04");
 44:         al2.add("java05");
 45:         al2.add("java06"); 
 46: 
 47:         //al1.retainAll(al2);//去交集，al1中只会保留和al2中相同的元素。
 48:         al1.removeAll(al2); 
 49: 
 50:         sop("al1:"+al1);
 51:         sop("al2:"+al2); 
 52: 
 53:     } 
 54: 
 55:     public static void base_method()
 56:     {
 57:         //创建一个集合容器。使用Collection接口的子类。ArrayList
 58:         ArrayList al = new ArrayList(); 
 59:         //1，添加元素。
 60:         al.add("java01");//add(Object obj);
 61:         al.add("java02");
 62:         al.add("java03");
 63:         al.add("java04"); 
 64:         //打印原集合。
 65:         sop("原集合:"+al); 
 66:         //3，删除元素。
 67:         //al.remove("java02");
 68:         //al.clear();//清空集合。 
 69:         //4，判断元素。
 70:         sop("java03是否存在:"+al.contains("java03"));
 71:         sop("集合是否为空？"+al.isEmpty()); 
 72:         //2，获取个数。集合长度。
 73:         sop("size:"+al.size()); 
 74:         //打印改变后的集合。
 75:         sop(al); 
 76:     } 
 78:     public static void sop(Object obj)
 79:     {
 80:         System.out.println(obj);
 81:     }
 82: }

迭代器：

（游戏厅夹子的经典例子）

迭代器是取出方式，会直接访问集合中的元素。是集合的内部类。通过iterator()方法获取该内部类的对象。

使用迭代器是为了获取集合中的元素并操作元素。

3）List集合共性方法：

增 
      add(index,element); 
      addAll(index,Collection);

删 
      remove(index);

改 
      set(index,element); 
查 
      get(index): 
      subList(from,to); 
      listIterator(); 
      int indexOf(obj):获取指定元素的位置。 
      listIterator();

获取子列表：subList();

列表迭代器：ListIterator，是List集合特有迭代器。之所以要有列表迭代器，是因为Iterator迭代器只有判断、取出和移除三种方法，没有增加等功能，有局限性，ListIterator是Iterator的子接口，用法和Iterator一样，但是具备增删改查等比较齐全的功能。

4）ArrayList：

底层使用数组结果。查询较快，增删较慢。但一般情况下都是进行查询操作，所以一般使用的都是ArrayList。

ArrayList线程不同步，Vector虽然虽然也是数组结构而且线程同步，但无论增删还是查询都很慢，所有ArrayList取代了Vector。

可变长度：ArrayList默认长度是10，当容量超过10后，再添加新元素时，会50%延长，添加将新元素。Vector是100%延长，默认长度也是10；

相比之下，ArrayList比Vector更节省空间。

枚举是Vector的特有取出方式：

  1: Enumeration en = v.elements();
  2: 
  3: while(en.hasMoreElements())
  4: {
  5:      System.out.println(en.nextElement());
  6: }

 

从上面的例子可以看出，枚举和迭代器是一样的，但是枚举名称和方法名称都比较长，所以使用迭代器方便一些。枚举是Vector特有方法。

5）LinkedList：

LinkedList底层是链表结构，增删速度很快，查询稍慢。线程不同步。

LinkedList:特有方法： 
addFirst(); 
addLast();

在集合的头脚标位置，也就是在起始位置添加元素。

getFirst(); 
getLast(); 
获取元素（但不删除元素）如果集合中没有元素，会出现NoSuchElementException异常

removeFirst(); 
removeLast(); 
删除元素。如果集合中没有元素，会出现NoSuchElementException异常

pollFirst（）；

pollLast(); 

删除元素，如果集合中没有元素，就会返回null；这是与removeFirst（）的区别。

在JDK1.6出现了替代方法。

offerFirst(); 
offerLast();

peekFirst(); 
peekLast(); 
获取元素。如果集合中没有元素，会返回null。这是与getFirst和getLast的区别。

6）HashSet：

Set元素是无序的。元素不可重复。

Set集合和Collection的功能是一致的。

HashSet底层是哈希表结构。

  1: class HashSetDemo 
  2: {
  3: 	public static void sop(Object obj)
  4: 	{
  5: 		System.out.println(obj);
  6: 	}
  7: 	public static void main(String[] args) 
  8: 	{
 10: 		HashSet hs = new HashSet();
 11: 
 12: 		System.out.println(hs.add("java01"));//true
 13: 		System.out.println(hs.add("java01"));//false,相同元素不能存入
 14: 		hs.add("java02");
 15: 		hs.add("java03");
 16: 		hs.add("java03");
 17: 		hs.add("java04");
 19: 		Iterator it = hs.iterator();
 21: 		while(it.hasNext())
 22: 		{
 23: 			sop(it.next());
 24: 		}
 25: 	}
 26: }

HashSet中保证对象唯一性：覆写HashCode和equals方法。而且这两方法是集合内部自动调用的，非手动调用。为了防止HashCode相同，可以写成name.hashCode+age*7（7是随意的）这样的方式定义hashCode值。

注意：覆写HashCode方法和equals方式不能出错。

HashSet判断和删除依据：contains()和remove()方法判断和删除依据是hashCode值和equals。如果hashCode不同就不判断equals。

*ArrayList判断元素的依据是equals。*

7）TreeSet

底层数据结构是二叉树。

可以对Set集合中的元素进行排序。 
保证元素唯一性的依据： 
compareTo方法

TreeSet排序的第一种方式：让元素自身具备比较性。 
元素需要实现Comparable接口，覆盖compareTo方法。 
也种方式也成为元素的自然顺序，或者叫做默认顺序。

TreeSet的第二种排序方式。 
      当元素自身不具备比较性时，或者具备的比较性不是所需要的。 
      这时就需要让集合自身具备比较性。 
      在集合初始化时，就有了比较方式。

  1: public int compareTo(Object obj)
  2: 	{
  4: 		//return 0;
  6: 		if(!(obj instanceof Student))
  7: 			throw new RuntimeException("不是学生对象");
  8: 		Student s = (Student)obj;
 10: 		System.out.println(this.name+"....compareto....."+s.name);
 11: 		if(this.age>s.age)
 12: 			return 1;
 13: 		if(this.age==s.age)//当主要条件相同时就判断次要条件
 14: 		{
 15: 			return this.name.compareTo(s.name);
 16: 		}
 17: 		return -1;
 19: 	}

可以对Set集合进行排序。保证元素唯一性，compareTo，return 0；就表示相同。

自定义比较器，覆写compare方法。

  1: class Com implements Comparator{
  2: 	public int compare(Object o1, Object o2) {
  3: 		return 0;
  4: 	}
  5: }

让学生对象自身具备比较性，实现Comparable接口，覆写compareTo方法

  1: class Student implements Comparable{
  3: 	public int compareTo(Object o) {
  4: 		return 0;
  5: 	}
  6: }

如果两种排序方式都用了，以比较器为主。

二叉树结构都是根据比较性是否返回0，return 0判断是否相同。

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------