Set接口：与List接口方法相似，当添加元素为重复元素时，那么此元素将不会被添加进集合，Set集合无序，可添加null。
例一：
package com.hyxy;
import java.util.HashSet;
import java.util.Set;
public class TestSet1 {
public static void main(String[] args) {
Set<String> set=new HashSet<String>();
set.add("A");
set.add("B");
set.add("C");
System.out.println(set);//运行结果：[A, B, C]
set.add("AB");
System.out.println(set);//运行结果：[A, AB, B, C]
//证明重复
set.add("A");
System.out.println(set);//运行结果：[A, AB, B, C]
set.add(null);
System.out.println(set);//运行结果：[null, A, AB, B, C]
System.out.println(set.contains("AB"));//运行结果：true
}
}
例二：自定义类Student，自动生成有无参构造方法，属性set、get方法，toString方法，hashCode、equals方法。当向HashSet集合中存入元素时，HashSet会调用该对象的hashCode方法来得到该对象的hashCode值，然后滚局hashCode值决定该对象在HashSet中的存储位置。如果两个元素的equals方法返回true，但hashCode返回值不相等，hashSet将会把他们存储在不同的位置，但依然可以添加成功。
public class Student {
private String strID;
private int age;
private String grade;
private String name;
public Student() {}
public Student(String strID, int age, String grade, String name) {
this.strID = strID;
this.age = age;
this.grade = grade;
this.name = name;
}
public String getStrID() {
return strID;
}
public void setStrID(String strID) {
this.strID = strID;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGrade() {
return grade;
}
public void setGrade(String grade) {
this.grade = grade;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String toString() {
return "Student [strID=" + strID + ", age=" + age + ", grade=" + grade + ", name=" + name + "]";
}
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((grade == null) ? 0 : grade.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((strID == null) ? 0 : strID.hashCode());
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (grade == null) {
if (other.grade != null)
return false;
} else if (!grade.equals(other.grade))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (strID == null) {
if (other.strID != null)
return false;
} else if (!strID.equals(other.strID))
return false;
return true;
}
}
测试类：
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class TestHashSetDemo01 {
public static void main(String[] args) {
Set<Student> set=new HashSet<Student>();
Student s1=new Student("164101",20,"大二","郑一");
Student s2=new Student("164102",21,"大一","王二");
Student s3=new Student("164103",20,"大二","张三");
set.add(s1);
set.add(s2);
set.add(s3);
set.add(new Student("164104",19,"大二","李四"));
System.out.println(set.size());//输出结果：4
Student s4=new Student("164103",20,"大二","张三");
//未在Student类中重写hashCode与equals方法
set.add(s4);
System.out.println(set.size());//输出结果：5
//在Student类中重写hashCode与equals方法
set.add(s4);
System.out.println(set.size());//输出结果：4
//删除有两种情况
//情况一：已知地址信息，可直接删除
set.remove(s3);
System.out.println(set.size());//输出结果：3
//情况二：地址信息未知，可重新生成相同对象
set.remove(new Student("164104",19,"大二","李四"));
System.out.println(set.size());//输出结果：2
//在放入集合中后，元素属性不可随意进行修改，否则在后续删除操作中会造成不必要的麻烦，并可能造成内存溢出
//原因：
//存入时：原元素属性参与hash运算得出地址
//删除时：此时元素属性参与hash运算得出地址
//我们可以得知，如果修改后删除，得出的地址处并没有元素，故无法删除
//解决方法：将丢该元素属性值改回原值后可进行删除
s2.setAge(18);
set.remove(s2);
System.out.println(set.size());//输出结果：2
s2.setAge(21);
set.remove(s2);
System.out.println(set.size());//输出结果：1
//set集合虽然无序，依然可是使用迭代器进行遍历
Iterator<Student> it=set.iterator();
while(it.hasNext()) {
System.out.println(it.next());//输出结果：Student [strID=164101, age=20, grade=大二, name=郑一]
}
}
}
Queue接口：
①boolean offer(E e)：将元素添加到队尾
②E poll()：移除队首元素并将其返回
③E peek()：查看队首元素
④E remove()：移除队首元素并将其返回
⑤boolean remove(Object o)：移除指定元素
例三：
package com.hyxy;
import java.util.LinkedList;
import java.util.Queue;
public class TestQueue {
public static void main(String[] args) {
Queue<String> queue=new LinkedList<String>();
queue.offer("A");
queue.offer("B");
queue.offer("C");
queue.offer("D");
queue.offer("E");
System.out.println(queue);//运行结果：[A, B, C, D, E]
System.out.println(queue.poll());//运行结果：A
System.out.println(queue);//运行结果：[B, C, D, E]
System.out.println(queue.peek());//运行结果：B
System.out.println(queue);//运行结果：[B, C, D, E]
System.out.println(queue.remove());//运行结果：B
System.out.println(queue);//运行结果：[C, D, E]
System.out.println(queue.remove("D"));//运行结果：true
System.out.println(queue);//运行结果：[C, E]
}
}
Deque接口：
①boolean offer(E e)：添加元素到队尾
②boolean offerFirst(E e)：添加元素到队首
③boolean offerLast(E e)：添加元素到队尾
④E poll()：移除队首元素
⑤E pollFirst()：移除队首元素
⑥E pollLast()：移除队尾元素
⑦E peek()：查看队首元素
⑧E peekFirst()：查看队首元素
⑨E peekLast()：查看队尾元素
例四：
package com.hyxy;
import java.util.Deque;
import java.util.LinkedList;
public class TestDeque1 {
public static void main(String[] args) {
Deque<String> deque=new LinkedList<String>();
deque.offer("A");
deque.offer("B");
System.out.println(deque);//输出结果：[A, B]
deque.offerLast("C");
System.out.println(deque);//输出结果：[A, B, C]
deque.offerFirst("H");
System.out.println(deque);//输出结果：[H, A, B, C]
System.out.println(deque.poll());//输出结果：H
System.out.println(deque);//输出结果：[A, B, C]
System.out.println(deque.pollFirst());//输出结果：A
System.out.println(deque);//输出结果：[B, C]
System.out.println(deque.pollLast());//输出结果：C
System.out.println(deque);//输出结果：[B]
deque.peek();
}
}
Stack栈结构：
①void push(E e)：进栈
②E pop()：移除栈顶元素
③E peek()：查看栈顶元素
例五：
package com.hyxy;
import java.util.Deque;
import java.util.LinkedList;
public class TestDeque2 {
public static void main(String[] args) {
Deque<String> stack=new LinkedList<String>();
stack.push("A");
stack.push("B");
stack.push("C");
System.out.println(stack);//输出结果：[C, B, A]
System.out.println(stack.peek());//输出结果：C
System.out.println(stack);//输出结果：[C, B, A]
System.out.println(stack.pop());//输出结果：C
System.out.println(stack);//输出结果：[B, A]
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
