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

------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培训、期待与您交流！ -------