标签：黑马程序员
------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
黑马程序员——16，集合
/*
集合类：用来装对象的容器，任何对象都可以装进去，没有固定长度，功能和数组类似
集合框架：装东西的容器不断向上抽取共有部分然后形成的体系
最上面的是Collection接口
为什么会有这么多容器？因为每种容器对数据的存储方式不同（数据结构）
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Jihe
{
public static void main(String[]args)
{
ArrayList a=new ArrayList();
//ArrayList是Collection接口的子类
a.add("jdk01");
a.add("jdk02");
a.add("jdk03");
a.add("jdk04");
a.add("jdk05");
/*
这里的添加本质上在内存上都是把对象的地址值放在了容器里面，
这样容器就可以访问对象了，
而不是真的把对象整个放进容器，
仅仅是说法上是放进容器里面而已。
如果就这样编译的话会有注意提示，这个不是编译错误，暂时不需要理会
*/
soc("a原本的长度="+a.size());//size获取长度
soc(a);//直接打印集合是可以的
a.remove("jdk02");
soc("remove掉jdk02后的a="+a);
soc("remove掉的a的长度="+a.size());
//a.clean();//清空容器内部
soc("a.isEmpty()="+a.isEmpty());
soc("a.contains(\"jdk03\")="+a.contains("jdk03"));
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
上面代码编译运行结果：
a原本的长度=5
[jdk01, jdk02, jdk03, jdk04, jdk05]
remove掉jdk02后的a=[jdk01, jdk03,jdk04, jdk05]
remove掉的a的长度=4
a.isEmpty()=false
a.contains("jdk03")=true
*/——————分割线——————
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Jihe2
{
public static void main(String[]args)
{
ArrayList a=new ArrayList();
//ArrayList是Collection接口的子类
a.add("jdk01");
a.add("jdk02");
a.add("jdk03");
a.add("jdk04");
a.add("jdk05");
ArrayList a2=new ArrayList();
a2.add("jdk01");
a2.add("jdk02");
a2.add("yu03");
a2.add("yu04");
a2.add("yu05");
soc("a="+a);
soc("a2="+a2);
//a.retainAll(a2);//把a与a2的交集元素返回到a中
// soc("a.retainAll(a2)="+a);
a.removeAll(a2);//把a当中a与a2交集元素去掉，然后再返回
soc("a.removeAll(a2)="+a);
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
a=[jdk01, jdk02, jdk03, jdk04, jdk05]
a2=[jdk01, jdk02, yu03, yu04, yu05]
a.removeAll(a2)=[jdk03, jdk04, jdk05]
*/————————分割线——————
/*
由于不同的容器有不同的取出元素方式，所以就有迭代器
迭代器：取出元素的方式
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Jihe3
{
public static void main(String[] args)
{
ArrayList a=new ArrayList();
//ArrayList是Collection接口的子类
a.add("jdk01");
a.add("jdk02");
a.add("jdk03");
a.add("jdk04");
a.add("jdk05");
Iterator it=a.iterator();//建立迭代器（取出方式的对象）
while(it.hasNext())//判断是否还有下一个元素
{
soc(it.next());
}
soc(a);
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
jdk01
jdk02
jdk03
jdk04
jdk05
[jdk01, jdk02, jdk03, jdk04, jdk05]
*/————————分割线——————
/*
Collection下面有两个常用的子接口
List和Set
List中的元素有序排列，元素可以重复，该集合体系有索引
Set中的元素无序排列，元素不可以重复，该集合体系没有索引
List:凡是可以操作角标的方法都是该体系的特有方法
增---add(index,element);
addAll(index,Collection);
减---remove(index);
改---set(index,element);
查---get(index);
subList(from,to);
listIterator();
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
Class Jihe4
{
Public static void main(String[] args)
{
ArrayList a=new ArrayList();
//ArrayList是List接口的子类
a.add("jdk01");
a.add("jdk02");
a.add("jdk03");
a.add("jdk04");
a.add("jdk05");
ArrayList b=new ArrayList();
b.add("yu01");
b.add("yu02");
b.add("yu03");
b.add("yu04");
b.add("yu05");
soc("a---"+a);
soc("b---"+b);
a.add(2,"jdk06");
soc("a.add(2,\"jdk06\")---"+a);
a.addAll(3,b);
soc("a.addAll(3,b)---"+a);
a.remove(0);
soc("a.remove(0)---"+a);
a.set(4,"ooooo");
soc("a.set(4,\"ooooo\")---"+a);
a.get(6);
soc("a.get(6)---"+a);
a.subList(0,4);
soc("a.subList(0,4)---"+a);
soc("改变之后的a---"+a);
Iterator it= a.listIterator();
while(it.hasNext())
{
soc(it.next());
}
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
a---[jdk01, jdk02, jdk03, jdk04, jdk05]
b---[yu01, yu02, yu03, yu04, yu05]
a.add(2,"jdk06")---[jdk01, jdk02,jdk06, jdk03, jdk04, jdk05]
a.addAll(3,b)---[jdk01, jdk02, jdk06, yu01,yu02, yu03, yu04, yu05, jdk03, jdk04, jdk05]
a.remove(0)---[jdk02, jdk06, yu01, yu02,yu03, yu04, yu05, jdk03, jdk04, jdk05]
a.set(4,"ooooo")---[jdk02, jdk06,yu01, yu02, ooooo, yu04, yu05, jdk03, jdk04, jdk05]
a.get(6)---[jdk02, jdk06, yu01, yu02,ooooo, yu04, yu05, jdk03, jdk04, jdk05]
a.subList(0,4)---[jdk02, jdk06, yu01, yu02,ooooo, yu04, yu05, jdk03, jdk04, jdk05]
改变之后的a---[jdk02, jdk06,yu01, yu02, ooooo, yu04, yu05, jdk03, jdk04, jdk05]
jdk02
jdk06
yu01
yu02
ooooo
yu04
yu05
jdk03
jdk04
jdk05
*/————————分割线——————
/*
ArrayList的一些方法应用
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Jihe5
{
public static void main(String[] args)
{
method();
soc("---分割线---");
method2();
}
public static void method()
{
ArrayList a=new ArrayList();
//ArrayList是List接口的子类
a.add("jdk01");
a.add("jdk02");
a.add("jdk03");
a.add("jdk04");
a.add("jdk05");
ArrayList b=new ArrayList();
b.add("yu01");
b.add("yu02");
b.add("yu03");
b.add("yu04");
b.add("yu05");
soc("a---"+a);
soc("b---"+b);
soc(a.indexOf("jdk03"));
//indexOf返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1
Iterator it= a.listIterator();
while(it.hasNext())
{
Object obj=it.next();
if(obj.equals("jdk04"))
{
//a.add("java");//这里不能用
/*
因为不能够同时用集合方法和迭代器对同一组元素操作，
容易产生并发修改异常
*/
it.remove();//将a中的jdk04删除
}
soc("obj---"+obj);
//不管迭代器有没有进行删除操作，obj 的指向都没有改变，所以都会打印出来
//本质上迭代器删除的是储存在容器中的对象地址而已
}
soc("修改后的a---"+a);
}
public static void method2()
{
ArrayList a=new ArrayList();
//ArrayList是List接口的子类
a.add("jdk01");
a.add("jdk02");
a.add("jdk03");
a.add("jdk04");
a.add("jdk05");
ArrayList b=new ArrayList();
b.add("yu01");
b.add("yu02");
b.add("yu03");
b.add("yu04");
b.add("yu05");
soc("a---"+a);
soc("b---"+b);
ListIterator li=a.listIterator();
soc("正向遍历前的li.hasPrevious()---"+li.hasPrevious());
//hasPrevious用来判断有没有前面元素，有的话返回true否则返回false
soc("正向遍历前的li.hasNext()---"+li.hasNext());
while(li.hasNext())
{
Object obj=li.next();
if(obj.equals("jdk04"))
{
li.add("hhhhh");//这个是ListIterator特有方法，这是Iterator所没有的
//hhhhh是添加在jdk04的后面的
//li.set("ttt");//在jdk04的位置上改成ttt
//这个是ListIterator特有方法，这是Iterator所没有的
}
soc("obj---"+obj);
}
soc("修改后的a---"+a);
soc("正向遍历后的li.hasPrevious()---"+li.hasPrevious());
soc("正向遍历后的li.hasNext()---"+li.hasNext());
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
a---[jdk01, jdk02, jdk03, jdk04, jdk05]
b---[yu01, yu02, yu03, yu04, yu05]
2
obj---jdk01
obj---jdk02
obj---jdk03
obj---jdk04
obj---jdk05
修改后的a---[jdk01, jdk02,jdk03, jdk05]
---分割线---
a---[jdk01, jdk02, jdk03, jdk04, jdk05]
b---[yu01, yu02, yu03, yu04, yu05]
正向遍历前的li.hasPrevious()---false
正向遍历前的li.hasNext()---true
obj---jdk01
obj---jdk02
obj---jdk03
obj---jdk04
obj---jdk05
修改后的a---[jdk01, jdk02,jdk03, jdk04, hhhhh, jdk05]
正向遍历后的li.hasPrevious()---true
正向遍历后的li.hasNext()---false
*/————分割线————
/*
在List有几个常用的子类
ArrayList---动态数组：底层数据结构是数组结构，查询快，增减慢，线程不同步
LinkedList---底层数据结构是链表结构，（像链子一样，后一个勾着前一个元素）增删快，查询慢
Vector---底层数据结构数组，功能与ArrayList一样，但是线程同步
ArrayList默认长度10，只要元素超出了长度就延长百分之50，直到能够足够装下所有元素
Vector默认长度10，只要元素超出长度就延长百分之100，直到能够装下所有元素
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
Class Jihe6
{
public static void main(String[] args)
{
method();
}
public static void method()
{
Vector a=new Vector();
//Vector是List接口的子类
a.add("jdk01");
a.add("jdk02");
a.add("jdk03");
a.add("jdk04");
a.add("jdk05");
soc("a---"+a);
Enumeration it= a.elements();//建立一个枚举
//Vector中的枚举也是一种取出方式
/*
Vector中的枚举功能和迭代器一样只不过名字过长，慢慢被替代了
*/
while(it.hasMoreElements())
{
soc(it.nextElement());
}
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
a---[jdk01, jdk02, jdk03, jdk04, jdk05]
jdk01
jdk02
jdk03
jdk04
jdk05
*/————分割线————
/*
以下是关于LinkedList的一些知识点
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Jihe7
{
publicstatic void main(String[] args)
{
method();
method2();
method3();
method4();
method5();
method6();
}
public static LinkedList dx()
{
LinkedList a=new LinkedList();
//LinkedList 是List接口的子类，线程不同步
a.add("jdk01");
a.add("jdk02");
a.add("jdk03");
a.add("jdk04");
a.add("jdk05");
soc("原本的a---"+a);
return a;
}
public static void method()
{
soc("以下是：method-------------");
LinkedList a=dx();
a.addFirst("kkk");//把kkk添加到头部
soc("a.addFirst(\"kkk\")---"+a);
a.addFirst("uio");
soc("a.addFirst(\"uio\")---"+a);
a.addLast("last");
soc("a.addLast(\"last\")---"+a);
System.out.println("HelloWorld!");
}
public static void method2()
{
soc("以下是：method2-------------");
LinkedList a= dx();
soc("a.getFirst()---"+a.getFirst());//获取但是不删除元素
soc("a.getLast()---"+a.getLast());
soc("结果getFirst和getLast之后的a---"+a);
}
public static void method3()
{
soc("以下是：method3-------------");
LinkedList a= dx();
soc("原本a的长度---"+a.size());
soc("a.removeFirst()---"+a.removeFirst());
//removeFirst和removeLast方法返回的都是被增删的元素
soc("removeFlirst之后的a---"+a);
soc("再次a.removeFirst()---"+a.removeFirst());
soc("再次removeFlirst之后的a---"+a);
soc("a.removeLast()---"+a.removeLast());
soc("removeLast之后的a---"+a);
/*
如果容器里面没有元素，就用getFirst,getLast,removeFirst或者removeLast方法操作元素,
那么，就会抛出“没有这个元素”的异常NoSuchElementException
*/
}
public static void method4()
{
soc("以下是：method4(1.6jdk新版本的方法)-------------");
LinkedList a= dx();
//offFirst和offLast方法添加元素
soc("a.offerFirst(\"456\")---"+a.offerFirst("456"));
soc("经过a.offerFirst(\"456\")后的a---"+a);
soc("a.offerLast(\"456\")---"+a.offerLast("456"));
soc("经过a.offerLast(\"456\")后的a---"+a);
}
public static void method5()
{
soc("以下是：method5(1.6jdk新版本的方法)-------------");
LinkedList a= dx();
//peekFirst和peekLast方法获取但是不删除元素
soc("a.peekFirst()---"+a.peekFirst());
soc("a---"+a);
soc("a.peekLast()---"+a.peekLast());
soc("a---"+a);
while(!a.isEmpty())
{
a.removeFirst();
}
soc("取出a中所有元素");
soc("a.peekFirst()---"+a.peekFirst());
soc("a---"+a);
soc("a.peekLast()---"+a.peekLast());
soc("a---"+a);
//容器中没有元素时候，peekFirst和peekLast方法返回null
}
public static void method6()
{
soc("以下是：method6(1.6jdk新版本的方法)-------------");
LinkedList a= dx();
//pollFirst和pollLast方法获取并且删除元素
soc("a.pollFirst()---"+a.pollFirst());
soc("a---"+a);
soc("a.pollLast()---"+a.pollLast());
soc("a---"+a);
while(!a.isEmpty())
{
a.removeFirst();
}
soc("取出a中所有元素");
soc("a.pollFirst()---"+a.pollFirst());
soc("a---"+a);
soc("a.pollLast()---"+a.pollLast());
soc("a---"+a);
//容器中没有元素时候，peekFirst和peekLast方法返回null
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
以下是：method-------------
原本的a---[jdk01, jdk02,jdk03, jdk04, jdk05]
a.addFirst("kkk")---[kkk, jdk01,jdk02, jdk03, jdk04, jdk05]
a.addFirst("uio")---[uio, kkk,jdk01, jdk02, jdk03, jdk04, jdk05]
a.addLast("last")---[uio, kkk,jdk01, jdk02, jdk03, jdk04, jdk05, last]
Hello World!
以下是：method2-------------
原本的a---[jdk01, jdk02,jdk03, jdk04, jdk05]
a.getFirst()---jdk01
a.getLast()---jdk05
结果getFirst和getLast之后的a---[jdk01,jdk02, jdk03, jdk04, jdk05]
以下是：method3-------------
原本的a---[jdk01, jdk02,jdk03, jdk04, jdk05]
原本a的长度---5
a.removeFirst()---jdk01
removeFlirst之后的a---[jdk02, jdk03, jdk04, jdk05]
再次a.removeFirst()---jdk02
再次removeFlirst之后的a---[jdk03, jdk04, jdk05]
a.removeLast()---jdk05
removeLast之后的a---[jdk03, jdk04]
以下是：method4(1.6jdk新版本的方法)-------------
原本的a---[jdk01, jdk02,jdk03, jdk04, jdk05]
a.offerFirst("456")---true
经过a.offerFirst("456")后的a---[456, jdk01, jdk02, jdk03, jdk04, jdk05]
a.offerLast("456")---true
经过a.offerLast("456")后的a---[456, jdk01, jdk02, jdk03, jdk04, jdk05, 456]
以下是：method5(1.6jdk新版本的方法)-------------
原本的a---[jdk01, jdk02,jdk03, jdk04, jdk05]
a.peekFirst()---jdk01
a---[jdk01, jdk02, jdk03, jdk04, jdk05]
a.peekLast()---jdk05
a---[jdk01, jdk02, jdk03, jdk04, jdk05]
取出a中所有元素
a.peekFirst()---null
a---[]
a.peekLast()---null
a---[]
以下是：method6(1.6jdk新版本的方法)-------------
原本的a---[jdk01, jdk02,jdk03, jdk04, jdk05]
a.pollFirst()---jdk01
a---[jdk02, jdk03, jdk04, jdk05]
a.pollLast()---jdk05
a---[jdk02, jdk03, jdk04]
取出a中所有元素
a.pollFirst()---null
a---[]
a.pollLast()---null
a---[]
*/
——————分割线——————
/*
用LinkedList
模拟队列（先进先出）
模拟栈(先进后出)
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Dueilie//队列类
{
private LinkedList a=new LinkedList();
public void myAdd(Object obj)//加进元素
{
a.addLast(obj);
}
public Object myGet()//删减元素
{
return a.pollFirst();
}
public boolean isKong()
{
return a.isEmpty();
}
}
class Zhang
{
private LinkedList b=new LinkedList();
public void myAdd(Object obj)
{
b.addLast(obj);
}
public Object myGet()
{
return b.pollLast();
}
public boolean isKong()
{
return b.isEmpty();
}
}
class Jihe8
{
publicstatic void main(String[] args)
{
method();
method2();
}
public static void method()
{
Dueilie a= new Dueilie();
a.myAdd("iop01");
a.myAdd("iop02");
a.myAdd("iop03");
a.myAdd("iop04");
a.myAdd("iop05");
a.myAdd("iop06");
while(!a.isKong())
{
soc(a.myGet());
}
}
public static void method2()
{
Zhang a=new Zhang();
a.myAdd("ert01");
a.myAdd("ert02");
a.myAdd("ert03");
a.myAdd("ert04");
a.myAdd("ert05");
a.myAdd("ert06");
while(!a.isKong())
{
soc(a.myGet());
}
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
iop01
iop02
iop03
iop04
iop05
iop06
ert06
ert05
ert04
ert03
ert02
ert01
*/——————分割线————
/*
去除容器中的重复元素
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Jihe9
{
publicstatic void main(String[] args)
{
ff();
method2();
}
public static void ff()
{
ArrayList a=new ArrayList();
a.add("jdk01");
a.add("jdk02");
a.add("jdk01");
a.add("jdk01");
a.add("jdk04");
a.add("jdk04");
soc(a);
ArrayList b=method(a);
soc(method(a));
}
public static ArrayList method(ArrayList a)
{
ArrayList b=new ArrayList();
Iterator it=a.iterator();
while(it.hasNext())
{
Object obj=it.next();
if( !b.contains(obj) )//如果不包含就记录在b容器里面
{
b.add(obj);
}
}
return b;
}
public static void method2()
{
ArrayList a=new ArrayList();
a.add("jdk01");
a.add("jdk02");
a.add("jdk01");
a.add("jdk01");
a.add("jdk04");
a.add("jdk04");
soc(a);
Iterator it=a.iterator();
while(it.hasNext())
{
soc(it.next()+"-----"+it.next());//如果元素个数是奇数的话就容易出问题
//所以一般在一个循环里面next()方法写一次
}
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
[jdk01, jdk02, jdk01, jdk01, jdk04, jdk04]
[jdk01, jdk02, jdk04]
[jdk01, jdk02, jdk01, jdk01, jdk04, jdk04]
jdk01-----jdk02
jdk01-----jdk01
jdk04-----jdk04
*/——————分割线————
/*
依旧是ArrayList相关练习
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Student
{
private String name ;
private int age;
Student(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)
{
if( !(obj instanceof Student ) )
{
return false;
}
Student stu=(Student)obj;
System.out.println(this.name+"----"+stu.name);
System.out.println(this.age+"----"+stu.age);
boolean cd= this.name.equals(stu.name)&& this.age==stu.age;
//这里的equals方法是字符串的equals方法，比较的是地址值
return cd;
}
}
class Jihe10
{
Public static void main(String[]args)
{
ArrayList a= new ArrayList();
a.add(new Student("haha01",12));
a.add(new Student("haha02",13));
a.add(new Student("haha01",12));
a.add(new Student("haha04",15));
a.add(new Student("haha05",16));
a.add(new Student("haha05",16));
//a.add(Object obj);括号里面返回的是Object类的对象
a= bijiao(a);
Iterator it= a.iterator();
while(it.hasNext() )
{
Student stu=(Student)it.next() ;
//这里为什么要强制转换类型呢？
/*
因为a.add(Object obj);括号里面返回的是Object类的对象,
it.next()代表的也是对应的Object类的对象，
Object类的对象没有对应的getName()和getAge()方法调用
*/
soc("名字---"+stu.getName()+"---年龄---"+stu.getAge());
}
}
public static ArrayList bijiao (ArrayList a)
{
ArrayList b=new ArrayList();
Iterator it= a.iterator();
while(it.hasNext())
{
Student stu= (Student)it.next();
if(!b.contains(stu) )
/*
这里的contains方法会内部自己调用到对象的equals方法，
用来比较对象是否是一致的，但是由于equals方法被复写了，
所以，实际上也就是调用了复写之后的equals方法
remove方法也是调用了对象的equals方法，比较之后才会删减
list,ArrayList也因为类似原理依赖于底层的Object类的equals方法，
*/
{
b.add(stu);
}
}
return b;
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
haha02----haha01
13----12
haha01----haha01
12----12
haha04----haha01
15----12
haha04----haha02
15----13
haha05----haha01
16----12
haha05----haha02
16----13
haha05----haha04
16----15
haha05----haha01
16----12
haha05----haha02
16----13
haha05----haha04
16----15
haha05----haha05
16----16
名字---haha01---年龄---12
名字---haha02---年龄---13
名字---haha04---年龄---15
名字---haha05---年龄---16
*/——————分割线——————
/*
Set中的元素无序，元素不可以重复，该集合体系没有索引,
无序意思就是存入和取出顺序不一定一样
Set集合功能和Collection是一样的
Set体系里面常用的是：
HashSet----底层数据结构是哈希表，接收到的数据（对象的哈希值）都按照哈希表顺序排列，
一个数据按照自己的哈希值进来后，发现如果之前已经有存入的数据，就比较是否为同一个对象，
如果不是的话就在该哈希值下面顺延表示有两个对象在同一个哈希值下，否则就踢出去。
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Jihe11
{
public static void main(String[]args)
{
method();
method2();
method3();
}
public static void method()
{
soc("以下是method-----------");
HashSet a=new HashSet();
a.add("jdk01");
a.add("jdk02");
a.add("jdk03");
a.add("jdk04");
a.add("jdk05");
a.add("jdk06");
Iterator it=a.iterator();
while( it.hasNext())
{
soc(it.next());
}
}
public static void method2()
{
soc("以下是method2-----------");
HashSet a=new HashSet();
a.add("jdk01");
a.add("jdk01");
a.add("jdk03");
a.add("jdk04");
a.add("jdk04");
a.add("jdk06");
Iterator it=a.iterator();
while( it.hasNext())
{
soc(it.next());
}
}
public static void method3()
{
soc("以下是method3-----------");
HashSet a=new HashSet();
soc("第一个a.add(\"jdk01\")返回的是---"+a.add("jdk01"));
soc("第二个a.add(\"jdk01\")返回的是---"+a.add("jdk01"));
}
public static void soc(Object obj )
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
以下是method-----------
jdk04
jdk03
jdk06
jdk05
jdk02
jdk01
以下是method2-----------
jdk04
jdk03
jdk06
jdk01
以下是method3-----------
第一个a.add("jdk01")返回的是---true
第二个a.add("jdk01")返回的是---false
*/——————分割线————
/*
HashSet的具体实例的应用
依据相似的原理，对于HashSet而言，判断元素是否存在，删除这些操作都
依赖于hashCode和equals方法。
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Student
{
private String name ;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int hashCode()//哈希值是int类型的
//为什么这里要定义一个hashCode方法?
/*
因为要覆盖Object类中的hashCode方法,然后，
返回后面需要调用的哈希值
*/
{
System.out.println("名字:"+this.name+"; hasCode()");//观测某对象是否调用了该方法
return this.name.hashCode()+this.age;
//名字的哈希值加上int类的年龄组成对应的对象的哈希值
//后面如果出现不同名字和年龄的对象的话，就会按照哈希表放在容器某个位置
/*
后面如果出现相同名字和年龄的对象的话，就会按照哈希表放在容器某个位置，
并且虚拟机自动把其与前面相同名字年龄的对象比较名字年龄，当然，会被剔除出去，
*/
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public boolean equals (Object obj)
{
if( !(obj instanceof Student ) )
{
return false;
}
Student stu=(Student)obj;
System.out.println(this.name+"----"+stu.name);
System.out.println(this.age+"----"+stu.age);
boolean cd= this.name.equals(stu.name)&& this.age==stu.age;
//这里的equals方法是字符串的equals方法，比较字符串内容是否相等
return cd;
}
}
class Jihe12
{
publicstatic void main(String[] args)
{
HashSet a= new HashSet();
a.add(new Student("haha01",12));
a.add(new Student("haha02",13));
a.add(new Student("haha01",12));
a.add(new Student("haha04",15));
a.add(new Student("haha05",16));
a.add(new Student("haha05",16));
//a.add(Object obj);括号里面返回的是Object类的对象
/*
就算是对象的名字年龄相同，每一个新建对象都有不同的哈希值,
从一开始就根据哈希表被放进容器里不同的位置上，即便后面使
用contains方法做比较都是没有实际效果，这样就挑不出重复的元素，
为了解决这个问题，就要覆盖Object类中的hashCode方法。
*/
//a= bijiao(a);
/*
对于HashSet类的容器，往里面加元素时，虚拟机会自动比较提出重复元素,
(这也是HashSet类容器不允许重复元素存在的原因)
所以没有必要用到bijiao方法，但是会调用对象的equals方法
如果对象没有equals方法就默认是调用Object类的equals方法
*/
Iterator it= a.iterator();
while(it.hasNext() )
{
Student stu=(Student)it.next() ;
soc("名字---"+stu.getName()+"---年龄---"+stu.getAge());
}
}
public static ArrayList bijiao (ArrayList a)//这个方法没有被调用
{
ArrayList b=new ArrayList();
Iterator it= a.iterator();
while(it.hasNext())
{
Student stu= (Student)it.next();
if(!b.contains(stu) )
{
b.add(stu);
}
}
return b;
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
名字:haha01; hasCode()
名字:haha02; hasCode()
名字:haha01; hasCode()
haha01----haha01
12----12
名字:haha04; hasCode()
名字:haha05; hasCode()
名字:haha05; hasCode()
haha05----haha05
16----16
名字---haha02---年龄---13
名字---haha05---年龄---16
名字---haha04---年龄---15
名字---haha01---年龄---12
*/版权声明：本文为博主原创文章，未经博主允许不得转载。
标签：黑马程序员
原文地址：http://blog.csdn.net/dangaodeaiyi/article/details/47258281
