Java基础_集合框架1

一、集合框架(体系概述)

为什么会出现集合框架（集合类）？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合框架是容器，有何不同？

数组虽然也可以存储对象，但长度是固定的；集合长度可变。数组中可以存储基本数据类型，集合只能存储对象。

集合框架的特点：

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

 

为什么会出现这么多容器呢？

因为每一个容器对数据的存储方式不同。这个存储方式称之为：数据结构。

二、集合框架(共性方法)

/*

集合框架(共性方法)：

1.add方法的参数类型是Object，以便接受任意类型的对象
2.集合中存储的都是对象的引用（地址）。

*/
import java.util.*;
class CollectionDemo 
{
	public static void main(String[] args) 
	{
		base_method();
		base_method_2();	
	}

	public static void base_method()
	{
		//创建一个集合容器。使用Collection接口的子类ArrayList
		ArrayList a1=new ArrayList();

		a1.add("java01");//添加元素   add(Object obj);
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");

		sop("原集合："+a1);//打印
		sop("java03是否存在："+a1.contains("java03"));
		sop("集合是否为空？ "+a1.isEmpty());
		sop("size:"+a1.size());//获取集合长度。
		a1.remove("java02");//移除java02
		sop("删除java02后的集合："+a1);//打印
		a1.clear();//清空集合
		sop("清空后的集合："+a1);//打印

	}
	public static void base_method_2()
	{
		
		ArrayList a1=new ArrayList();

		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");

		ArrayList a2=new ArrayList();

		a2.add("java01");
		a2.add("java02");
		a2.add("java05");
		a2.add("java06");

		a1.retainAll(a2);//a1中存放和a2的交集
		sop("a1:"+a1);
		sop("a2:"+a2);

		a1.removeAll(a2);//移除a1中a2存在的所有元素
		sop("a1:"+a1);
		sop("a2:"+a2);

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

三、集合框架(迭代器)

迭代器：集合的取出元素的方式。

/*
迭代器：
集合的取出元素的方式。
*/
import java.util.*;
class CollectionDemo 
{
	public static void main(String[] args) 
	{
		method_get();
	}
	public static void method_get()
	{
		ArrayList a1=new ArrayList();

		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");

		/*
		Iterator it=a1.iterator();//获取迭代器，用于取出集合中的元素。
		while(it.hasNext())
		{
			sop(it.next());
		}
		*/

		for(Iterator it=a1.iterator();it.hasNext();)//及时释放Iterator
		{
			sop(it.next());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

四、集合框架(List集合共性方法)

/*
Collection
	|--List:元素是有序的，同时元素可以重复，因为该集合体系有索引。
	|--Set:元素是无序的，元素不可重复，因为该集合体系有没有索引。

List:
特有方法。凡是可以操作角标的方法都是该体系特有的方法：
增：
	add(index,element); 
	addAll(index,element);
删：
	remove(index);
改：
	set(intdex,element);
查：
	get(intdex);
	subList(from,to);
	ListIterator();

*/
import java.util.*;
class ListDemo 
{
	public static void main(String[] args) 
	{
		ArrayList a1=new ArrayList();

		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");

		sop("原集合："+a1);
		a1.add(1,"java09");//在指定位置添加
		sop(a1);

		a1.remove(2);
		sop(a1);

		a1.set(2,"java007");//在指定位置修改
		sop(a1);

		sop("get{2}:"+a1.get(2));//在指定位置获取

		for(int i=0;i<a1.size();i++)//获取全部
		{
			System.out.println("a["+i+"]="+a1.get(i));
		}

		Iterator it=a1.iterator();

		while(it.hasNext())//用迭代器
		{
			sop("next:"+it.next());
		}

		//通过indexOf获取对象的位置
		sop("index:"+a1.indexOf("java02"));

		List sub=a1.subList(1,3);
		sop("sub:"+sub);

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

五、集合框架(ListIterator)

/*
Collection
	|--List:元素是有序的，同时元素可以重复，因为该集合体系有索引。
	|--Set:元素是无序的，元素不可重复，因为该集合体系有没有索引。

List:
特有的迭代器。ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生
java.util.ConcurrentModificationException异常。
所以在迭代器时，只能用迭代其的方法操作元素，可是Iterator方法是有限的。
如果想要其它的操作如：添加，修改等，就需要使用其自接口ListIterator。
该接口只能通过List集合的listIterator方法获取。

*/
import java.util.*;
class ListDemo 
{
	public static void main(String[] args) 
	{
		//演示列表迭代器
		ArrayList a1=new ArrayList();

		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");
		
		sop(a1);
		
		ListIterator li=a1.listIterator();
		while(li.hasNext())
		{
			Object obj=li.next();
			if(obj.equals("java02"))
				li.add("java009");
		}
		sop("hasNext():"+li.hasNext());
		sop("hasPrevious():"+li.hasPrevious());
		sop(a1);

		/*

		//在迭代过程中准备添加或删除元素
		Iterator it=a1.iterator();

		while(it.hasNext())//用迭代器
		{
			Object obj=it.next();
			if(obj.equals("java02"))
				//a1.add("java008");
				it.remove();//将java02的引用从集合中移除
			sop("obj="+obj);
		}
		sop(a1);

		*/

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

六、集合框架(List集合具体对象的特点)

Collection

|--List:元素是有序的，同时元素可以重复，因为该集合体系有索引。

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

|--LinkedList:底层的数据结构使用链表。特点：增删速度很快，查询稍慢。

|--Vector:底层是数组数据结构。线程同步。被ArrayList替代。

七、集合框架(Vector中的枚举)

/*
Vector特有取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的，为什么出现迭代呢？
因为枚举的名称以及方法的名称都过长，所以被迭代器取代了，枚举郁郁而终了。
*/
import java.util.*;
class VectorDemo 
{
	public static void main(String[] args) 
	{
		Vector v=new Vector();

		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");

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

八、集合框架(LinkedList)

/*
LinkedList特有方法：
addFirst():
addLast():
添加元素

getFirst():
getLast():
获取元素，但不删除元素

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

所以在JDK1.6出现了替代方法：
offerFirst()
offerLast()
添加元素

peekFirst()
peekLast()
获取元素，但不删除元素。如果集合中没有元素，会出返回null

pollFirst()
pollLast()
获取元素，删除元素。如果集合中没有元素，会出返回null

*/
import java.util.*;
class LinkedListDemo 
{
	public static void main(String[] args) 
	{
		LinkedList link1=new LinkedList();

		link1.addFirst("java01");
		link1.addFirst("java02");
		link1.addFirst("java03");
		link1.addFirst("java04");

		sop("link1="+link1);

		LinkedList link2=new LinkedList();

		link2.addLast("java01");
		link2.addLast("java02");
		link2.addLast("java03");
		link2.addLast("java04");

		sop("link2="+link2);

		sop(link2.getFirst());
		sop(link2.getLast());
		sop("size="+link2.size());

		sop(link2.removeFirst());//如果列表为空，会抛出null异常
		sop(link2.removeLast());
		sop("size="+link2.size());

		while(!link2.isEmpty())//全部获取
		{
			sop(link2.removeFirst());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

九、集合框架(LinkedList练习)

/*
使用LinkedList模拟一个堆栈或队列的数据结构。
堆栈：先进后出。
队列：先进先出。
*/
import java.util.*;
class DuiLie//队列
{
	private LinkedList link;
	DuiLie()
	{
		link=new LinkedList();
	}
	public void myAdd(Object obj)
	{
		link.addFirst(obj);
	}
	public Object myGet()
	{
		return link.removeLast();//堆栈：return link.removeFirst();
	}
	public boolean isNull()
	{
		return link.isEmpty();
	}
}
class LinkedListTest 
{
	public static void main(String[] args) 
	{
		DuiLie d1=new DuiLie();
		d1.myAdd("java01");
		d1.myAdd("java02");
		d1.myAdd("java03");
		d1.myAdd("java04");

		while(!d1.isNull())
		{
			System.out.println(d1.myGet());
		}
	}
}

十、集合框架(ArrayList练习)

/*
去除ArrayList集合中重复的元素。
*/
import java.util.*;
class ArrayListTest 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		ArrayList a1=new ArrayList();

		a1.add("java01");
		a1.add("java01");
		a1.add("java03");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");
		a1.add("java04");
		a1.add("java04");

		sop("原数据："+a1);

		sop("去除重复元素："+singleElement(a1));
	}
	public static ArrayList singleElement(ArrayList a1)
	{
		//定义一个临时容器
		ArrayList a2=new ArrayList();

		Iterator it=a1.iterator();

		while(it.hasNext())//next()调用一次，就hasNext()判断一次。
		{
			Object obj=it.next();
			if(!a2.contains(obj))
				a2.add(obj);
		}

		return a2;
	}
}

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同龄人，视为同一个人。为重复元素。

思路：
1.对人描述，将数据封装成人对象。
2.定义容器，将人存入。
3.取出。


结论：List集合判断元素是否相同，依据的是元素的equals方法。
*/
import java.util.*;
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public boolean equals(Object obj)//重写Object类的equals方法
	{
		if(!(obj instanceof Person))
			return false;
		Person p=(Person)obj;
		
		System.out.println(this.name+"..........."+p.name);//测试contains调用equals

		return this.name.equals(p.name)&&this.age==p.age;
	}
}
class ArrayListTest2 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		ArrayList a1=new ArrayList();
		a1.add(new Person("lisi01",30));
		a1.add(new Person("lisi02",32));
		a1.add(new Person("lisi03",33));
		a1.add(new Person("lisi04",34));
		a1.add(new Person("lisi01",30));
		a1.add(new Person("lisi02",32));
		a1.add(new Person("lisi03",33));
		a1.add(new Person("lisi04",34));

		a1=singleElement(a1);//去除重复

		Iterator it=a1.iterator();
		
		while(it.hasNext())
		{
			Person p=(Person)it.next();
			sop("姓名："+p.getName()+"\t年龄："+p.getAge());
		}
	}
	public static ArrayList singleElement(ArrayList a1)
	{
		//定义一个临时容器
		ArrayList a2=new ArrayList();

		Iterator it=a1.iterator();

		while(it.hasNext())//next()调用一次，就hasNext()判断一次。
		{
			Object obj=it.next();
			if(!a2.contains(obj))//底层调用equals()方法
				a2.add(obj);
		}

		return a2;
	}


}

十一、集合框架(HashSet)

/*
|--Set:元素是无序的，元素不可重复，因为该集合体系有没有索引。
	|--HashSet:底层数据结构是哈希表。
	|--TreeSet:

Set集合的功能和Collection是一致的。
*/
import java.util.*;
class HashSetDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();
		sop(hs.add("java01"));
		sop(hs.add("java01"));
		hs.add("java02");
		hs.add("java03");
		hs.add("java03");
		hs.add("java04");

		Iterator it=hs.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
}

十二、集合框架(HashSet存储自定义对象)

/*
给hashSet集合中存入自定义对象。
比如：存人对象。同姓名同龄人，视为同一个人。为重复元素。

HashSet是如何保证元素唯一性的呢？
那是通过元素的两个方法：hashCode和equals来完成的
如果元素的hashCode值相同，才会判断equals是否为true。
如果元素的hashCode值不相同，不会调用equals
*/
import java.util.*;
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public int hashCode()//重写Object类的hashCode方法
	{
		System.out.println(this.name+"....hashCode");
		return 60;
	}
	public boolean equals(Object obj)//重写Object类的equals方法
	{
		if(!(obj instanceof Person))
			return false;
		Person p=(Person)obj;
		
		System.out.println(this.name+".....equals....."+p.name);//测试contains调用equals

		return this.name.equals(p.name)&&this.age==p.age;
	}
}
class HashSetDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();
		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a2",12));

		Iterator it=hs.iterator();

		while(it.hasNext())
		{
			Person p=(Person)it.next();
			sop("姓名："+p.getName()+"\t年龄："+p.getAge());
		}
	}
}

 

hashCode改进后：

public int hashCode()//重写Object类的hashCode方法
{
		System.out.println(this.name+"....hashCode");
		return this.name.hashCode()+age*13;//age*13是确保唯一性。
}

 

十三、集合框架(HashSet判断和删除的依据)

/*
注意，对于判断元素是否存在以及删除等操作，依赖元素的
hashCode和equals方法。
*/
import java.util.*;
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public int hashCode()//重写Object类的hashCode方法
	{
		System.out.println(this.name+"....hashCode");
		return this.name.hashCode()+age*13;
	}
	public boolean equals(Object obj)//重写Object类的equals方法
	{
		if(!(obj instanceof Person))
			return false;
		Person p=(Person)obj;
		
		System.out.println(this.name+".....equals....."+p.name);//测试contains调用equals

		return this.name.equals(p.name)&&this.age==p.age;
	}
}
class HashSetDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();
		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a2",12));
		
		hs.remove(new Person("a3",13));//删除元素
		sop("a1:"+hs.contains(new Person("a1",11)));//获取元素是否存在
		Iterator it=hs.iterator();

		while(it.hasNext())
		{
			Person p=(Person)it.next();
			sop("姓名："+p.getName()+"\t年龄："+p.getAge());
		}
	}
}