Java基础--集合框架<一>

importjava.util.ArrayList;
importjava.util.Iterator;
importjava.util.ListIterator;
publicclassArrayListDemo{
	publicstaticvoidmain(String[]args)
	{
		ArrayListal=newArrayList();//新建一个ArrayList对象
		al.add("张三");	//调用添加方法add添加一条数据
		al.add("李四");
		al.add("王五");		
		al.add("李四");		//ArrayList对象中元素是可以重复的
		
		//al.remove(2);//删除指定索引位的元素并返回被删的元素"李四"。
		
		al.get(1);	//通过索引获取指定元素"张三"
		al.indexOf("张三");//获取指定元素第一次出现的索引位，如果该元素不存在返回-1
		al.lastIndexOf("张三");//反向索引指定元素的位置
		al.subList(0,2);	//获取子列表(角标为0~2：但不包括2)
		
		al.set(0,"老刘");	//对指定索引位进行元素的修改
		
		Iteratorit=al.iterator();//创建迭代器对象
		while(it.hasNext())	//判断：如果存在内容，遍历
		{
			System.out.println(it.next());//打印
		}
		
		//list集合特有的迭代器ListIteratorlistIterator()
		ListIteratoriterator=al.listIterator();//通过调用listIterator()创建迭代器对象
		while(iterator.hasNext())
		{
			Objectobj=iterator.next();
			if(obj.equals("java02"))
			{
				//在迭代时，不可以通过集合对象的方法操作集合中的元素。
				//al.add("java009");×错误用法
				
				//必须通过迭代器操作集合中元素
				iterator.add("老王");				
			}			
		}		
	}
}

importjava.util.*;

publicclassLinkList{
	publicstaticvoidmain(String[]args)
	{
		LinkedListlink=newLinkedList();//创建LinkedList对象
		link.add("java1.0");//向LinkedList对象中添加元素
		link.add("java2.0");
		link.add("java3.0");
		link.add("java3.0");//可以添加相同元素
		sop(link);
		
		link.addFirst("C++");		//将指定元素插入此列表的开头
		link.offerFirst("带头大哥");	//在JDK1.6中的替代方法:在此列表的开头插入指定的元素
		sop(link);

		link.addFirst("addFirst起始");		//将指定元素插入此列表的末尾
		link.offerFirst("offerFirst末尾");		//在JDK1.6中的替代方法:将指定元素插入此列表的末尾
		/*
		link.get(0);	//获得返回此列表中指定位置处的元素
		link.removeFirst();//取出第一个，其他元素删除
		link.removeLast();	//取出第一个，其他元素删除
		*/
		link.peekFirst();//获取但不移除此列表的第一个元素；如果此列表为空，则返回null。
		link.peekLast();//获取元素，但不删除元素。如果集合中没有元素，会返回null。
		link.pollFirst();//获取并移除此列表的第一个元素；如果此列表为空，则返回null。
		link.pollLast();//获取元素，但是元素被删除。如果集合中没有元素，会返回null。

		sop(link);
		sop(link.peekFirst());
		sop(link.size());

//		sop(link.getFirst());
//		sop(link.getLast());
//		while(!link.isEmpty()){
//			sop(link.removeLast());
//		}
//		sop(link.removeFirst());
//		sop(link.removeFirst());
//		sop(link.removeFirst());
//		sop(link.removeFirst());
//		sop(link);
//		sop(link.size());
	}
	publicstaticvoidsop(Objectobj){
		System.out.println(obj);
	}
}

importjava.util.ArrayList;
importjava.util.ListIterator;
importjava.util.*;
/*
List集合特有的迭代器。ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。

所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，
只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

该接口只能通过List集合的listIterator方法获取。
注意：迭代器的next方法返回的是Object类型，所以要记得类型装换
*/
publicclassIterator{
	publicstaticvoidmain(String[]args)
	{
		//演示列表迭代器
		ArrayListal=newArrayList();
		al.add("java01");//add(Objectobj);
		al.add("java02");
		al.add("java03");
		al.add("java04");		
		
		ListIteratorli=al.listIterator();
			
		//list集合特有的迭代器ListIterator
		while(li.hasNext())
		{
			Objectobj=li.next();//迭代器的next方法返回的是Object类型
			if(obj.equals("java02"))
			{//在迭代时，不可以通过集合对象的方法操作集合中的元素。
				//al.add("java009");×错误用法
				
				li.add("替换后的java02");
				
//用指定元素替换next或previous返回的最后一个元素（可选操作）。				
//				li.set("java006");
			}
		}
		
		while(li.hasPrevious())
		{//使用列表迭代器逆向遍历列表，有多个元素
			sop("hasPrevious---"+li.previous());			
		}
		//sop("hasNext---"+li.hasNext());
		//sop("hasPrevious---"+li.hasPrevious());
		
		sop(al);//输出al
		
		/*普通迭代
		//在迭代过程中，准备添加或删除元素
		Iteratorit=al.iterator();
		while(it.hasNext())
		{
			Objectobj=it.next();
			if(obj.equals("java02"))
				//al.add("java08");//当方法检测到对象的并发修改，但不允许这种修改时，抛出异常。
				it.remove();//将"java02"的引用从集合中删除了
			sop("obj="+obj);	
		}
		sop("al="+al);
		*/
	}
	
	publicstaticvoidsop(Objectobj){
		System.out.println(obj);
	}	
}

publicclassHashSetDemo{
	publicstaticvoidsop(Objectobj)
	{
		System.out.println(obj);
	}
	publicstaticvoidmain(String[]args)
	{
		HashSeths=newHashSet();
		sop(hs.add("java03"));
		sop(hs.add("java03"));//无法添加重复false
		hs.add("java01");
		hs.add("java02");
				
		hs.add("java04");
		Iteratorit=hs.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}		
	}
}

importjava.util.HashSet;

/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。

HashSet是如何保证元素唯一性的呢？
			是通过元素的两个方法，hashCode和equals来完成。
			如果元素的HashCode值相同，才会判断equals是否为true。
			如果元素的hashcode值不同，不会调用equals。

*/

classPerson2
{
	privateintage;
	privateStringname;
	publicPerson2(Stringname,intage)
	{
		this.name=name;
		this.age=age;
	}
	publicStringgetName()
	{
		returnname;
	}
	publicintgetAge()
	{
		returnage;
	}	
	
	publicinthashCode()
	{//覆盖父类中的hashCode方法
		System.out.println(this.name+"...hashCode");
//		return60;
		returnname.hashCode()+age*11;//避免重复
	}
	
	//覆盖父类中的equals方法
	publicbooleanequals(Objectobj)
	{
		if(!(objinstanceofPerson2))
			returnfalse;		
		Person2p=(Person2)obj;	
		
		System.out.println(this.name+"--equals--"+p.name);
		returnthis.name.equals(p.name)&&this.age==p.age;
	}
}
publicclassHashsetTest{
	publicstaticvoidsop(Objectobj)
	{
		System.out.println(obj);
	}
	publicstaticvoidmain(String[]args)
	{
		HashSeths=newHashSet();
		hs.add(newPerson2("a1",11));
		hs.add(newPerson2("a2",12));
		hs.add(newPerson2("a3",22));
//		hs.add(newPerson2("a2",12));
//		hs.add(newPerson2("a3",22));
		
		//sop("a1:"+hs.contains(newPerson2("a1",11)));
		
		sop(hs.remove(newPerson2("a2",12)));
		
//		Iteratorit2=hs.iterator();
//		while(it2.hasNext())
//		{
//			Person2p=(Person2)it2.next();
//			sop(p.getName()+"-"+p.getAge());
//		}		
	}
}

importjava.util.*;
/*
当元素自身不具备比较性，或者具备的比较性不是所需要的。
这时需要让容器自身具备比较性。
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时，以比较器为主。

定义一个类，实现Comparator接口，覆盖compare方法。

*/
classStudent2implementsComparable//该接口强制让学生具备比较性
{
	privateStringname;
	privateintage;
	Student2(Stringname,intage)
	{
		this.name=name;
		this.age=age;
	}
	publicStringgetName(){
		returnname;
	}
	publicintgetAge(){
		returnage;
	}
	
	@Override
	publicintcompareTo(Objecto)
	{
		//返回负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。
		
		if(!(oinstanceofStudent2))
			thrownewRuntimeException("不是学生对象");
		Student2s=(Student2)o;
		System.out.println(this.name+"..compare.."+s.name);
		
		if(this.age>s.age)
			return1;
		if(this.age==s.age)
		{
			returnthis.name.compareTo(s.name);
		}			
		return-1;
	}	
}

publicclassTreeSetDemo2{
	publicstaticvoidsop(Objectobj)
	{
		System.out.println(obj);
	}
	publicstaticvoidmain(String[]args)
	{
		TreeSetts=newTreeSet();//接收了一个接口子对象
		//必须具备比较性
		ts.add(newStudent2("lisi01",22));
		ts.add(newStudent2("lisi02",21));
		ts.add(newStudent2("lisi97",19));
		ts.add(newStudent2("lisi97",17));
		ts.add(newStudent2("lisi03",20));
		
		Iteratorit=ts.iterator();
		while(it.hasNext())
		{
			Student2s=(Student2)it.next();
			sop(s.getName()+"---"+s.getAge());
		}
	}
}

//定义比较器，实现Comparator接口，覆盖compare方法。
classMyCompareimplementsComparator
{
	@Override
	publicintcompare(Objecto1,Objecto2)
	{
		Student2s1=(Student2)o1;
		Student2s2=(Student2)o2;
		intnum=s1.getName().compareTo(s2.getName());
		if(num==0)
		{	
			newInteger(s1.getAge()).compareTo(newInteger(s2.getAge()));
			/*
			if(s1.getAge()>s2.getAge())
				return1;
			if(s1.getAge()<s2.getAge())
				return-1;
			return0;
			*/
		}
		returnnum;
	}	
}