Java基础14：集合类；list集合；迭代器；set集合；

关键字：集合类；list集合；迭代器；set集合；

一、概述

1、为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就是对对象进行存储，集合就是存储对象最常用的一种方式
2、数组和集合类是容器，有何不同？
数组虽然也可以存储对象，但是长度是固定的
集合长度是可变的
数组中可以存储基本数据类型
集合只能存储对象
3、集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象
4、为什么会出现这么多的容器呢？
因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构
5、

Collection
|
|------List：元素是有序的，元素可以重复，因为该集合体系有索引
| |
| |--------ArrayList：底层的数据结构使用的是数组结构，查询速度很快，但是增删稍慢，线程不同步，默认10个元素
| |--------LinkedList：底层使用的链表数据结构，查询很慢，增删速度很快
| |--------Vector：底层是数组数据结构，和ArrayList一样，查询，增删，都很慢，Vector是1.0出现，ArrayList是1.2出现，线程同步，但已经不用了
|
|------Set：元素是无序的，元素不可以重复
|
|--------HashSet
|--------TreeSet
二、集合框架(共性方法)
1、add方法的参数类型是Object，以便于接收任意额类型对象。

2、集合中存储的都是对象的引用(地址)

import java.util.*;
class Demo{
	public static void main(String[] args){
		method_2();
	}
	public static void method_2(){
		ArrayList al1 = new ArrayList();
		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");
		ArrayList al2 = new ArrayList();
		al2.add("java01");
		al2.add("java02");
		al2.add("java05");
		al2.add("java06");
		al1.retainAll(al2);//保留交集   al1中只有  java01 java02
		al1.remove(al2);//去除交集    al1中只有  java01 java02
		sop("al1:"+al1);
		sop("al2:"+al2);
	}
	public static void base_method(){
		//创建一个集合容器，使用Collection接口的子类，ArrayList
		ArrayList al = new ArrayList();
		//1、添加元素。 add(Object obj)
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		//2、获取个数，集合长度    注意：Demo.java 使用了未经检查或不安全的操作。    注意：要了解详细信息，请使用 -Xlint:unchecked 重新编译。
		sop("size："+al.size());
		//打印集合
		sop(al);
		//3、删除元素
		al.remove("java02");
		sop(al);
		//清空
		al.clear();
		4、判断元素
		sop("java03是否存在"+al.contains("java03"));
		sop("集合是否为空"+al.isEmpty());
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

三、集合框架(迭代器)
1、什么是迭代器？其实就是集合的取出元素的方式
2、就把取出方式定义在集合的内部，这样取出方式就可以直接访问结合内容的元素。那么取出方式就定义成了内部类。
3、而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共共性内容：判断，取出。那么可以将写共性取出。
4、那么这些内部类都符合一个规则。该规则是Iterator。如何获取集合的取出对象呢？通过一个对外提供的方法：iterator();

import java.util.*;
class Demo{
	public static void main(String[] args){
		method_get();
	}
	public static void method_get(){
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		//Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素，
		// while(it.hasNext()){
			// sop(it.next());
		// }
		//都这么写
		for(Iterator it = al.iterator();it.hasNext();){
			sop(it.next());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

四、集合框架(List集合共性方法)
1、Collection
|
|----List：元素是有序的，元素可以重复，因为该集合体系有索引
|----Set：元素是无序的，元素不可以重复

2、List：特有方法，凡是可以操作角标的方法都是该体系特有的方法
(1)、增：
add(index,element)
(2)、删：
remove(index)
(3)、改：
set(index,element)
(4)、查：
get(index)
subList()
listIterator()
五、集合框架(ListIterator)
1、list集合特有的迭代器，ListIterator是Iterator的子接口。
2、在迭代时候，不可以通过集合对象的方法操作集合中的元素，因为会发生 ConcurrenModificationException异常。
3、所以在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作
4、如果想要其他的操作，如添加、修改等，就需要使用其子接口，ListIterator。
5、该接口只能通过List集合的listIterator方法获取
6、hasPrevious() ，前面是否有元素
六、集合框架(List集合具体对象的特点)

import java.util.*;
class Demo{
	public static void main(String[] args){
		method_get();
	}
	public static void method_get(){
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		sop("原集合是："+al);
		al.add(1,"java09");
		sop("后："+al);
		//删除
		al.remove(2);
		//修改元素
		al.set(2,"java07");
		//通过角标获取元素
		sop(al.get(1));
		//获取所有元素
		for(int x=0;x<al.size();x++){
			sop("al("+x+") = "+al.get(x));
		}
		for(Iterator it = al.iterator();it.hasNext();){
			sop(it.next());
		}
		//通过 indexOf获取对象的位置
		sop(al.indexOf("java04"));
		sop(al);
		sop(al.subList(1,3));
		ListIterator li = al.listIterator();
		
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

七、集合框架(Vector中的枚举)
1、枚举就是Vector特有的取出方式
2、发现枚举和迭代器很像。
3、其实枚举和迭代是一样的，
4、因为枚举的名称以及方法的名称都过长，所以被迭代器取代了，枚举就郁郁而终了

import java.util.*;
class Demo{
	public static void main(String[] args){
		method_get();
	}
	public static void method_get(){
		Vector v = new Vector();
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");
		Enumeration en = v.elements();
		while(en.hasMoreElements()){
			sop(en.nextElement());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

八、集合框架(LinkedList)
1、LinkedList:特有方法
(1)、addFirst()：
(2)、addLast()：
(3)、getFirst()：
(4)、getLast()：
(5)、removeFirst()：删除并返回元素 ，如果集合中没有有元素，会出现 NoSuchElementExceptionextends RuntimeException 表明枚举中没有更多的元素


peekFirst() 
          获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
(5)、removeLast()
2、1.6中出现了替代方法
boolean offer(E e) 
          将指定元素添加到此列表的末尾（最后一个元素）。 
boolean offerFirst(E e) 
          在此列表的开头插入指定的元素。 
E peekFirst() 
          获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 
E peekLast() 
          获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E pollFirst() 
 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 
E pollLast() 
 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 
九、集合框架(LinkedList练习)

/*
使用LinkedFirst模拟一个堆栈或者队列数据结构
堆栈：先进后出   如同一个罐子
队列：先进先出   如同一个水管
*/
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();
	}
	public boolean isNull(){
		return link.isEmpty();
	}
}
class Demo{
	public static void main(String args[]){
		Duilie dl = new Duilie();
		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");
		while(!dl.isNull()){
			System.out.println(dl.myGet());
		}
	}
}

十、集合框架(ArrayList练习)

/*
使用LinkedFirst模拟一个堆栈或者队列数据结构
堆栈：先进后出   如同一个罐子
队列：先进先出   如同一个水管
*/
import java.util.*;


class Demo{
	public static void main(String args[]){
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java02");
		al.add("java04");
		al = singleElement(al);
		System.out.println(al.toString());
	}
	public static ArrayList singleElement(ArrayList al){
		//定义一个临时容器
		ArrayList newAl = new ArrayList();
		Iterator it = al.iterator();
		//没调用一次next就要hasNext判断下
		while(it.hasNext()){
			Object obj = it.next();
			if(!newAl.contains(obj)){
				newAl.add(obj);
			}
		}
		return newAl;
	}
}

十一、集合框架(ArrayList练习2)

/*
将自定义对象作为元素存到ArrayList集合中，并去除创富元素
比如，存人对象，视为同一个人，为重复元素
思路：
1、对人描述，将数据封装进人对象
2、定义容器，将人进行存入
3、取出


List集合判断是否包含其实是根据这个对象判断是否和内部的对象， equals，可以复写这个equals，写自己的判断


当List remove 删除时候，也是i先equals判断有没有，如果所以要注意
*/
import java.util.*;


public class Demo{
	public static void main(String args[]){
		ArrayList al = new ArrayList();
		al.add(new Person("list01",31));
		al.add(new Person("list02",32));
		al.add(new Person("list02",32));
		al.add(new Person("list03",33));
		al.add(new Person("list04",34));
		al.add(new Person("list04",34));
		al.add(new Person("list05",35));
		al = singleElement(al);
		for(Iterator it = al.iterator();it.hasNext();){
			Person p = (Person)it.next();
			sop(p.getName()+":"+p.getAge());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj.toString());
	}
	public static ArrayList singleElement(ArrayList al){
		//定义一个临时容器
		ArrayList newAl = new ArrayList();
		Iterator it = al.iterator();
		//没调用一次next就要hasNext判断下
		while(it.hasNext()){
			Object obj = it.next();
			if(!newAl.contains(obj)){
				newAl.add(obj);
			}
		}
		return newAl;
	}
}
class Person{
	private String name;
	private int age;
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object obj){
		if(!(obj instanceof Person)){
			return false;
		}
		Person p = (Person)obj;
		return this.name.equals(p.name)&&this.age==p.age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
}

十二、集合框架(HashSet)

/*
Set：元素是无序（存入和取出的顺序不一定一致）的，元素不可以重复
	|---HashSet：底层数据结构是哈希表
		HashSet是如何保证元素的唯一性的呢？
		是通过元素的两个方法，hashCode和equals来完成。
		如果元素的hashCode值相同，才会判断equals是否为true
		如果元素的hashCode值不同，不会调用equals
		
		注意：对于判断元素是否存在，以及删除的操作，以来的方法是元素的 hashCode和equals方法
			先 hashCode 再 equals
			而，arrayList 仅仅是equals
	|---TreeSet：
	
Set集合的功能和Collection是一致的
*/
import java.util.*;


public class Demo{
	public static void main(String args[]){
		HashSet hs = new HashSet();
		hs.add("java01");
		hs.add("java02");
		hs.add("java03");
		sop(hs.add("java04"));
		sop(hs.add("java04"));
		for(Iterator it = hs.iterator();it.hasNext();){
			sop(it.next());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj.toString());
	}
}

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

/*
往hashSet集合中存入自定义对象
姓名和年龄相同为同一人，重复元素
*/
import java.util.*;


public class Demo{
	public static void main(String args[]){
		HashSet hs = new HashSet();
		hs.add(new Person("al",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a4",14));
		for(Iterator it = hs.iterator();it.hasNext();){
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj.toString());
	}
}
class Person{
	private String name;
	private int age;
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object obj){
		Person p = (Person)obj;
		sop(this.name+" -> "+p.name);
		if(!(obj instanceof Person)){
			return false;
		}
		return this.name.equals(p.name)&&this.age==p.age;
	}
	public int hashCode(){
		sop(this.name);
		//两个对象不一样，但是name.hashCode()+this.age;一样，所以最好是name.hashCode()+this.age*；一个数字;比如name.hashCode()+this.age*37
		return this.name.hashCode()+this.age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
	public static void sop(Object obj){
		System.out.println(obj.toString());
	}
}

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

/*
往hashSet集合中存入自定义对象
姓名和年龄相同为同一人，重复元素
*/
import java.util.*;


public class Demo{
	public static void main(String args[]){
		HashSet hs = new HashSet();
		hs.add(new Person("al",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a4",14));
		sop(hs.contains(new Person("a2",12)));
		hs.remove(new Person("a3",13));
		for(Iterator it = hs.iterator();it.hasNext();){
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj.toString());
	}
}
class Person{
	private String name;
	private int age;
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object obj){
		Person p = (Person)obj;
		sop(this.name+" -> "+p.name);
		if(!(obj instanceof Person)){
			return false;
		}
		return this.name.equals(p.name)&&this.age==p.age;
	}
	public int hashCode(){
		sop(this.name);
		//两个对象不一样，但是name.hashCode()+this.age;一样，所以最好是name.hashCode()+this.age*；一个数字;比如name.hashCode()+this.age*37
		return this.name.hashCode()+this.age*37;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
	public static void sop(Object obj){
		System.out.println(obj.toString());
	}
}