《黑马程序员》java集合知识梳理

                         ----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

Collection是最基本的集合接口。

  1.    Collection用于表示对任何对象或元素组，常见的方法有

                           

                                单个元素的增加及删除

                                       add(Object obj)   将obj添加给集合

                                       remove(Object obj)将集合中的元素obj删除掉

                               查询集合

                                           size():返回当前集合中元素中的数量

                                           isEmpty():判断当前集合是否有元素

                                          contain(Object obj)判断当前集合是否包含元素Obj

                                           Iterator():返回迭代器，用来访问集合元素

                               集合组操作

                                         boolean :  containAll(Collection c) 判断是否包含集合c

                                         addAll(Collection c)  :将集合c全部添加到集合中

                                         clear()：删除集合中所有的元素

                                         removeAll(Collection c)：删除集合中所有与集合c中元素相同的元素

                                         retainAll(Collection c):删除集合中所有与集合c中元素不相同的元素

     2. List

              list 集合中元素师有序的，元素可以重复，因此集合体系中有索引

              list中特有方法

                          add(int index ,element) 在指定位置添加元素

                          set(int index,element)修改指定位置的元素

                          indexOf(element) 依据元素找到元素在集合中的位置

                          listIterator()        获取迭代器

                                     迭代器使用方式

                                                    Iterator it = list.iterator();
                                                      while(it.hasNext())
                                         {
                                 sop("next:"+it.next());
                                             }

                       迭代器的方法

                                            boolean hasNext() 判断是否存在下一个访问元素

                                            Object next(), 返回要访问的下一个元素

                                            void remove() 删除上一个访问的元素

                     list集合有特有的迭代器ListIterator，ListIterator与普通的迭代器相比，它不仅能查询遍历，删除，而且它对元素有添加 修改的功能，并且它能向前遍历hasPrevious()。

                 

                       list可分三种

                                 ArrayList: 底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步

                                                        根据数组的特点访问，索引

                                 LinkList  底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步

                                                     使用堆栈先进先出的存储模式，那么在遍历的时候，先add进去的元素可能后面被遍历

                                 Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低

                                                      vector现在很少使用，如下是使用实例，

                                                                   Vector v = new Vector()

                                                                   Enumeration en = v.elements();
                                                                                  while(en.hasMoreElements())
                                                                       {
                                                                 System.out.println(en.nextElement());
                                                                          }

                一般我们常用的就是arraylist了

 3. set 

   

     set 集合是无序的，元素不可以重复，它包含Collection中所有的方法功能

                        HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是通过元素的两个方法，hashCode和equals来保证唯一性。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
                        ,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

                   一般hashcode和equal方法定义在hashSet集合元素所对应的对象类中，在hashset集合添加元素时，底层自动调用。那么对于list集合来说，判断元素存在问题就只能依靠equals方法，这是由于他们底层数据结构不同而导致的。

                         TreeSet底层的数据结构式二叉树，他的自然排序结构是以中序遍历方式存储

                         TreeSet集合可以按照元素的自然顺序对元素进行排序。那么要使得对象具有可以性，就要实现comparable接口

                         comparable接口中有conpareTo（）方法，返回值正数表示大，返回值为负数，表示为小，相等就返回0

    

                   在这里一定得注意个问题，如果你比较的对象中某种属性时，返回值是0，系统会自动认为在这两个对象相同，所以在比较时，一定要严谨，必须是比较晚所有属性后的返回值才能真正的说明这连个对象是否相同。

                     当元素的自身不具备比较性，这时就需要让容器具有比较性，那就要使用比较器comparator。

                      而当自身和集合都具备比较性我们将以集合的比较性为主。

                                 1. 实现接口comparable

class Student implements Comparable//该接口强制让学生具备比较性。
{
	private String name;
	private int age;

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Object obj)
	{

		//return 0;
		
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		System.out.println(this.name+"....compareto....."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
		/**/
	}

	public String getName()
	{
		return name;

	}
	public int getAge()
	{
		return age;
	}
}

                  2.定义比较器

class MyCompare implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;

		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
		{

			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
			/*
			if(s1.getAge()>s2.getAge())
				return 1;
			if(s1.getAge()==s2.getAge())
				return 0;
			return -1;
			*/
		}

		
		return num;

	}
}