java学习笔记集合框架Set集合

Set集合特点：无序，不可重复元素

Set集合的功能：和Collection是一致的。无特有方法，有的都是共性方法。
Set集合子接口：
| -- HashSet：数据结构是哈希表，线程是非同步的。保证元素唯一性的原理：判断元素 hashCode值是否相同。 如果相同，还会继续判断元素的equals方法，是否为 true。
通过元素的两个方法，hashCode和equals来完成，如果元素的HashCode值相同才会判断equals是否true。 如果元素的hashCode值不同，不调equals。
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
| -- TreeSet：该集合的特点是可以对Set集合中的元素进行排序。（按字母顺序ASCII）底层数据结构是二叉树， 保 证元素唯一性的依据是comparaTo方法返回0。

哈希表：
存储一系列的哈希值。存储顺序按照哈希值来存，不按照存入顺序存储。在哈希表中，当哈希值重复时（即地制值相同），会在进行判断哈希值的内容是否相同。若内容不同会将相同的位置的哈希值中的一个位置顺延一个。

HashSet集合示例：
需求：向hasSet集合中存入自定义对象，姓名和年龄相同为同一个元素即重复元素
classHashSetTest
{
public static void sop(Object obj) // 定义方法用于输出
{
System.out.println(obj);
}

public static void main(String[] args) // 主函数
{
hs.add(new Person(“a1”,11));
hs.add(new Person(“a2”,12));
hs.add(new Person(“a3”,13));
hs.add(new Person(“a2”,12));

sop(“a1:”+hs.contains(newPerson(“a3”,12))); // 此语句当哈希地址相同时比较哈希值都相同返回true
hs.remove(new Person(“a4”,14))); // 删除操作也判断哈希地址后在判断哈希值都相同则删除

Iterator it = hs.iterator();
while(it.hasNext()) // 循环输出列表中的元素。
{
Person p =(Person)it.next(); // 强制转型
sop(p.getName()+”::”+p.getAge());
}
}
}
classperson // 定义自定义Person类
{
private String name;
private int age;
person(String name,int age)
{
this.name=name;
this.age=age;
}
public int hashCode() // 重写hashCode用于比较哈希地址后比较哈希值
{
System.out.println(this.name+”……hashCode”); // 用于显示何时调用此方法。
// return 60; // 此方法有重复比较。
// 按条件来设定哈希值
return name.hashCode()+age*39; // 此种方法没有重复比较之比较两个地址相同的哈希值*39高效。
}
public String get Name ()
{
return name;
}
public int getAge()
{
return age;
}
public boolean equals(Object obj) // 对象间比较用的是equals方法，重写equals方法用于比较对象。
{
if(!obj instanceof Person)
return false;
Person p =(Person)obj;
// 如果equals被调用则会显示出比较过程效果。 结果为equals没有调用
System.out.println(this.name+”….”+p.name);
returnthis.name.equals(p.name)&&this.age==p.age;
}
}

TreeSet排序的第一种方式：
让元素自身具备比较性。元素要实现Comparable接口，覆盖compareTo方法。这种方式也称为元素的自然顺序或者叫做默认 顺序。
TreeSet排序的第二种方式：
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时就有了比较方式。

HashSet集合示例1：
需求：向TreeSet集合中存储自定义对象学生，并按照学生年龄进行排序。
记住：排序时，当主要条件相同时，一定要判断一下次要条件。

classTreeSetDemo
{
public static void main(String[] args) // 主函数
{
TreeSet ts = newTreeSet(); // 实例化一个TreeSet并添加元素
ts.add(“lisi02”,22);
ts.add(“lisi007”,20);
ts.add(“lisi09”,19); //由于TreeSet会自动排序所以必须要指定排序的方式否则添加多个对象会出错
ts.add(“lisi01”,40);
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu =(Student)it.next();
System.out.println(stu.getName()+”…”+stu.getAge()); // 结果为： aaa abc bca cba
}
}
public static void method() // 基本验证方法
{
TreeSet ts = newTreeSet(); // 实例化一个TreeSet并添加元素
ts.add(“cba”);
ts.add(“abcd”);
ts.add(“aaa”);
ts.add(“bca”);

Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next()); // 结果为： aaa abc bca cba
}
}
}

classStudent implements Comparable // 定义学生类实现Comparable接口强制让学生具有比较性
{
private String name; // 定义私有变量姓名和年龄
private int age;
Student(String name,int age) // 定义构造函数，给name和age赋值初始化。
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj) // 重写comparable方法指定比较方式
{ // 方法中若直接return1，则是如何存如何取方式，return-1是倒叙取方式。
if(!(obj instanceof Student))
throw newRuntimeException(“不是学生对象”);
Student s = (Student)obj; // 将参数obj强制转换成Student
System.out.println(this.name()+”…Comparable…”+this.age()); // 输出显示验证
if(this.age>s.age) // 判断按年龄排序。
return 1;
if(this.age==s.age) // 当年龄相同时，在比较姓名进行排序
{
return this.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}

TreeSet排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合容器自身具备比较性。在集合初始化时就有了比较方式。原理也是二叉树。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合容器自身具备比较性。定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compare方法。
HashSet集合示例2：
classStudent implements Comparable // 定义学生类实现Comparable接口强制让学生具有比较性
{
private String name; // 定义私有变量姓名和年龄
private int age;
Student(String name,int age) // 定义构造函数，给name和age赋值初始化。
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj) // 重写comparable方法指定比较方式
{ // 方法中若直接return1，则是如何存如何取方式，return-1是倒叙取方式。
if(!(obj instanceof Student))
throw newRuntimeException(“不是学生对象”);
Student s =(Student)obj; // 将参数obj强制转换成Student
if(this.age>s.age) // 判断按年龄排序。
return 1;
if(this.age==s.age) // 当年龄相同时，在比较姓名进行排序
{
returnthis.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}

classTreeSetDemo2 // 第二种排序方式实现
{
public static void main(String[]args) // 主函数
{
TreeSet ts = new TreeSet(newMyCompare); // 实例化一个TreeSet并添加元素并传递参数比较器
ts.add(“lisi02”,22);
ts.add(“lisi007”,20);
ts.add(“lisi09”,19); //由于TreeSet会自动排序所以必须要指定排序的方式否则添加多个对象会出错
ts.add(“lisi01”,40);
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu =(Student)it.next();
System.out.println(stu.getName()+”…”+stu.getAge()); }
}
}

classMyCompare implements Comparator
{
public int compare(Object 01,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num =s1.getName().compareTo(s2.getName());
if(num==0) // 当名字相同时比较年龄
returns1.getAge()-s2.getAge();
/* 利用Integer的compareTo方法比较
return newInteger(s1.getAge()).compareTo(new Integer(s2.getAge()));
*/
return num;
}
}

HashSet集合示例3：

按照字符串长度排序。
（字符串本事具备比较性，但是它的比较方式不是所需要的，这时就只能使用比较器）

importjava.util.*;
classTreeSetTest // 定义联系类

{
public static void main(String[] args)
{
TreeSetts = new TreeSet();
ts.add(“abcd”);
ts.add(“cc”);
ts.add(“cba”);
ts.add(“z”);
ts.add(“hahaha”);
Iteratorit = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
classStringLengthComparator implements Comparator // 定义比较器，重写compare方法。比较字符串长度。
{
public int compare(Object o1,Object o2)
{
String s1 = (String)o1;
String s2 = (String)o2;
/* 方法一：
if(s1.length() >s2.length())
return 1;
if(s1.length() >s2.length())
return 0;
return -1;
*/
int num = newInteger(s1.length()).compareTo(new Integer(s2.length())); //方法二：将字符串转成整型比
if(num==0)
returns1.compareTo(s2); 当长度相同时比较字符串本事，用原来的compareTo方法。
return num;
}
}