黑马程序员--- 学习笔记(第十四天)

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
集合:
集合是一种容器.是可变长度的,可以存储不同类型的对象.


集合框架:
Collection
|--List
   |--ArrayList
   |--LinkedList
   |--Vector
|--Set
   |--HashSet
   |--TreeSet
为什么会出现这么多的容器?
因为每一个容器对数据的存储方式都有所不同,这个存储方式称之为:数据结构


collection共性方法:
 1.添加
 add(e);
 addAll(Collcetion);


 2.获取
 size() ;
 3.删除
 remove();
 removeAll();
 4.清空集合
 clear();
 5.判断
 contains();
 containsAll();
 isEmpty();
 6.交集
 retainAll();
 7.迭代器
 Iterator

/*
collection共性方法

测试
*/
import java.util.*;
class Demo1 
{
	public static void main(String[] args) 
	{
		Collection col=new ArrayList();
		// boolean add(E e) 
      //    确保此 collection 包含指定的元素（可选操作）。 
		col.add("a0");
		col.add("a1");
		col.add("a2");
		//boolean addAll(Collection<? extends E> c) 
       //   将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。 
	  ArrayList al=new ArrayList();
		 al.add("a7");
		 al.add("a1");
		  al.add("a6");
		   al.add("a2");
		col.addAll(al);
		// void clear() 
      //    移除此 collection 中的所有元素（可选操作）。 
				 //col.clear();
		
		// boolean contains(Object o) 
       //   如果此 collection 包含指定的元素，则返回 true。 
		sop(col.contains("a1"));
		// boolean containsAll(Collection<?> c) 
      //    如果此 collection 包含指定 collection 中的所有元素，则返回 true。 
		sop(col.containsAll(al));
	// boolean equals(Object o) 
      //    比较此 collection 与指定对象是否相等。 
	  sop(col.equals("a1"));
	//	boolean isEmpty() 
      //    如果此 collection 不包含元素，则返回 true。 
	  sop(col.isEmpty());
	
	//	boolean remove(Object o) 
      //    从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。 
		//sop(col.remove("a2"));
	
	//	boolean removeAll(Collection<?> c) 
       //   移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。 
	//	sop(col.removeAll(al));
		// boolean retainAll(Collection<?> c) 
      //    仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。 
		 sop(col.retainAll(al));
		// int size() 
      //    返回此 collection 中的元素数。 
		sop(col.size());

	//	Iterator<E> iterator() 
     //     返回在此 collection 的元素上进行迭代的迭代器。 
		Iterator it=col.iterator();
		for (;it.hasNext() ; )
		{
			System.out.println(it.next());
		}
	
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

//集合中存储的都是对于引用(地址)  


什么是迭代器?
其实就是集合的取出方式,把取出方式放在集合的内部,这样取出方式就可以可以直接访问
集合内部的元素,那么取出方式就被定义成了内部类,而每一个容器的数据结构不同,所以
取出方式的动作细节也不一样,但是都是有共性的内容:判断和取出,那么就将这些共性内容
抽取成一个接口,就是Iterator


那么这些内部类都符合一个规则,该规则就是Iterator,如何从获取集合中取出对象呢?
通过一个对外的提供方法iterator();


List:元素都是有序的,元素可以重复,因为该集合体系有索引
Set:元素是无序的,元素不可以重复


List特有方法,凡是可以操作角标的方法都是该体系的特有方法:
1.添加
add(index,e);
addAll(index,c);
2.获取
get(index);
indexOf(o);
size();
3.判断
equals();
contains();
containsAll();
isEmpty();
4.清空
clear()
5.删除
remove(index);
6.修改
set(index,o)
7.截取
subList()
8.迭代器
Iterator()
ListIterator()


List的特有迭代器:ListIterator是Iterator的子类接口,在迭代时不可以通过集合
对象方法操作集合的元素,因为会发生并发修改异常.
所以在迭代器时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能
对元素进行判断,取出,删除的操作.如果想要其他的操作如添加,修改等,就需要使用
子接口ListIterator,该类只能通过List集合的ListIterator()来获取

/*
List 共性方法

父类是Collection,所以父类有的方法该类都有
这里演示特有的,Demo1已经演示过父类的共性方法了
*/
import java.util.*;
class Demo2 
{
	public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();
		List list=null;
		 al.add("a1");
		al.add("a2");
		al.add("a3");
		 //void add(int index, E element) 
        //  在列表的指定位置插入指定元素（可选操作）。 
		 al.add(0,"a10");
		//	  boolean addAll(int index, Collection<? extends E> c) 
        //  将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。 
		ArrayList c=new ArrayList();
		c.add("a55");

		al.addAll(c);
	//	 int indexOf(Object o) 
      //    返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 
		sop(al.indexOf("a1"));
	//	int lastIndexOf(Object o) 
     //     返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 
		sop(al.lastIndexOf("a1"));
		//  E get(int index) 
       //   返回列表中指定位置的元素。 
  		sop("添加"+al.get(0));
		//	  E remove(int index) 
     //     移除列表中指定位置的元素（可选操作）。
	 sop("删除"+al.remove(0));
	//		  E set(int index, E element) 
      //    用指定元素替换列表中指定位置的元素（可选操作 
	  sop("修改"+al.set(0,"a0000"));
	//		  List<E> subList(int fromIndex, int toIndex) 
	  list=al.subList(0,2);
	 //     返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。 
	 //	 ListIterator<E> listIterator() 
        //  返回此列表元素的列表迭代器（按适当顺序）。 
		ListIterator li=al.listIterator();
		for (;li.hasNext() ; )
		{
			sop(li.next());
			if(al.contains("a0000"))
				 //al.remove("a0000"); //不能用集合的方法操作集合 
				li.remove(); //迭代的修改方法
				//li.set(e); 迭代器修改法
				//li.add(e); 迭代器的增加方法

		}
		//sop(li.next());  没有下一个了,回报NoSuchElementException
		sop(li.hasNext());
		sop(li.hasPrevious()); //逆序判断是否存在元素
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

 LinkedList特有方法:
 1.添加
 addFirst();
 addLast();
 2.删除 
 removeFirst();
 removeLast();
 3.修改
 set(index,e);
 4.获取
 getFirst();
 getLast();
 5.迭代器
 Iterator()
 ListIterator()
 6.清空
 clear();

/*
LinkedList特有方法
*/
import java.util.*;
class Demo3 
{
	public static void main(String[] args) 
	{
		LinkedList l=new LinkedList();
		l.add("a0");
		l.add("a1");
		l.add("a2");
		// void addFirst(E e) 
       //   将指定元素插入此列表的开头。
	   l.addFirst("第一个");
		// void addLast(E e) 
		//		  将指定元素添加到此列表的结尾。 
		l.addLast("最后一个");
		// E getFirst() 
		//		  返回此列表的第一个元素。
		sop(l.getFirst());
		// E getLast() 
		//		  返回此列表的最后一个元素。
		sop(l.getLast());
		// E removeFirst() 
		//		  移除并返回此列表的第一个元素。 
		sop("移除"+l.removeFirst());
		// E removeLast() 
       //   移除并返回此列表的最后一个元素。
	   sop("移除"+l.removeLast());
		// E pop() 
       //   从此列表所表示的堆栈处弹出一个元素。 
	   sop("移除"+l.pop());
		//void push(E e) 
        //  将元素推入此列表所表示的堆栈。
		l.push("就剩我一个了");

		Iterator it=l.iterator();
		for (;it.hasNext() ; )
		{
			sop(it.next());
		}
	 
		
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

 JDK1.6之后更新了这些方法:就是在获取元素为空时返回null,上面有些方法为空时会发生异常
 //添加
 offer();
 offerFirst();
 offerLast();
 //获取
 peek();
 peekFirst();
 peekLast();
 //移除
 poll();
 pollFirst();
 pollLast();
//  pop() //从此列表所表示的堆栈处弹出一个元素。 
// push(E e) // 将元素推入此列表所表示的堆栈。 

/*
JDK1.6 
LinkedList提供的新方法 
移除元素 不存在不会报异常 返回null
*/
import java.util.*;
class Demo8 
{
	public static void main(String[] args) 
	{	 
		LinkedList li=new LinkedList();
		li.add("one");
		li.add("two");
//		 boolean offer(E e) 
//          将指定元素添加到此列表的末尾（最后一个元素）。
		sop(li.offer("three"));
//		 boolean offerFirst(E e) 
//          在此列表的开头插入指定的元素。
		sop(li.offerFirst("four"));
//		boolean offerLast(E e) 
//          在此列表末尾插入指定的元素。 
		sop(li.offerLast("five"));
//		 E peek() 
//          获取但不移除此列表的头（第一个元素）。 
		sop("获取第一个元素"+li.peek());
//		E peekFirst() 
//          获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 
		sop("获取第一个元素"+li.peekFirst());
//		 E peekLast() 
//          获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。 
		sop("获取第最后一个个元素"+li.peekLast());
//		 E poll() 
//          获取并移除此列表的头（第一个元素） 
			sop("获取并移除第一个元素"+li.poll());
//		 E pollFirst() 
//          获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 
			sop("获取并移除第一个元素"+li.pollFirst());
//		E pollLast() 
//          获取并移除此列表的最后一个元素；如果此列表为空，则返回 null 
			sop("获取并移除最后一个元素"+li.pollLast());
		Iterator it=li.iterator();
		for (;it.hasNext() ; )
		{
			sop(it.next());
		}

	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

Vector的特有方法:
addElement();
elementAt();
elements();
FirstElement();
insertElementAt();
lastElement();
removeElementAt();
removeElement();
removeAllElements();
setElementAt();


ArrayList特点:
1.底层的数据结构是数组结构
2.在查询,修改速度很快,增删稍慢
3.线程是不同步的
4.默认长度是10,超过了50%延长

/*
Vector 特有方法

枚举
*/
import java.util.*;
class Demo4 
{
	public static void main(String[] args) 
	{	
		Vector v=new Vector();
		// void addElement(E obj) 
        //  将指定的组件添加到此向量的末尾，将其大小增加 1。 
		v.addElement("简女神");
		v.addElement("二龙兄");
		v.addElement("许三小朋友");
		//	  E elementAt(int index) 
        //  返回指定索引处的组件。 
		sop(v.elementAt(0));
		//	  E firstElement() 
       //   返回此向量的第一个组件（位于索引 0) 处的项）。 
		sop(v.firstElement());
		//	  void insertElementAt(E obj, int index) 
       //   将指定对象作为此向量中的组件插入到指定的 index 处。 
		v.insertElementAt("第一个",0);
		//	  E lastElement() 
       //   返回此向量的最后一个组件。 
		sop(v.lastElement());
		//	  boolean removeElement(Object obj) 
       //   从此向量中移除变量的第一个（索引最小的）匹配项。 
		sop("移除"+v.removeElement("第一个"));
		//	 void removeElementAt(int index) 
       //   删除指定索引处的组件。
	   v.removeElementAt(1);
		//	 void setElementAt(E obj, int index) 
		// 将此向量指定 index 处的组件设置为指定的对象。
		v.setElementAt("xp",1);

//		Enumeration<E> elements() 
//          返回此向量的组件的枚举。
		Enumeration en=v.elements();

		for (;en.hasMoreElements() ; )
		{
			sop(en.nextElement());
		}
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

LinkedList特点:
1.底层使用的是链表数据结构
2.增删速度很快,查询修改稍慢
3.线程是不同步的


Vector特点:
1.底层使用的是数组数据结构
2.是线程同步的.被ArrayList替代了,增删改查都慢
3.默认长度是10,超过了按100%延长


枚举是Vector的特有取出方式:
发现枚举跟迭代器是很像,其实枚举跟迭代器是一样的,因为没枚举的名称和
方法名称都过长,所以被迭代器取代了

/*
LinkedList 练习
模拟堆栈,队列 

堆栈:先进后出
队列:先进先出
*/
import java.util.*;
class Demo5 
{
	public static void main(String[] args) 
	{
		QueueTest q=new QueueTest();
		q.add("小嘴哥哥");
		q.add("七哥");

		/*先进先出
		while(!q.isEmpty()){
			q.remove_Last();
		} */
		/*先进后出*/
		for (;!q.isEmpty() ; )
		{
			q.remove_First();
		}
	}
}
class QueueTest
{
	private LinkedList li=null;
	public QueueTest(){
		li=new LinkedList();
	}
	/*添加元素*/
	public void add(Object o){
		li.offerFirst(o);
	}
	/*判断是否为空*/
	public boolean isEmpty(){
		return li.isEmpty();
	}
	/*后出*/
	public void remove_Last(){
		sop(li.pollLast());
	}
	/*先出*/
	public void remove_First(){
		sop(li.pollFirst());
	}
	public void sop(Object o){
		System.out.println(o);
	}
}

/*
ArrayList 添加自定义对象

去除重复元素
*/
import java.util.*;
class Demo6 
{
	public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();
		al.add(new Person("你",11));
		al.add(new Person("你",11));
		al.add(new Person("我",12));
		al.add(new Person("他",13));
		al.add(new Person("他",13));
		 al=singleList(al);
		 //)remove 也调用了equals方法
		sop(al.remove(new Person("你",13)));
		Iterator it=al.iterator();

		for (;it.hasNext() ; )
		{
			Person p=(Person)it.next();
			sop(p.getName()+"--"+p.getAge());
		}


	}
	public static void sop(Object o){
		System.out.println(o);
	}
	public static ArrayList singleList(ArrayList all){
		ArrayList al=new ArrayList(); 
		for (int i=0;i<all.size();i++ )
		{
			/*contains会equals方法判断元素*/
			if(!(al.contains(all.get(i))))
				al.add(all.get(i));
		}
		return al;
	}
}
/*人类*/
class Person
{
	private String name;
	private int age;
	public void setName(String name){
	   this.name=name;
	}
	public String getName(){
		  return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	public Person(String name, int age){
		this.name=name;
		this.age=age;
	}
	/*重写equals方法*/
	public boolean equals(Object b){
		if(!(b instanceof Person))
			throw new RuntimeException("传入对象错误 ");
		  //输出看是否调用了
		//System.out.println("dd");
		Person p=(Person)b;
		return (this.name.equals(p.getName())) && (this.age==p.getAge());
	}
	

}

结论:
List中,判断元素是否相同,依据的是元素的equals方法,remove底层也是调用了equals方法


Set结合的功能和collection是一致的
HashSet:底层是哈希表结构 ,线程是不同步的


结论:HashSet是如何保证唯一性呢?
是通过元素的两个方法,HashCode(),equals().如果元素的HashCode值相同,才会判断
equals是否为true,否则不会调用

/*
HashSet 是一句Hashcode 和equals保证集合的唯一性
*/
import java.util.*;
class Demo7 
{
	public static void main(String[] args) 
	{
		/*
		依据的是 HashCode 和 equals保证集合的元素不重复
		*/
		HashSet h=new HashSet();
		h.add(new Person("刘阳文",1));
		h.add(new Person("刘阳",10));
		h.add(new Person("刘文",11));
		h.add(new Person("我",18));
		h.add(new Person("我",18));

		Iterator it=h.iterator();
		for (;it.hasNext() ; )
		{
			Person p=(Person)it.next();
			sop(p.getName()+"--"+p.getAge());
		}
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}
/*人类*/
class Person
{
	private String name;
	private int age;
	public void setName(String name){
	   this.name=name;
	}
	public String getName(){
		  return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	public Person(String name, int age){
		this.name=name;
		this.age=age;
	}
	public int hashCode(){
		return (this.name.hashCode())+this.age*13;
	}
	/*重写equals方法*/
	public boolean equals(Object o){
		if(!(o instanceof Person))
			throw new RuntimeException("类型传入错误");

		//  System.out.println("dddd");
		Person p=(Person)o;
		return this.name.equals(p.getName())&& this.age==p.getAge();
	}
}
	

应该尽量保证HashCode唯一性,可以减少判断次数,增加效率


对于判断元素是否存在,以及删除元素操作,依据的方法是元素的HashCode和equals方法




 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————