java笔记-集合框架-集合基础

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

数组和集合类的不同：

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

集合类的特点：

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

为什么会出现很多容器？每个容器对数据的存储方式都有不同，该存储方式称为数据结构。

Collection中的方法：

add方法的参数是Object，以便于接收任意类型的对象。

集合中存储的都是对象的引用（地址）

什么是迭代器？

就是集合中取出元素的方法。

java中集合类的关系图

集合中添加元素

/*
** Collection add()方法。
*/
import java.util.*;
class CollectionDemo{
	public static void main(String[] args){
		ArrayList al=new ArrayList();
		//向集合中添加元素。
		al.add("java 001");
		al.add("java 002");
		al.add("java 003");
		al.add("java 004");
		al.add("java 005");
		//it对象在使用完毕即销毁。
		for(Iterator it=al.iterator();it.hasNext();){
			sop(it.next());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

集合中数据操作

/*
** Collection 方法。
** List:容器中的元素是有序的，可以重复，元素有索引。
** Set：容器中元素是无序的，不可以重复。

** List特有的方法：凡是可以操作角标的方法都是该体系特有的方法。
** 增加：add(index,element);
		 addAll(index,collection);
** 删除：remove(index);
** 修改：set(index,element);
** 查找：get(index);
		 subList(from,to);
		 listIterator();
** 获取集合长度：size();
** List 集合特有的迭代器：ListIterator。其是Iterator的子接口。
** 在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生并发异常，即：迭代方法和集合对象方法同时操作集合中的元素。
** 在迭代时，只能通过迭代的方法操作元素，但操作有限，需用ListIterator子接口方法操作元素。
** 该接口只能通过List的listIterator方法获取。
*/
import java.util.*;
class ListDemo{
	public static void main(String[] args){
		ArrayList al=new ArrayList();
		al.add("java 001");
		al.add("java 002");
		al.add("java 003");
		al.add("java 004");
		al.add("java 005");
		//it对象在使用完毕即销毁。
		for(Iterator it=al.iterator();it.hasNext();){
			sop(it.next());
		}
		sop("删除指定位置(角标3)的元素");
		al.remove(3);
		sop(al);
		sop("修改指定位置(角标1)的元素");
		al.set(1,"java 007");
		sop(al);
		sop("查找指定位置(角标1)的元素");
		sop(al.get(1));
		sop("获取集合中的所有元素");
		sop(al.subList(0,al.size()));
		sop("获取集合中的所有元素，方法二：");
		Iterator it=al.iterator();
		while(it.hasNext()){
			sop(it.next());
		}
		//获得指定对象(java 007)的位置：
		sop(al.indexOf("java 007"));
		//返回列表中最后一次出现指定元素(java 007)的位置。
		sop(al.lastIndexOf("java 007"));
		sop("通过ListIterator 子接口操作集合中的元素");
		ListIterator li=al.listIterator();
		while(li.hasNext()){
			Object obj =li.next();
			if(obj.equals("java 007")){
				li.remove();	//此处已经删除了，为什么还能打印出来。
								//此处删除的是集合元素的引用，在此之前已将该引用值赋给了obj，下方打印的是obj的值。
				li.add("java 009");
				//li.set("java 0010");
			}	
			sop(obj);
		}
		sop("删除jva 007的元素。增加java 009的元素");
		sop(al);
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

模拟队列的先进先出和堆栈的先进后出特性

// 模拟队列和堆栈的先进先出和先进后出的过程。
import java.util.*;
class DuiLie
{
	private LinkedList link;
	DuiLie(){
		link=new LinkedList();
	}
	public void myAdd(Object obj){
		link.addFirst(obj);
	}
	//输出最下层的元素。
	//removeLast(),删除并返回此列表中的第一个元素。
	//若使用getLast(),则只能得到列表中的最后一个元素。必须删除，后续的才能下降为最后一个元素
	public Object myGet(){
		return link.removeLast();
	}
	public boolean isNull(){
		return link.isEmpty();
	}
}
class DuiZhan
{
	private LinkedList dz;
	DuiZhan(){
		dz=new LinkedList();
	}
	public void myAdd(Object obj){
		//率先加入的垫底。
		dz.addFirst(obj);
	}
	public Object myGet(){
		//输出最上层的元素。
		//removeFirst(),删除并返回此列表中的第一个元素。
		//若使用getFirst(),则只能得到列表中的第一个元素。必须删除，后续的才能上升为第一个元素。
		return dz.removeFirst();
	}
	public boolean isNull(){
		return dz.isEmpty();
	}
}
class  LinkedListTest
{
	public static void main(String[] args) 
	{
		DuiLie dl=new DuiLie();
		DuiZhan dz=new DuiZhan();
		//增加队列元素。
		dl.myAdd("java 001");
		dl.myAdd("java 002");
		dl.myAdd("java 003");
		dl.myAdd("java 004");
		sop("队列的先进先出特性");
		while(!dl.isNull()){
			sop(dl.myGet());
		}
		//增加堆栈元素。
		dz.myAdd("DuiZhan 001");
		dz.myAdd("DuiZhan 002");
		dz.myAdd("DuiZhan 003");
		dz.myAdd("DuiZhan 004");
		sop("堆栈的先进后出特性");
		while(!dz.isNull()){
			sop(dz.myGet());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

HashSet类型

/*
 Set:元素是无序的（存入和取出的数序不一定一致），元素不可以重复。
	|---HashSet：底层数据结构是哈希表。
		HashSet是如何保证元素的唯一性？
		通过元素的两个方法：hashCode和equals来完成。
		如果元素的hashCode值相同，才会判断equals是否为true。
		如果元素的hashCode值不同，不会调用equals.

		注意，对于判断元素是否存在(contains),删除(remove)等，依赖的方法是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 this.name;
	}
	public int getAge(){
		return this.age;
	}
	//重写字符串的哈希值。构建姓名+年龄的哈希值。
	public int hashCode(){
		return name.hashCode()+age;
	}
	//重写equals方法。
	public boolean equals(Object obj){
		//首先判断是否为Person类型，如果不是，直接pass
		if(!(obj instanceof Person)){
			return false;
		}
		//强制类型转换。先转换为Person类型。
		Person p=(Person)obj;
		//姓名年龄均相同为同一个人。
		return this.name.equals(p.name)&&(this.age==p.age);
	}
}
class  HashSetDemo
{

	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();
		hs.add(new Person("hash 001",1));
		hs.add(new Person("hash 002",2));
		hs.add(new Person("hash 003",3));
		hs.add(new Person("hash 004",4));
		hs.add(new Person("hash 005",5));
		hs.add(new Person("hash 004",4));
		//使用iterator方法构建迭代器。
		Iterator it=hs.iterator();
		while(it.hasNext()){
			Person p=(Person)it.next();
			sop(p.getName()+"..."+p.getAge());
		}

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