假设现在一个学生类,有学号和姓名,我现在hashcode方法重写的时候,只将学号
时间: 2023-06-27 15:02:11 浏览: 105
作为计算hashcode的因子,而不考虑姓名,这样会有什么问题呢?
在hashcode方法中只考虑学号而不考虑姓名,可能会导致两个不同的学生对象却具有相同的hashcode值。这种情况被称为“哈希冲突”。如果两个学生对象的学号相同,但姓名不同,那么它们的hashcode值将相同,这样就会导致它们被放在同一个hash桶中,而这样会影响程序的性能。因此,在设计hashcode方法时,应该尽量考虑对象的所有属性,以便尽量减少哈希冲突的发生。
相关问题
Java详细代码创建一个学生类,每个学生有学号、姓名、年龄信息,输入5个学生信息,输出去重后的3个学生信息。重写学生类的eqauls、hashCode函数,使用HashSet去重
好的,下面是Java代码:
```java
import java.util.HashSet;
public class Student {
private String id; // 学号
private String name; // 姓名
private int age; // 年龄
public Student(String id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
// 重写equals方法
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
Student student = (Student) obj;
return id.equals(student.id) && name.equals(student.name) && age == student.age;
}
// 重写hashCode方法
@Override
public int hashCode() {
int result = id.hashCode();
result = 31 * result + name.hashCode();
result = 31 * result + age;
return result;
}
public static void main(String[] args) {
HashSet<Student> set = new HashSet<>();
set.add(new Student("20210001", "张三", 18));
set.add(new Student("20210002", "李四", 19));
set.add(new Student("20210003", "王五", 20));
set.add(new Student("20210001", "张三", 18)); // 重复的学生信息
set.add(new Student("20210004", "赵六", 21));
set.add(new Student("20210002", "李四", 19)); // 重复的学生信息
// 去重后的学生信息
System.out.println("去重后的学生信息:");
for (Student student : set) {
System.out.println(student.id + "\t" + student.name + "\t" + student.age);
}
}
}
```
以上代码创建了一个学生类,重写了equals方法和hashCode方法,使用HashSet去重学生信息。在main方法中,我们创建了5个学生信息,其中有两个学生信息是重复的。最后输出去重后的3个学生信息。
java程序设计 1) 定义学生类,成员变量:姓名、学号; 2) 定义测试类,在main方法中创建学生对象s1,姓名为“张三”,学号为“1”;创建学生对象s2,姓名为“张三”,学号为“1”,比较s1和s2 是否相同?用==还是用equals()?观察运行结果,并分析结果; 3) 如要求,当两个学生的姓名和学号相同时,比较结果为true,该如何设计?设计代码后,再比较s1和s2,观察结果,并分析; 4) 重写hashCode方法,当两个学生对象的姓名和学号相同时,它们的hashCode也相同; 5) 在main方法中需要输出学生对象的信息,代码该如何设计(提示:toString( )方法)
1)学生类的代码如下:
```java
public class Student {
private String name; // 学生姓名
private String id; // 学生学号
public Student(String name, String id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public String getId() {
return id;
}
public void setName(String name) {
this.name = name;
}
public void setId(String id) {
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", id='" + id + '\'' +
'}';
}
}
```
2)测试类的代码如下:
```java
public class Test {
public static void main(String[] args) {
Student s1 = new Student("张三", "1");
Student s2 = new Student("张三", "1");
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // false
}
}
```
运行结果为false,因为s1和s2虽然属性值相同,但是它们是两个不同的对象,所以用==比较返回的结果是false。同样地,用equals()方法比较也返回false,因为默认情况下equals()方法比较的是两个对象的内存地址。
3)如果要求当两个学生的姓名和学号相同时比较结果为true,可以重写equals()方法,如下所示:
```java
public class Student {
//...
@Override
public boolean equals(Object obj) {
if(obj == null) {
return false;
}
if(this == obj) {
return true;
}
if(obj instanceof Student) {
Student s = (Student)obj;
if(this.name.equals(s.name) && this.id.equals(s.id)) {
return true;
}
}
return false;
}
}
```
重新运行main方法,观察结果如下:
```java
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true
```
可以看到,用equals()方法比较返回的结果是true,因为重写后的equals()方法比较的是两个对象的属性值。
4)重写hashCode()方法,如下所示:
```java
public class Student {
//...
@Override
public int hashCode() {
return Objects.hash(name, id);
}
}
```
这里使用了Objects类的静态方法hash(),该方法可以接受任意数量的参数,并生成一个哈希值。
5)要输出学生对象的信息,可以在Student类中重写toString()方法,如下所示:
```java
public class Student {
//...
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", id='" + id + '\'' +
'}';
}
}
```
然后在测试类中调用toString()方法输出学生对象的信息,如下所示:
```java
System.out.println(s1.toString());
System.out.println(s2); // 等同于System.out.println(s2.toString());
```
输出结果为:
```
Student{name='张三', id='1'}
Student{name='张三', id='1'}
```
阅读全文