黑马程序员--Java基础之集合类

时间:2023-02-19 15:30:55

 

 

    JAVA 学习第14天,今天学习的内容是集合类,之所以会存在集合类,是因为集合操作的是对象,且它的特点是长度不固定。

import java.util.*;

/*
集合类:概念
由来:方便对""“对象”""的操作,对对象存储,集合是存储对象最常用的一种方式
特点:用于存储对象,集合长度是可变的,集合可以存储不同类型的对象
与数组的区别:
            
    List (ArrayList,LinkedLlist,Vector)
Collection 
    Set  (HashSet,TreeSet)

Collection
 |--List:元素是有序的,元素可以重复,因为该集合体系有索引
  |--ArrayList:  底层的数据结构使用的是数组结构。特点:查询速度快,但是增删慢,线程不同步
  |--LinkList:底层使用的是链表数据结构,特点:增删速度快,查询稍慢
  |--Vector: 底层是数组数据结构。线程同步。被ArrayList替代了


 |--Set: 元素是无序的,元素不可以重复
 |--Set: 元素是无序的(存入和取出的顺序不一定一致),元素不可以重复
   |--HashSet:底层数据结构式哈希表

   HashSet是如何保证元素的唯一性的呢?
   是通过元素的两个方法,hashSet和equals来完成。
   如果元素的hashCode值相同,不会判断equals是否为true
   如果元素的hashSet值不同,才会调用equals
   
   注意:对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals的方法

 |--TreeSet:


为什么会出现这么多的容器呢?
因为每一个容器对数据的存储方式都有不同,这个存储方法称之为:数据结构

1,add方法的参数类型是Object,以便于接收任意类型对象
2,集合中存储的都是对象的引用(地址)

什么是迭代器  //生活实例:电玩城中 大罐子 玩具的取出,夹子
其实就是集合的去除元素的方式。是一个接口

就把取出方式定义在集合的内部。这样取出方式就可以直接访问集合内部的元素

那么取出方式就被定义成了内部类

而每一个容器的数据结构不同
所以取出的动作细节也不一样,但是都有共性内容
判断和取出,那么可以将这些共性抽取

那么这些内部类都符合一个规则,该规则就是Iterator。
如何获取集合的取出对象呢?
通过一个对外提供的方法:
iterator();

*/


class  CollectionDemo
{
 public static void main(String[] args)
 {
  method_get();

 }

 public static void method_get() //方法用于获取集合容器中的元素
 {
  ArrayList al = new ArrayList();

  al.add("java1"); //1,往al容器中添加元素,add(Object obj);
  al.add("java2");
  al.add("java3");
  al.add("java4");

  //al.iterator();  获取迭代器,用于去除集合中的元素
  //Iterator it = al.iterator();
  //it.next();   用于获取迭代器中的元素
  //it.hasNext();    用于判断迭代器中是否还有元素
  /*
  while (it.hasNext())
  {
   
   sop(it.next());
  }*/

  for (Iterator it=al.iterator();it.hasNext() ; )
  {
   sop(it.next());
  }
 }

 public static void method_2()
 {
  ArrayList al1 = new ArrayList();

  al1.add("java1"); 
  al1.add("java2");
  al1.add("java3");
  al1.add("java4");

  ArrayList al2 = new ArrayList();
  
  al2.add("java1"); 
  al2.add("java2");
  al2.add("java5"); 
  al2.add("java6");

  //al1.retainAll(al2); //取交集,al1剩下java1,java2
  al1.removeAll(al2);  //将相同的去除,剩下自己不同的

  sop("al1"+al1);
  sop("al2"+al2);
  
 }

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

  al.add("java1"); //1,往al容器中添加元素,add(Object obj);
  al.add("java2");
  al.add("java3");
  al.add("java4");

  //打印原来集合
  sop("原集合"+al);

  //3,删除元素
  //al.remove("java2");
  //al.clear(); //清空集合

  //4,判断元素
  sop("java3是否存在:"+al.contains("java3"));
  sop("al是否为空:"+al.isEmpty());

  //2,获取al容器的元素,长度
  sop(al.size());
  //打印改变后的集合
  sop("改变后集合"+al);
 
 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
}

 

import java.util.*;
/*
Collection
 |--List:元素是有序的,元素可以重复,因为该集合体系有索引
  |--ArrayList:  底层的数据结构使用的是数组结构。特点:查询速度快,但是增删慢,线程不同步
  |--LinkList:底层使用的是链表数据结构,特点:增删速度快,查询稍慢
  |--Vector: 底层是数组数据结构。线程同步。被ArrayList替代了


 |--Set: 元素是无序的,元素不可以重复
 |--Set: 元素是无序的(存入和取出的顺序不一定一致),元素不可以重复
   |--HashSet:底层数据结构式哈希表
   HashSet是如何保证元素的唯一性的呢?
   是通过元素的两个方法,hashSet和equals来完成。
   如果元素的hashCode值相同,才会判断equals是否为true
   如果元素的hashSet值不同,才会调用equals
   
   注意:对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals的方法

 |--TreeSet:


List集合特有的方法;
 凡是可以操作角标的方法都是该体系特有的方法

 add(index,element); 在指定位子增加元素
 addAll(index,Collect);

 remove(index); 删除指定位子元素

 set(index,element);  将指定位置的元素修改为新的element

 get(index);  查找指定位置的元素
 subList(form,to); 获取集合中的部分内容,包含头,不包含脚
 listIterator();  迭代器


重点:List集合特有的迭代器,ListIterator是Iterator的子接口,

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

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

该接口只能通过List集合的ListIterator方法获取

 

*/

class ListDemo
{
 public static void main(String[] args)
 {
  listiteratorDemo();
 }

 public static void listiteratorDemo()
 {
  ArrayList al = new ArrayList();
  //容器添加元素
  al.add("java01");
  al.add("java02");
  al.add("java03");
  sop("原有元素:"+al);

  ListIterator li = al.listIterator();

  while (li.hasNext())   //正向遍历hasNext()
  {
   Object obj = li.next();
   if (obj.equals("java02"))
    //li.add("java005");
    li.set("java007");

  }
  sop("改变后的元素"+al);

 

  while (li.hasPrevious())   // 反向遍历li.hasPrevious()
  {
   sop("hasPrevious"+(li.hasPrevious()));
  }
  

 

  /*
  Iterator it = al.iterator();
  while(it.hasNext()) //正向遍历,下一个位置有元素
  {
   Object obj =it.next();
   if(obj.equals("java02"))
    al.add("java008"); //出现异常
   sop(obj);
  }
  sop(al);
  */
 }

 

 public static void method_list()
 {
  ArrayList al = new ArrayList();
  //容器添加元素
  al.add("java01");
  al.add("java02");
  al.add("java03");
  al.add("java04");

  sop("原有元素:"+al);
  //在指定位置上添加元素
  al.add(1,"java009");
  // 删除指定位子元素
  al.remove(2);
  //将指定位置的元素修改为新的element
  //al.set(2,"java007");
  //查找指定位置的元素
  //sop("al[1]="+al.get(1));

  //sop("改变后的元素"+al);
  //迭代器
  Iterator it = al.iterator();
  while (it.hasNext())
  {
   sop(it.next());
  }
  //通过indexOf获取对象元素的位置
  sop("java003的位置是:"+al.indexOf("java03"));
  //获取集合中的部分内容,包含头,不包含脚
  List sub = al.subList(1,3);
  sop("1到3的部分元素sub="+sub);
  
 }

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

 

 


/*
需求:使用LinkedList方法,自定义数据结构,队列,堆栈

堆栈:先进后出 如同一个杯子
队列:先进先出 First In First Out  FIFO  如同一个水管


*/
import java.util.*;

class QueueDemo
{
 private LinkedList link;
 QueueDemo()
 {
  link= new LinkedList();
 }

 public void mySet(Object obj)
 {
  
  link.addFirst(obj);
 }
 public Object myGet()
 {
  return link.removeLast();
 }
 public boolean isNull()
 {
  return link.isEmpty();
 }
}

class  LinkedListTest
{
 public static void main(String[] args)
 {
  QueueDemo qu = new QueueDemo();
  qu.mySet("spide01");
  qu.mySet("spide02");
  qu.mySet("spide03");
  qu.mySet("spide04");
  qu.mySet("spide05");
  
  while (!qu.isNull())
  {
   sop(qu.myGet());
  }
  

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

 

 


import java.util.*;
/*
需求:去除ArrayList数组数据中重复的元素

思路:1,首先有这样一个包含重复元素的ArrayList数据集合
   2,有一个新的ArrayList数据类型的newAl数据集合
   3,遍历原来的数据集合中数据元素,如果新的数据集合中没有这个元素,
   就放到新的数据集合中,如果有的话,就丢掉这个数据元素


*/

 

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

 public static void main(String[] args)
 {
  ArrayList al = new ArrayList();
  al.add("spider01");
  al.add("spider02");
  al.add("spider01");
  al.add("spider02");
  al.add("spider01");
  al.add("spider03");
  al.add("spider01");

  sop("原来的数组集合数据"+al);

  al=getSingleArrayList(al);

  sop("改变后的数组集合数据"+al);

 }

 public static ArrayList getSingleArrayList(ArrayList al)
 {
  ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器,用于接收al集合
  
  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   Object obj = it.next();

   if (!newAl.contains(obj)) //判断新集合中是否包含该元素
    newAl.add(obj);
  }
  
  return newAl;
 }
}

 

 

 



/*
需求:使用LinkedList方法,自定义数据结构,队列,堆栈

堆栈:先进后出 如同一个杯子
队列:先进先出 First In First Out  FIFO  如同一个水管


*/
import java.util.*;

class QueueDemo
{
 private LinkedList link;
 QueueDemo()
 {
  link= new LinkedList();
 }

 public void mySet(Object obj)
 {
  
  link.addFirst(obj);
 }
 public Object myGet()
 {
  return link.removeLast();
 }
 public boolean isNull()
 {
  return link.isEmpty();
 }
}

class  LinkedListTest
{
 public static void main(String[] args)
 {
  QueueDemo qu = new QueueDemo();
  qu.mySet("spide01");
  qu.mySet("spide02");
  qu.mySet("spide03");
  qu.mySet("spide04");
  qu.mySet("spide05");
  
  while (!qu.isNull())
  {
   sop(qu.myGet());
  }
  

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

 

 

 


 

 

import java.util.*;
/*
需求:去除ArrayList数组数据中重复的元素

思路:1,首先有这样一个包含重复元素的ArrayList数据集合
   2,有一个新的ArrayList数据类型的newAl数据集合
   3,遍历原来的数据集合中数据元素,如果新的数据集合中没有这个元素,
   就放到新的数据集合中,如果有的话,就丢掉这个数据元素


*/

 

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

 public static void main(String[] args)
 {
  ArrayList al = new ArrayList();
  al.add("spider01");
  al.add("spider02");
  al.add("spider01");
  al.add("spider02");
  al.add("spider01");
  al.add("spider03");
  al.add("spider01");

  sop("原来的数组集合数据"+al);

  al=getSingleArrayList(al);

  sop("改变后的数组集合数据"+al);

 }

 public static ArrayList getSingleArrayList(ArrayList al)
 {
  ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器,用于接收al集合
  
  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   Object obj = it.next();

   if (!newAl.contains(obj)) //判断新集合中是否包含该元素
    newAl.add(obj);
  }
  
  return newAl;
 }
}

 

 


import java.util.*;
/*
将自定义对象作为元素存到ArrayList集合中,并去除重复元素

比如:存人对象,同姓名同年龄,视为同一个人,为重复元素

思路:
1,对人描述,将数据封装进人对象
2,定义容器,将人存入
3,取出


*/
/*
class Person
{
 private String name;
 private int age;
 Person(String name,int age)
 {
  this.name = name;
  this.age = age;
 }
 public int getAge()
 {
  return age;
 }
 public String getName()
 {
  return name;
 }
}

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

 public static void main(String[] args)
 {
  ArrayList al = new ArrayList();

  al.add(new Person("zzh001",23));//object obj = new Person(" ", )
  al.add(new Person("zzh002",24));
  al.add(new Person("zzh003",25));
  al.add(new Person("zzh004",26));
  al.add(new Person("zzh001",23));
  al.add(new Person("zzh002",24));

  al = getSingleElement(al);
  
  Iterator it = al.iterator();
  while (it.hasNext())
  {
   Object obj = it.next();
   Person p = (Person)obj;
   sop(p.getName()+"....."+p.getAge());
   /*
   //程序运行到这一步,打印结果为
   zzh001",23
   zzh002",24
   zzh003",25
   zzh004",26
   zzh001",23
   zzh002",24
   比较后的没有将重复的zzh001和zzh002去除

   是因为contains(obj)比较的是对象的地址,调用时object的equals的方法
   比较的是地址而每个对象都是new出来的,地址都不一样,所以不会取出,
   所以没有比较对象中的姓名和年龄是否相同,
   getSingleElement()函数总(!newAl.contains(obj))返回的都是真(就是不包含,会添加到新的集合中)
   
   解决方法是Person类中重写equals方法,让他判断对象的姓名和年龄


   
  }

  
  

 }

 public static ArrayList getSingleElement(ArrayList al)
 {
  ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器,用于接收al集合
  
  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   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) //复写object的equals的方法,判断年龄、姓名是否相同
 {
  if (!(obj instanceof Person))
   return false;

  Person p = (Person)obj;
  return this.name.equals(p.name) && this.age==p.age;

 }
 public int getAge()
 {
  return age;
 }
 public String getName()
 {
  return name;
 }
}

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

 public static void main(String[] args)
 {
  ArrayList al = new ArrayList();

  al.add(new Person("zzh001",23));//object obj = new Person(" ", )
  al.add(new Person("zzh002",24));
  al.add(new Person("zzh003",25));
  al.add(new Person("zzh004",26));
  al.add(new Person("zzh001",23));
  al.add(new Person("zzh002",24));

  al = getSingleElement(al);
  
  Iterator it = al.iterator();
  while (it.hasNext())
  {
   Object obj = it.next();

   //it.next()迭代器取得的对象元素是Object类型,而要Person方法需要转换成Person类型
   Person p = (Person)obj;  
   sop(p.getName()+"....."+p.getAge());
   
  }
 }

 public static ArrayList getSingleElement(ArrayList al)
 {
  ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器,用于接收al集合
  
  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   Object obj = it.next();

   if (!newAl.contains(obj)) //判断新集合中是否包含该元素
    newAl.add(obj);
  }
  
  return newAl;
 }
}

 

 

import java.util.*;
/*
将自定义对象作为元素存到ArrayList集合中,并去除重复元素

比如:存人对象,同姓名同年龄,视为同一个人,为重复元素

思路:
1,对人描述,将数据封装进人对象
2,定义容器,将人存入
3,取出


*/
/*
class Person
{
 private String name;
 private int age;
 Person(String name,int age)
 {
  this.name = name;
  this.age = age;
 }
 public int getAge()
 {
  return age;
 }
 public String getName()
 {
  return name;
 }
}

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

 public static void main(String[] args)
 {
  ArrayList al = new ArrayList();

  al.add(new Person("zzh001",23));//object obj = new Person(" ", )
  al.add(new Person("zzh002",24));
  al.add(new Person("zzh003",25));
  al.add(new Person("zzh004",26));
  al.add(new Person("zzh001",23));
  al.add(new Person("zzh002",24));

  al = getSingleElement(al);
  
  Iterator it = al.iterator();
  while (it.hasNext())
  {
   Object obj = it.next();
   Person p = (Person)obj;
   sop(p.getName()+"....."+p.getAge());
   /*
   //程序运行到这一步,打印结果为
   zzh001",23
   zzh002",24
   zzh003",25
   zzh004",26
   zzh001",23
   zzh002",24
   比较后的没有将重复的zzh001和zzh002去除

   是因为contains(obj)比较的是对象的地址,调用时object的equals的方法
   比较的是地址而每个对象都是new出来的,地址都不一样,所以不会取出,
   所以没有比较对象中的姓名和年龄是否相同,
   getSingleElement()函数总(!newAl.contains(obj))返回的都是真(就是不包含,会添加到新的集合中)
   
   解决方法是Person类中重写equals方法,让他判断对象的姓名和年龄


   
  }

  
  

 }

 public static ArrayList getSingleElement(ArrayList al)
 {
  ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器,用于接收al集合
  
  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   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) //复写object的equals的方法,判断年龄、姓名是否相同
 {
  if (!(obj instanceof Person))
   return false;

  Person p = (Person)obj;
  return this.name.equals(p.name) && this.age==p.age;

 }
 public int getAge()
 {
  return age;
 }
 public String getName()
 {
  return name;
 }
}

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

 public static void main(String[] args)
 {
  ArrayList al = new ArrayList();

  al.add(new Person("zzh001",23));//object obj = new Person(" ", )
  al.add(new Person("zzh002",24));
  al.add(new Person("zzh003",25));
  al.add(new Person("zzh004",26));
  al.add(new Person("zzh001",23));
  al.add(new Person("zzh002",24));

  al = getSingleElement(al);
  
  Iterator it = al.iterator();
  while (it.hasNext())
  {
   Object obj = it.next();

   //it.next()迭代器取得的对象元素是Object类型,而要Person方法需要转换成Person类型
   Person p = (Person)obj;  
   sop(p.getName()+"....."+p.getAge());
   
  }
 }

 public static ArrayList getSingleElement(ArrayList al)
 {
  ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器,用于接收al集合
  
  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   Object obj = it.next();

   if (!newAl.contains(obj)) //判断新集合中是否包含该元素
    newAl.add(obj);
  }
  
  return newAl;
 }
}

 

 

import java.util.*;
/*
枚举就是Vector特有的取出方式
发现枚举和迭代器很像
其实枚举和迭代是一样的

因为枚举的名称以及方法的名称都过长
所以被迭代器取代了

*/

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

 public static void main(String[] args)
 {
  Vector al = new Vector();
 
  al.add("java01");
  al.add("java02");
  al.add("java03");

  Enumeration en = al.elements();
  while (en.hasMoreElements())
  {
   sop(en.nextElement());
  }
 }
}

 

import java.util.*;
/*
LinkedList 链表结构,使用频率不是很高
特有方法(面试考几率高)
addFirst();
addLast();

//获取元素,但不删除元素
getFirst();  
getLast();

//获取元素,但删除元素
removeFirst(); 
removeLast();

如果集合中没有元素,会出现 NoSuchElementException

JDK1.6版本后出现替代方法

offerFirst();
offerLast()

//获取元素,但不删除元素,如果集合中没有元素,会返回null;
peekFirst();
peekLast();

//获取元素,但删除元素,如果集合中没有元素,会返回null;
pollFirst();
pollLast();


*/


class  LinkedListDemo
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  LinkedList link = new LinkedList();
  link.addFirst("java01");
  link.addFirst("java02");
  link.addFirst("java03");
  link.addFirst("java04");

  sop(link);

  sop(link.getFirst());
  sop(link.getLast());

  link.removeFirst();
  sop("link.size()="+link.size());
  sop(link);

 }
}

 

import java.util.*;

/*
|--Set: 元素是无序的(存入和取出的顺序不一定一致),元素不可以重复
 |--HashSet:底层数据结构式哈希表
   HashSet是如何保证元素的唯一性的呢?
   是通过元素的两个方法,hashSet和equals来完成。
   如果元素的hashCode值相同,才会判断equals是否为true
   如果元素的hashSet值不同,才会调用equals
   
   注意:对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals的方法

 |--TreeSet:

Set集合的功能和Collection是一致的


*/


class  HashSetDemo
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  HashSet hs = new HashSet();

  hs.add("spider001");
  hs.add("spider002");
  hs.add("spider003");
  hs.add("spider004");
  hs.add("spider001");
  hs.add("spider002");
  
  Iterator it = hs.iterator(); //集合要获取元素需要通过迭代器
  while (it.hasNext())
  {
   sop(it.next());
  }

 


 }
}

 

 


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

*/

class Person
{
 private String name;
 private int age;
 Person(String name,int age)
 {
  this.name = name;
  this.age = age;
 }

 public int hashCode()
 {
  System.out.println(this.name+"...hashCode...");
  return name.hashCode()+age*5;
 }
 
 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);
  return this.name.equals(p.name) && this.age==p.age;

 }
 
 public int getAge()
 {
  return age;
 }
 public String getName()
 {
  return name;
 }
}

class  HashSetTest1
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  HashSet hs = new HashSet();
  hs.add(new Person("spider001",23));
  hs.add(new Person("spider002",24));
  hs.add(new Person("spider003",25));
  //hs.add(new Person("spider004",26));
  //hs.add(new Person("spider001",23));
  //hs.add(new Person("spider002",24));

  //sop(hs.contains(new Person("spride002",24)));
  hs.remove(new Person("spider003",25));


  Iterator it = hs.iterator();
  while (it.hasNext())
  {
   Object obj = it.next();
   Person p = (Person)obj;
   sop(p.getName()+"..."+p.getAge());
  }

 }

 public static ArrayList getSingleElement(ArrayList al)
 {
  ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器,用于接收al集合
  
  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   Object obj = it.next();

   if (!newAl.contains(obj)) //判断新集合中是否包含该元素
    newAl.add(obj);
  }
  
  return newAl;
 }
}

 

 

 

 

 

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

*/

class Person
{
 private String name;
 private int age;
 Person(String name,int age)
 {
  this.name = name;
  this.age = age;
 }

 public int hashCode()
 {
  System.out.println(this.name+"...hashCode...");
  return name.hashCode()+age*5;
 }
 
 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);
  return this.name.equals(p.name) && this.age==p.age;

 }
 
 public int getAge()
 {
  return age;
 }
 public String getName()
 {
  return name;
 }
}

class  HashSetTest1
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  HashSet hs = new HashSet();
  hs.add(new Person("spider001",23));
  hs.add(new Person("spider002",24));
  hs.add(new Person("spider003",25));
  //hs.add(new Person("spider004",26));
  //hs.add(new Person("spider001",23));
  //hs.add(new Person("spider002",24));

  //sop(hs.contains(new Person("spride002",24)));
  hs.remove(new Person("spider003",25));


  Iterator it = hs.iterator();
  while (it.hasNext())
  {
   Object obj = it.next();
   Person p = (Person)obj;
   sop(p.getName()+"..."+p.getAge());
  }

 }

 public static ArrayList getSingleElement(ArrayList al)
 {
  ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器,用于接收al集合
  
  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   Object obj = it.next();

   if (!newAl.contains(obj)) //判断新集合中是否包含该元素
    newAl.add(obj);
  }
  
  return newAl;
 }
}