Map中通过containsKey()方法和containsValue()方法来判断键和值是否存在 

Map 中对对象进行了 Key 标记，通过 get（Key）可以取得对应的对象

 Map 的containsValue（）方法的参数是 Object 对象，因为Map 的 Value 值是对象元素

 Map 的containsKey（）方法取得 Map 映射的 Key 值 

跟List中的Contains()方法一样，Map中的ContainsValue()方法也需要调用某个Value值的equals()方法，去和参数对象进行比较，如果匹配成功，返回结果为true，说明在Map中的Value值确实包含参数对象。因此，需要重写Student类的equals()方法。

public void testContainKeyOrValue() {

System.out.println("请输入学生的ID");

Scanner input =new Scanner(System.in);

String id = input.next();

System.out.println("你输入的学生id为："+id+",在学生隐射表里面是否存在："+student.containsKey(id));

if (student.containsKey(id))

System.out.println("对应的学生为："+student.get(id).name);

System.out.println("请输入学生姓名：");

String name =input.next();

if(student.containsValue(new Student(null,name)))

System.out.println("在学生映射表里是存在学生："+name);

else

System.out.println("不存在该学生");

}

java.util.Calendar 类是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();

List集合查询某元素的索引位置，使用集合.indexof(对象)方法。此方法查询的是该集合中第一次出现此对象的位置。.lastindexof(对象)查询的是该集合最后一次出现此对象的位置索引。于contains()方法类似，在查询时都是在调用集合中每个对象的equals()方法来比较二者是否相同。若此集合没有与参数相等的对象，则返回-1。

indexOf()实现机制:

System.out.println("备选课程里是否包含课程"+ca1.name+"的索引位置为"+causetolist.indexOf(ca2));

当调用hashSet的contains方法时，其实是遍历每个元素，然后调用了hashCode()方法，返回哈希码，如果哈希码相等，再调用equals()方法，如果equals()方法也返回true，才算相等

判断set中的课程是否存在？ 使用set中的contains方法，set中调用contains（obj）方法，contains方法的实现机制：先调用object中的hashcode方法，再调用object中的equals方法。所以要对对象的hashcode（）方法和equals方法重写，可以使用eclipse中的source>GENARATE hashcode（），在对象的类中，实现方法的重写。

public void testSudenttoCause() {

student1 = new Student("1","CBB");

for(int i=0;i<3;i++){

System.out.println("请输入你要选课的id");

Scanner input = new Scanner(System.in);

String str = input.next();

for(Cause ca :causetolist) {

if(str.equals(ca.id)) {

student1.cause.add(ca);

}

}

}

}

public void testSetEquals() {

System.out.println("请学生输入已选择的课程：");

String name = input.next();

Cause cause =new Cause() ;

cause.name=name;

System.out.println("备选课程里是否包含课程"+cause.name+":"+student1.cause.contains(cause));

}

HashMap类

Map接口

3. 使用 substring(beginIndex , endIndex) 进行字符串截取时，包括 beginIndex 位置的字符，不包括 endIndex 位置的字符

2、 一旦一个字符串在内存中创建，则这个字符串将不可改变。如果需要一个可以改变的字符串，我们可以使用StringBuffer或者StringBuilder（后面章节中会讲到）。

创建String对象的方法： String s1="imooc";//创建一个字符串对象imooc，名为s1 String s2=new String();//创建一个空字符串，名为s2 String s3=new String("imooc");//创建一个字符串对象imooc，名为s3

1. 字符串 str 中字符的索引从0开始，范围为 0 到 str.length()-1

2. 使用 indexOf 进行字符或字符串查找时，如果匹配返回位置索引；如果没有匹配结果，返回 -1

3. 使用 substring(beginIndex , endIndex) 进行字符串截取时，包括 beginIndex 位置的字符，不包括 endIndex 位置的字符

contains会调用object中的equals方法，所以需要在继承类中重写equals方法即可

如何判断List或者Set集合中是否包括某个实例对象——contains()

（1）contains的原理是分别调用每个元素的equals方法；

因此只需要在课程类里重写equals方法，就可以通过contains判断是否包含名称为某个值的元素

（2）java中的数据类型，可分为两类：

1. 基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean

他们之间的比较，应用双等号（==）,比较的是他们的值。

2. 复合数据类型(类)

当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。

JAVA当中所有的类都是继承于Object这个基类的，

在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的【内存地 址】，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

（3）

对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。

JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

CausetoSet.java:

public  void testListContain() {

Cause ca1 = causetolist.get(0);

System.out.println("取出课程"+ca1.name);

Cause ca2 = new Cause("1","高代");

System.out.println("备选课程里是否包含课程"+ca1.name+":"+causetolist.contains(ca2));

}

Cause.java中重写equals方法，可以Source直接快捷键，

public  void testListContain() {

Cause ca1 = causetolist.get(0);

System.out.println("取出课程"+ca1.name);

Cause ca2 = new Cause("1","高代");

System.out.println("备选课程里是否包含课程"+ca1.name+":"+causetolist.contains(ca2));

}

Cause.java中重写equals方法，可以Source直接重写

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)//null不是一个对象，也不是Object的实例。

return false;

if (getClass() != obj.getClass())

return false;

Cause other = (Cause) obj;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

@Override

public boolean equals(Object obj) {

if(this==obj) 

return true;

if(obj==null) 

return false;

if(!(obj instanceof Cause)) 

return false;

Cause cause =(Cause) obj;

if(this.name==null) {

if (cause.name==null) 

return true;

else 

return false;

}else {

if(this.name==cause.name)

return true;

else

return false;

}

}

Java中基本类型和包装类之间的转换

①装箱：把基本类型转换成包装类，使其具有对象的性质，又可手动装箱 new 和自动装箱 直接赋值

②拆箱：把包装类对象转换成基本类型的值，又可分为手动拆箱 intValue()和自动拆箱 直接赋值

泛型：规定集合中元素的类型  例子：public LIst<Course> courses；list集合中只能存放Course的元素，取出的时候不用进行类型转换。

public void testModify() {

Scanner input = new Scanner(System.in);

while(true) {

System.out.println("请输入你要修改的id");

String id = input.next();

Student stu = student.get(id);

if(stu==null) {

System.out.println("输入的id的学生不存在");

continue;

}

System.out.println("当前学生的名字"+stu.name);

System.out.println("请输入修改名字：");

String name = input.next();

stu.name = name;

student.put(id, stu);

break;

}

}

public void testRemove() {

Scanner input = new Scanner(System.in);

while(true) {

System.out.println("你要删除的学生id：");

String str = input.next();

Student stu = student.get(str);

if(stu==null) {

System.out.println("该id不存在！");

continue;

}

student.remove(str);

System.out.println("删除学生"+stu.name+"成功");

break;

}}

public void testPrint1() {

Set<Entry<String,Student>> entry = student.entrySet();

for (Entry<String, Student> entry2 : entry) {

System.out.println("取得的键为："+entry2.getKey());

System.out.println("取得的值为："+entry2.getValue().name);

}

}

public void testPrint2() {

Collection<Student> stu = student.values();

for (Student student : stu) {

System.out.println(student.name);

}

}