总结：集合框架（LinkedList，ArrayList，HashSet）

一，Collection集合的简介：

集合的一些常用方法介绍及两种不同迭代方法的语句

package fighting;

import java.util.ArrayList;
import java.util.Iterator;

public class CollectionDemo {

/**
* 1,集合的add方法的参数类型时Object，以便于接收任意类型的对象。
* 2,集合中存放的不是对象实体，存储的是对象的引用(地址)。
*
* 什么是迭代器？
* 其实就是用于取出集合中的元素。
*/
public static void main(String[] args) {

Base_method();
method_2();
method_get();

}
//获取集合中的元素--迭代器接口Iterator
public static void method_get(){
ArrayList a1 = new ArrayList();
//1，添加元素
a1.add("aaa");
a1.add("bbb");
a1.add("ccc");
a1.add("ddd");

//获取迭代器，用于取出集合中的元素
Iterator it = a1.iterator();
while(it.hasNext()){
System.out.println(it.next());//aaa  bbb  ccc  ddd
}
//for循环更优化：for循环结束，Iterator对象就释放了，而用while循环结束，Iterator对象仍占用内存
for(Iterator it1 = a1.iterator();it1.hasNext();){
System.out.println(it1.next());//aaa  bbb  ccc  ddd
}
}
//retainAll   removeAll
public static void method_2(){

ArrayList a1 = new ArrayList();
//1，添加元素
a1.add("aaa");
a1.add("bbb");
a1.add("ccc");
a1.add("ddd");

ArrayList a2 = new ArrayList();
//1，添加元素
a2.add("aaa");
a2.add("bbb");
a2.add("fff");
a2.add("ddd");
//取a1和a2的交集，存到a1
a1.retainAll(a2);
System.out.println("a1:"+a1);//a1:[aaa, bbb, ddd]
System.out.println("a2:"+a2);//a2:[aaa, bbb, fff, ddd]
//从a1中移除a1和a2的交集
a1.removeAll(a2);
System.out.println("a1:"+a1);//a1:[]  这里a1集合为空了，因为retainAll方法操作后，a1集合只剩下[aaa, bbb, ddd]
System.out.println("a2:"+a2);//a2:[aaa, bbb, fff, ddd]
}

//集合的一些基本方法
public static void Base_method(){
ArrayList a1 = new ArrayList();
//1，添加元素
a1.add("aaa");
a1.add("bbb");
a1.add("ccc");
a1.add("ddd");
a1.add("aaa");
//打印集合
System.out.println("原集合 "+a1);//原集合 [aaa, bbb, ccc, ddd, aaa]
System.out.println(a1.size());//5

//4,判断元素
System.out.println("ccc是否存在："+a1.contains("ccc"));//ccc是否存在：true

//2，删除元素的返回值是boolean类型的，并且移除列表中首次出现的指定元素
a1.remove("aaa");
System.out.println("删除后 "+a1);//删除后 [bbb, ccc, ddd, aaa]
//3，清空集合
a1.clear();
System.out.println("clear "+a1);//clear []
System.out.println("清空后集合是否为空："+a1.isEmpty());//清空后集合是否为空：true

}
}

二，List简介：

ArrayList，LinkedList和Vector的区别。

List增删改查的方法。

Iterator和ListIterator的用法与区别。

package fighting;
import java.util.ArrayList;
import java.util.*;
public class ListDemo {
/**
* Collection
*   |--List：元素是有序的，元素可以重复，因为该集合体系有索引。
*       |--ArrayList：底层的数据结构使用的是数组结构。
*       |             特点：查询速度很快，但是增删较慢。
*       |--LinkedList：底层数据结构使用的是链表数据结构。
*       |              特点：增删速度很快，但查询速度慢
*       |--Vector：底层是数据数据结构。
*                  和ArrayList相似，但是两者有区别：
*                  Vector线程同步，ArrayList线程不同步；
*                  ArrayList初始容量为10，元素个数超过10,再创建一个新的ArrayList对象，长度延长50%，
*                  把原来的元素拷贝到新集合中，再添加元素，
*                  而Vector是100%延长。
*   |--Set：元素是无需的，元素不可以重复。
*
* List：
* 特有方法：凡是可以操作脚标的方法都是该体系特有的方法。
*
* 增：add(index，element)
*     addAll(index,Collection)
* 删：remove(index)
* 改：set(index,element)
* 查：get(index)
*     subList(from，to)
*     listIterator()
*
* 知识点：List集合特有的迭代器：ListIterator是Iterator的子接口。
*        在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生异常java.util.ConcurrentModificationException
*        所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator的方法有限，
*        只能对元素进行盘算，取出，删除的操作，
*        如果想要进行其他的操作如添加、修改等，就需要使用其子接口：ListIterator，
*        ListIterator接口只能通过List集合的listIterator方法获取。
*/
public static void main(String[] args) {
ArrayList a1 = new ArrayList();
//添加元素
a1.add("aaa");
a1.add("bbb");
a1.add("ccc");
a1.add("ddd");
System.out.println(a1);//[aaa, bbb, ccc, ddd]
//1，在指定位置添加元素
a1.add(1,"fff");
System.out.println(a1);//[aaa, fff, bbb, ccc, ddd]
//2,删除指定位置的元素
a1.remove(2);
System.out.println(a1);//[aaa, fff, ccc, ddd]
//3,修改元素
a1.set(3, "hhh");
System.out.println(a1);//[aaa, fff, ccc, hhh]
//4.通过脚标获取元素
System.out.println(a1.get(3));//hhh
//5.使用脚标获取所有元素
for(int x=0;x<a1.size();x++){
System.out.println("a1("+x+")"+a1.get(x));//a1(0)aaa  a1(1)fff  a1(2)ccc  a1(3)hhh
}
//6,使用迭代器获取元素
for(Iterator it = a1.iterator();it.hasNext();){
System.out.println(it.next());//aaa  fff  ccc  hhh
}
//7,通过indexOf获取对象的位置
System.out.println("此时集合中的元素："+a1);//此时集合中的元素：[aaa, fff, ccc, hhh]
System.out.println("通过indexOf获取对象的位置:"+a1.indexOf("ccc"));//通过indexOf获取对象的位置:2
//8.subList，包含开始，不包含结尾
System.out.println("subList:"+a1.subList(0, 2));//subList:[aaa, fff]

//9，列表迭代器，使用普通的iterator迭代器，有一定弊端，不能再迭代的时候进行增改的操作。
/*Iterator it = a1.iterator();
while(it.hasNext()){
Object obj = it.next();
//出现异常java.util.ConcurrentModificationException
//因为迭代器在操作集合，此时程序也要用集合的方法操作集合(a1.add("ooo"))
if(obj.equals("aaa")){
//    a1.add("ooo");
it.remove();
}
System.out.println("列表迭代器："+obj);//此时仍可以打印出aaa，因为
}
System.out.println(a1);
*/
ListIterator li = a1.listIterator();
System.out.println(li.hasPrevious());//false
System.out.println(li.hasNext());//true
while(li.hasNext()){
Object obj = li.next();
if(obj.equals("aaa")){
li.add("ooo");
}
}
System.out.println(li.hasPrevious());//true
System.out.println(li.hasNext());//false
System.out.println("列表迭代器"+a1);//列表迭代器[aaa, ooo, fff, ccc, hhh]
//倒序输出，hasPrevious方法的使用
while(li.hasPrevious()){
System.out.println(li.previous());
}
}
}

三，Vector的使用

package fighting;

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {

/**
* 枚举是Vector特有的取出方式.
* 其实枚举和迭代是一样的，它们是要实现相同的功能需求。
*
* 因为枚举的名称以及方法的名称都过长，所以渐渐被迭代器取代了。
*
*
*/
public static void main(String[] args) {
//小窍门：凡是方法带有element的，都是Vector的特有方法，比如addElement
Vector v=new Vector();
v.add("111");
v.add("222");
v.add("333");
v.add("444");

//枚举是Vector特有的取出方式
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}
}

}

四，LinkList的用法：jdk1.6版本和旧版本的常用方法的比较

package fighting;

import java.util.LinkedList;

public class LinkedListDemo {

/**
* LinkedList特有方法：
* addFirst()-->jdk1.6的offerFirst()
* addLast()-->jdk1.6的offerLast()
*
* getFirst()-->jdk1.6的peekFirst()
* 区别：返回此列表的第一个元素,如果此列表为空，则抛出异常NoSuchElementException
*      peekFirst：获取但不移除此列表的第一个元素；如果此列表为空，则返回 null
* getLast()-->jdk1.6的peekLast()
* 区别：getLast：返回此列表的最后一个元素,如果此列表为空，则抛出异常NoSuchElementException
*      peekLast：获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null
*
* removeFirst()-->jdk1.6的pollFirst
* 区别：removeFirst：
*       pollFirst：获取并移除此列表的第一个元素；如果此列表为空，则返回 null
* removeLast()-->jdk1.6的pollLast
* 区别：removeLast：
*      pollLast：获取并移除此列表的最后一个元素；如果此列表为空，则返回 null
*/
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.addLast("111");
link.addLast("333");
link.addLast("222");
link.addLast("444");

//getFirst只是获取元素，removeFirst不仅获取元素还删除元素
System.out.println(link.getFirst());//111
System.out.println(link);//[111, 333, 222, 444]
System.out.println(link.removeFirst());//111
System.out.println(link);//[333, 222, 444]

//特有迭代
while(!link.isEmpty()){
System.out.println(link.removeFirst());//333  222  444
}

}

}

五，使用LinkedList模拟一个堆栈或者队列数据结构

package fighting;

import java.util.LinkedList;

public class LinkedListDemo2 {

/**
* 使用LinkedList模拟一个堆栈或者队列数据结构
*/
public static void main(String[] args) {

Queue q= new Queue();
q.myAdd("111");
q.myAdd("222");
q.myAdd("333");
q.myAdd("444");
while(!q.isNull()){
System.out.println(q.myGet());
}

Stack s= new Stack();
s.myAdd("111");
s.myAdd("222");
s.myAdd("333");
s.myAdd("444");
while(!s.isNull()){
System.out.println(s.myGet());
}

}

}
//队列：先进先出
class Queue{
private LinkedList link;
Queue(){
link=new LinkedList();
}
//每次都添加到队列末尾
public void myAdd(Object obj){
link.addLast(obj);
}
//每次移除第一个
public Object myGet(){
return link.removeFirst();
}
public boolean isNull(){
return link.isEmpty();
}
}
//堆栈：先进后出
class Stack{
private LinkedList link;
Stack(){
link=new LinkedList();
}
//每次添加到堆栈第一个，先进的就到了堆栈的底部
public void myAdd(Object obj){
link.addFirst(obj);
}
//每次移除第一个
public Object myGet(){
return link.removeFirst();
}
public boolean isNull(){
return link.isEmpty();
}
}

六，一个简单的小例子：去除ArrayList的重复元素

package fighting;

import java.util.ArrayList;

import java.util.Iterator;

public class ArraytListDemo {

/**
* 练习：去除ArrayList的重复元素
*/
public static void main(String[] args) {
ArrayList a1 = new ArrayList();
a1.add("111");
a1.add("111");
a1.add("222");
a1.add("333");
a1.add("333");

a1 = singleElement(a1);
System.out.println(a1);//[111, 222, 333]

}

public static ArrayList singleElement(ArrayList a1){

ArrayList newA1 = new ArrayList();
Iterator it = a1.iterator();
while(it.hasNext()){
Object obj = it.next();
if(!newA1.contains(obj)){
newA1.add(obj);
}
}
return newA1;
}
}

七，ArrayList集合中存储自定义对象，实现去重复

注意：ArrayList的add方法的参数Object类型，Person2对象在传入add方法时，向上转型为Object对象了

所以在用迭代器迭代的时候，it.next()返回的是Object类型，需要强转成Person2类型才可以调用Person2的方法

package fighting;

import java.util.ArrayList;

import java.util.Iterator;

public class ArrayListDemo2 {

/**
* 将自定义对象作为元素存到ArrayList集合中，并去除重复元素
* 比如：存储Person对象，同姓名同年龄视为同一个人，为重复元素
*
* 知识点：List对象判断元素是否相同，依据的是元素的equals方法
*
*/
public static void main(String[] args) {
ArrayList a1 = new ArrayList();
a1.add(new Person2("zhangsan01",10));
a1.add(new Person2("zhangsan02",11));
a1.add(new Person2("zhangsan03",12));
a1.add(new Person2("zhangsan04",13));
a1.add(new Person2("zhangsan03",12));
a1.add(new Person2("zhangsan04",13));

a1 = singleElement(a1);
Iterator it = a1.iterator();

//注意：ArrayList的add方法的参数Object类型，Person2对象在传入add方法时，向上转型为Object对象了
//所以在用迭代器迭代的时候，it.next()返回的是Object类型，需要强转成Person2类型才可以调用Person2的方法。
while(it.hasNext()){
Person2 p = (Person2)it.next();
System.out.println(p.getName()+"..." +p.getAge());
}
//remove方法：在删除以前，要先判断集合中有没有这个对象，也会调用equals方法
System.out.println("remove zhangsan03："+a1.remove(new Person2("zhangsan03",12)));
System.out.println("删除以后的集合元素：");
Iterator it2 = a1.iterator();
while(it2.hasNext()){
Person2 p = (Person2)it2.next();
System.out.println(p.getName()+"..." +p.getAge());
}

}
public static ArrayList singleElement(ArrayList a1){

ArrayList newA1 = new ArrayList();
Iterator it = a1.iterator();
while(it.hasNext()){
Object obj = it.next();
//注意：contains方法底层调用的是对象的equals方法
if(!newA1.contains(obj)){
newA1.add(obj);
}
}
return newA1;
}

}
class Person2{
private String name;
private int age;
Person2(String name,int age){
this.name=name;
this.age=age;
}
@Override
public boolean equals(Object obj){
if(!(obj instanceof Person2)){
return false;
}
Person2 p =(Person2)obj;
//equals方法是对象自动调用的，每次添加对象都要调用这个方法
System.out.println(this.name+"..."+p.name);
if(this.name.equals(p.name)&&this.age==p.age){
return true;
}
return false;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

}

运行结果：

zhangsan02...zhangsan01

zhangsan03...zhangsan01

zhangsan03...zhangsan02

zhangsan04...zhangsan01

zhangsan04...zhangsan02

zhangsan04...zhangsan03

zhangsan03...zhangsan01

zhangsan03...zhangsan02

zhangsan03...zhangsan03 zhangsan03为什么没有和zhangsan04比呢？因为zhangsan03和第二个进来的zhangsan03比较完后，发现是相同的，所以就返回false了。

zhangsan04...zhangsan01

zhangsan04...zhangsan02

zhangsan04...zhangsan03

zhangsan04...zhangsan04 以上是6句添加语句调用equals方法的比较过程。

zhangsan01...10

zhangsan02...11

zhangsan03...12

zhangsan04...13 这是添加完后第一次迭代输出的结果。

zhangsan03...zhangsan01

zhangsan03...zhangsan02

zhangsan03...zhangsan03 这是remove方法调用equals方法的比较过程。

remove zhangsan03：true
这是remove方法返回的结果。

删除以后的集合元素：

zhangsan01...10

zhangsan02...11

zhangsan04...13 这是remove以后的结果，zhangsan03被删除了。

八，HashSet的用法：

HashSet的简单应用。

HashSet存储自定义对象，并去重复。研究HashSet保证元素唯一性的依据。

package fighting;

import java.util.HashSet;

import java.util.Iterator;

public class HashSetDemo {

/**
* Set：元素是无序的(存入和取出的顺序不一定一致)，元素不可以重复
* 	|--HashSet：底层数据结构是哈希表
*             HashSet是如何保证元素唯一性的？
*             是通过元素的两个方法，hashCode和equals方法来完成。
*             如果元素的hashCode值相同，才会判断equals是否为true，
*             如果元素的hashCode值不同，不会调用equals。
*     所以记住：一般开发的时候定义对象，都重写hashCode和equals方法。
*
*     注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
*
*/
public static void main(String[] args) {
//HashSet的简单应用
HashSet hs = new HashSet();
hs.add("111");
//add方法也是有返回值的
System.out.println(hs.add("222"));
System.out.println(hs.add("222"));
hs.add("333");
hs.add("444");

Iterator it = hs.iterator();

while(it.hasNext()){
System.out.println(it.next());
}

//HashSet存储自定义对象，并去重复
HashSet hsObj = new HashSet();
hsObj.add(new Person3("zhangsan01",22));//①
hsObj.add(new Person3("zhangsan02",23));//②
hsObj.add(new Person3("zhangsan02",23));//③
hsObj.add(new Person3("zhangsan03",24));//④
//对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法
System.out.println("contains..."+hsObj.contains(new Person3("zhangsan02",23)));//⑤
System.out.println("contains..."+hsObj.contains(new Person3("zhangsan04",23)));//⑥
hsObj.remove(new Person3("zhangsan01",22));//⑦
Iterator itObj = hsObj.iterator();

while(itObj.hasNext()){
Person3 p = (Person3)itObj.next();
System.out.println(p.getName()+"..."+p.getAge());
}

}

}
class Person3{
private String name;
private int age;
Person3(String name,int age){
this.name=name;
this.age=age;
}
@Override
public int hashCode(){
System.out.println(this.name+"...hashCode");
return name.hashCode()+age*37;
}
@Override
public boolean equals(Object obj){
if(!(obj instanceof Person3)){
return false;
}
Person3 p =(Person3)obj;
//equals方法是对象自动调用的，每次添加对象都要调用这个方法
System.out.println(this.name+"..equals.."+p.name);
if(this.name.equals(p.name)&&this.age==p.age){
return true;
}
return false;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

}

运行结果：

true

false

222

333

111

444 以上是简单应用的输出结果。

zhangsan01...hashCode

zhangsan02...hashCode

zhangsan02...hashCode

zhangsan02..equals..zhangsan02

zhangsan03...hashCode 这是①②③④四条添加语句调用hashCode和equals方法的过程。如果元素的hashCode值相同，还会判断equals是否为true。

zhangsan02...hashCode

zhangsan02..equals..zhangsan02 这是第一条contains语句⑤的比较过程。由于元素的hashCode相同，又进一步调用了equals方法。

contains...true 这是第一条contains语句⑤的返回值

zhangsan04...hashCode

contains...false 这两句是第二条contains语句⑥的比较过程和返回值。由于集合中不存在此元素，所以hashCode不同，不用再调用equals方法。

zhangsan01...hashCode

zhangsan01..equals..zhangsan01 这是remove语句的⑦的比较过程，调用remove方法，要先确定此元素是否在集合中存在，存在才可以remove。

zhangsan02...23

zhangsan03...24 这是调用remove方法后的迭代输出结果