集合判断是否是同一元素的策略总结
总结：
- 对于List集合，仅仅是通过判断两个对象的【equals】方法是否为true
- 对于Hash系列的集合，是先判断对象的【hashCode】返回值是否相同，再判断对象的【equals】返回值是否为true
- 对于Tree 系列的集合，是判断两个对象的【compareTo】方法的返回结果是否是0
- 注意【Object】中的equals方法等同于==；默认不同对象调用hashCode方法返回的都是不同的整数。
- 注意【String】类重写了hashCode【和】equals方法，内容相同则两个值也相同(注意：SB并没有重新此方法)
普通List集合
// 对于ArrayList集合，判断是否是同一对象，仅仅通过调用对象的【equals】方法
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("lisi", 20));
al.add(new Person("bqt", 21));
al.add(new Person("hello", 22));
System.out.println(al);//[lisi,20, bqt,21, hello,22]
Person person = new Person("lisi", 23);
System.out.println(al.contains(person));//true，contains判断时调用的也是Person的equals方法
al.add(person);//允许元素重复
System.out.println(al);//[lisi,20, bqt,21, hello,22, lisi,23]
System.out.println("***************************");
System.out.println(getSingleElement(al));//[lisi,20, bqt,21, hello,22]
Collections.sort(al, new ComparatorByName());//按指定的比较器排序
System.out.println(al);//[bqt,21, hello,22, lisi,20, lisi,23]
Collections.sort(al);//以对象自己的排序规则排序
System.out.println(al);//[lisi,20, bqt,21, hello,22, lisi,23]
Tree系列集合
// 对于TreeSet，是根据【比较方法】的返回结果是否是0，是0，就是相同元素。注意：优先使用的是Set指定的比较器。
TreeSet<String> ts = new TreeSet<String>(new ComparatorByLength());
ts.add("aaa");
ts.add("z");
ts.add("ca");
ts.add("ac");
ts.add("aaa");//重复的元素，不允许
System.out.println(ts);//[z, ac, ca, aaa]，按字符串长度由短到长排序，如果长度相同，则按字符串自己的规则排序(自然排序)
TreeSet<Person> ts2 = new TreeSet<Person>(new ComparatorByName());
//TreeSet<Person> ts2 = new TreeSet<Person>();
ts2.add(new Person("aaa", 21));
ts2.add(new Person("nbaq", 21));
ts2.add(new Person("ca", 21));
ts2.add(new Person("ac", 21));
ts2.add(new Person("aaa", 22));//按名字(字符串)自己的规则排序，若名字相同按年龄由小到大排序
ts2.add(new Person("aaa", 21));//重复的元素，不允许
System.out.println(ts2);//[aaa,21, aaa,22, ac,21, ca,21, nbaq,21]。若不指定比较器，结果为[aaa,21, aaa,22]
Hash系列集合
// 对于Hash系列的集合，是调用Key的 equals【和】hashCode方法
Map<Person, Integer> map = new HashMap<Person, Integer>();
map.put(new Person("ca", 21), 1);
map.put(new Person("ca", 23), 3);//equals相同，但hashCode不同，当做不同的对象
map.put(new Person("aaa", 22), 2);
map.put(new Person("z", 26), 4);
System.out.println(map.put(new Person("ac", 400), 5));//null
System.out.println(map.put(new Person("ac", 500), 6));//5。equals和hashCode都相同，当做同一Key，把之前的【Value】替换掉，注意【Key】并没有变！
for (Person key : map.keySet()) {
Integer value = map.get(key);
System.out.print("【" + key.toString() + "-" + value + "】");//【aaa,22-2】【ac,400-6】【ca,23-3】【z,26-4】【ca,21-1】
}
去除List中重复元素
// 去除ArrayList中的重复元素
public static <T> ArrayList<T> getSingleElement(ArrayList<T> al) {
ArrayList<T> temp = new ArrayList<T>();
Iterator<T> it = al.iterator();
while (it.hasNext()) {
T obj = it.next();
//判断被迭代到的元素是否在临时容器存在
if (!temp.contains(obj)) temp.add(obj);
}
return temp;
}
比较器
//按字符串长度排序
class ComparatorByLength implements Comparator<String> {
public int compare(String s1, String s2) {
int temp = s1.length() - s2.length();
return temp == 0 ? s1.compareTo(s2) : temp;//按字符串长度由短到长排序，如果长度相同，则按字符串自己的规则排序(自然排序)
}
}
//按Person名字排序
class ComparatorByName implements Comparator<Person> {
public int compare(Person p1, Person p2) {
int temp = p1.name.compareTo(p2.name);
return temp == 0 ? p1.age - p2.age : temp;//按名字(字符串)自己的规则排序，若名字相同按年龄由小到大排序
}
}
具有比较功能的Bean
class Person implements Comparable<Person> {
//Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public int compareTo(Person p) {
return this.age - p.age;//按年龄由小到大排序
}
public int hashCode() {
int newAge = this.age;
if (age > 150) newAge = 150;
return name.hashCode() + newAge;//这里的hashCode是基于String类的hashCode更改的
}
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof Person)) return false;
Person p = (Person) obj;
return this.name.equals(p.name);//注意：是【先】判断hashCode是否相同，【再】判断equals是否为true
}
public String toString() {
//默认返回值是【person.getClass().getName() + ‘@‘ + Integer.toHexString(person.hashCode())】
return name + "," + age;
}
}
附件列表
时间： 2024-10-10 14:59:11