Day14
08 LinkedList
09 LinkedList练习
10 ArrayList练习
11 ArrayList练习2
12 HashSet
13 HashSet存储自定义对象
14 HashSet判断和删除的依据
08 LinkedList
LinkedList特有的方法:
addFirst() addLast()
getFirst() getLast()
获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException。
removeFirst() removeLast()
获取元素,并删除元素。如果集合中没有元素,会出现NoSuchElementException。
在JDK1.6中出现了替代方法。
offerFirst() offerLast()
peekFirst() peekLast()
获取元素,但不删除元素。如果集合中没有元素,会返回null.
pollFirst() pollLast()
获取元素,并删除元素。如果集合中没有元素,会返回null。
1 import java.util.*;
2
3 class LinkedListDemo
4 {
5 public static void main(String[] args)
6 {
7 LinkedList link=new LinkedList();
8
9 link.addFirst("java01");
10 link.addFirst("java02");
11 link.addFirst("java03");
12 link.addFirst("java04");
13
14
15 sop(link.getLast());
16 sop("size:"+link.size());
17
18 sop(link.removeLast());
19 sop("size:"+link.size());
20
21 //用自己的方法取出元素
22 while(!link.isEmpty())
23 {
24 sop(link.removeFirst());
25 }
26 }
27 public static void sop(Object obj)
28 {
29 System.out.println(obj);
30 }
31 }
09 LinkedList练习
使用LinkedList模拟堆栈或者队列的数据结构
堆栈:先进后出
1 import java.util.*;
2 class myStack
3 {
4 private LinkedList link;
5 public myStack()
6 {
7 link=new LinkedList();
8 }
9
10 public void myAdd(Object obj)
11 {
12 link.addFirst(obj);
13 }
14 public Object myGet()
15 {
16 return link.removeFirst();
17 }
18 public boolean isNull()
19 {
20 return link.isEmpty();
21 }
22 }
23 class LinkedListTest
24 {
25 public static void main(String[] args)
26 {
27 myStack s=new myStack();
28 s.myAdd("java01");
29 s.myAdd("java02");
30 s.myAdd("java03");
31 s.myAdd("java04");
32
33 while(!s.isNull())
34 {
35 System.out.println(s.myGet());
36 }
37
38
39 }
40 }
队列:先进先出
1 import java.util.*;
2 class myQueue
3 {
4 private LinkedList link;
5 public myQueue()
6 {
7 link=new LinkedList();
8 }
9
10 public void myAdd(Object obj)
11 {
12 link.addFirst(obj);
13 }
14 public Object myGet()
15 {
16 return link.removeLast();
17 }
18 public boolean isNull()
19 {
20 return link.isEmpty();
21 }
22 }
23 class LinkedListTest
24 {
25 public static void main(String[] args)
26 {
27 myQueue q=new myQueue();
28 q.myAdd("java01");
29 q.myAdd("java02");
30 q.myAdd("java03");
31 q.myAdd("java04");
32
33 while(!q.isNull())
34 {
35 System.out.println(q.myGet());
36 }
37
38
39 }
40 }
10 ArrayList练习
去掉ArrayList中的重复元素
基本思想:拿一个新的容器,分别取出原ArrayList中的元素,每拿一个便检查新容器中有没有与之相同的元素。
如果有,就把此元素丢掉,如果没有,就把此元素放到新容器中。遍历完成后,新容器中就是原ArrayList去掉重复元素后的结果了。
1 //去掉ArrayList中的重复元素
2 import java.util.*;
3 class ArrayListTest
4 {
5 public static ArrayList singleElement(ArrayList al)
6 {
7 ArrayList newAl=new ArrayList();
8 Iterator it=al.iterator();
9 while(it.hasNext())
10 {
11 Object obj=it.next();
12 if(!newAl.contains(obj))
13 {
14 newAl.add(obj);
15
16 }
17 }
18 /*
19 注意,循环中只能调用一次next,就用hasNext判断一次,
20 否则,会出现错误。
21 while(it.hasNext())
22 {
23 sop(it.next()+"......"+it.next());
24 }
25 */
26 return newAl;
27
28 }
29 public static void sop(Object obj)
30 {
31 System.out.println(obj);
32 }
33 public static void main(String[] args)
34 {
35 ArrayList al=new ArrayList();
36 al.add("java01");
37 al.add("java03");
38 al.add("java01");
39 al.add("java03");
40 al.add("java01");
41 al.add("java02");
42 sop(al);
43
44
45 sop(singleElement(al));
46
47 }
48 }
11 ArrayList练习2
将自定义对象作为元素存到ArrayList集合中,并去除重复元素
比如,存入人对象,同姓名同年龄,视为同一个人,为重复元素
思路:
1.对人描述,将数据封装进人对象。(姓名、年龄都相同的视为同一个人)
2.定义容器,将人存入
3.取出
List集合判断元素是否相同,依据的是元素的equals方法。
1 import java.util.*;
2 class Person
3 {
4 private String name;
5 private int age;
6 public Person(String name,int age)
7 {
8 this.name=name;
9 this.age=age;
10 }
11 public String getName()
12 {return name;}
13 public int getAge()
14 {return age;}
15 //重写父类的equals方法
16 public boolean equals(Object obj)
17 {
18 if(! (obj instanceof Person))
19 return false;
20 Person p=(Person)obj;
21 System.out.println(this.name+"..."+p.name);//输出语句,显示equals的调用过程
22 //此语句中调用的是String 中的equals方法
23 return this.name.equals(p.name) && this.age==p.age;
24
25
26 }
27 }
28
29
30 class ArrayListTest2
31 {
32 public static void sop(Object obj)
33 {
34 System.out.println(obj);
35 }
36 public static ArrayList singleElement(ArrayList al)
37 {
38 ArrayList newAl=new ArrayList();
39 Iterator it=al.iterator();
40 while(it.hasNext())
41 {
42 Object obj=it.next();
43 //contains底层调用的是对象的equals方法
44 //但是原equals方法比较的是对象的地址
45 //并不知道,我们想要的比较方法
46 //所以,要在Person类中重写父类的equals方法
47 if(!newAl.contains(obj))
48 {
49 newAl.add(obj);
50 }
51 }
52 return newAl;
53
54
55 }
56 public static void main(String[] args)
57 {
58 ArrayList al=new ArrayList();
59 al.add(new Person("java01",12));//al.add(Object obj) //Object obj=new Person("java01",12)
60 al.add(new Person("java02",22));
61 al.add(new Person("java01",32));
62 al.add(new Person("java03",22));
63 al.add(new Person("java02",22));
64
65 //如果注释掉重写的equals方法,remove的调用结果就是false,即找不到要移除的对象
66 //这说明remove底层调用的也是对象的equals方法。
67 sop("remove:"+al.remove(new Person("java03",22)));
68
69 al=singleElement(al);
70
71 Iterator it=al.iterator();
72 while(it.hasNext())
73 {
74 Person p=(Person)it.next();
75 sop(p.getName()+"----"+p.getAge());
76
77 }
78
79
80 }
81 }
12 HashSet
|--Set:元素是无序的(存入和取出的顺序不一定一致),元素不可以重复。
|--HashSet:底层的数据结构是哈希表
|--TreeSet:
Set集合的功能和Collection是一致的。
1 import java.util.*;
2 class HashSetDemo
3 {
4 public static void sop(Object obj)
5 {
6 System.out.println(obj);
7 }
8 public static void main(String[] args)
9 {
10 //验证Set无序,不可重复的特点
11 HashSet hs=new HashSet();
12 hs.add("java01");
13 hs.add("java01");
14 //sop(hs.add("java01"));sop(hs.add("java01")); 第一个是true 第二个是false
15 hs.add("java03");
16 hs.add("java04");
17 hs.add("java05");
18
19 Iterator it=hs.iterator();
20
21 while(it.hasNext())
22 {
23 sop(it.next());
24 }
25
26 }
27 }
13 HashSet存储自定义对象
HashSet是如何保证唯一性的呢?
是通过元素的两个方法,hashCode和equals
如果元素的hashCode值相同,才会判断equals是否为true
如果元素的hashCode不同,直接存入,不会调用equals。
在项目中,描述一个类,并且需要把它的对象装入集合时,一般都需要复写该类的hashCode方法和equals方法。
因为,原有的方法不能比较我们需要比较的内容。
1 /*
2 对象存入HashSet,先调用自己的hashCode方法计算哈希值,看哈希表中是否有和自己哈希值相同的元素
3 如果哈希值相同,再调用对象的equals方法来比较,
4 如果结果仍然相同,就不会存入Hashset;
5 如果不同就在哈希值相同的元素后,顺延一个位置存入。
6 */
7 import java.util.*;
8 class HashSetTest
9 {
10 public static void main(String[] args)
11 {
12 HashSet hs=new HashSet();
13 hs.add(new Person("a1",11));
14 hs.add(new Person("a2",12));
15 hs.add(new Person("a2",12));
16 hs.add(new Person("a1",13));
17 hs.add(new Person("a3",11));
18
19 Iterator it=hs.iterator();
20 while(it.hasNext())
21 {
22 Person p=(Person)it.next();
23 sop(p.getName()+"::"+p.getAge());
24 }
25
26 }
27 public static void sop(Object obj)
28 {
29 System.out.println(obj);
30 }
31 }
32 class Person
33 {
34 private String name;
35 private int age;
36 public int hashCode()
37 {
38 //return 60;
39 //为了避免再调用对象的equals方法进行比较,应该尽量使对象的hashCode值不同
40 return name.hashCode()+age*39;
41
42 }
43 public Person(String name,int age)
44 {
45 this.name=name;
46 this.age=age;
47 }
48 public String getName()
49 {return name;}
50 public int getAge()
51 {return age;}
52 //重写父类的equals方法
53 public boolean equals(Object obj)
54 {
55 if(! (obj instanceof Person))
56 return false;
57 Person p=(Person)obj;
58 System.out.println(this.name+"...equals..."+p.name);//输出语句,显示equals的调用过程
59 //此语句中调用的是String 中的equals方法
60 return this.name.equals(p.name) && this.age==p.age;
61
62
63 }
64 }
14 HashSet判断和删除的依据
注意,对于hashSet判断元素是否存在(contains()方法)或者删除元素(remove()方法)依赖的方法是HashCode和equals方法。
如果,hashCode值不同,直接可知道该元素不存在;
如果相同,再用equals方法判断。