装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱

创建Integer包装类对象，表示变量score1的值

Integer score2=new Integer（score1）；

将Integer包装类转换为double类型

double score3=score2.doubleValue（）；

将Integer包装类转换为float类型

float score4=score2.doubleValue( );

将Integer包装类转换为int类型

int score5=score2.intValue（）；

Exception 的父类是 Throwable

使用 try-catch-finally 语句捕获并处理异常

可以使用 throw 语句抛出异常

捕获到的异常，可以在当前方法的 catch 块中处理，也可抛出给调用者去处理

catch 块跟在 try 语句后面，它可以是一个或多个

catch 块有一个参数，该参数是某种异常类的对象

多重 catch 语句中，异常类型必须子类在前父类在后

在需要频繁对字符串进行修改操作时使用 StringBuilder 的效率比 String 要高

String 类常用方法2：

String s = "java";

s.toUpperCase();把小写字母转换为大写字母

s.toLowerCase();把大写字母转换为小写字母

s.charAt（1）；获取索引值为1的字符

byte b[ ] = s.geyBytes(); 转换为字节数组

String类的常用方法：

String  name = “HelloWorld.java”;

name.length(); 返回的是字符串的长度

name.indexOf(".");返回的是“.”的第一次出现位置

// 注意：返回的是数组中的位置，而不是数出来的位置

name.lastIndexOf("a");返回的是“a”最后一次出现的位置

String prefix= name.substring(1);返回的是从数组1开始到结束的字符串

String prefix= name.substring(1，7);返回的是从数组1开始到6的字符串

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

遍历  keySet  返回是key
     entrySet  返回是键值对
修改 put方法  只需将value中的name更改
添加  put方法
删除   remove(key)

代码如下：http://www.imooc.com/article/16598

put()方法，若添加的entry中的键在该映射中不存在映射关系，则添加；若添加的entry中的键在该映射中已有映射关系，则用新的value替代原来的value！

Map增删改查：
增：map的put(key,value)方法添加。
查：1.利用keyset()方法获得Map中key的集合，再遍历key的集合，利用Map的get(key)方法得到key对应的value值。
2.利用EntrySet方法获取May中Entry对象集：然后用foreach遍历集，再用Entry集的getkay()和getvalue()方法得到每一个key值和value值。
删：remove(object key)
改：put(原有的key,新的value)
通过entrySet可以返回Map中的所有键值对
Set<Entry<String,Student>>entrySet = students.entrySet();

Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法

keyset()返回Map中所有的key以集合的形式可用Set集合接收，返回所有键的Set集合。
取得Map的容量可用size()方法。

public class MapTest {
public Map<String,Student> students;
public MapTest(){
this.students=new HashMap<String,Student>();
}
public void testPut(){
Scanner console = new Scanner(System.in);
int i=0;
while(i<3){
System.out.println("请输入学生id：");
String ID =console.next();
Student st = students.get(ID);
if(st==null){
System.out.println("请输入学生姓名：");
String name = console.next();
Student newStudent =new Student (ID,name);
students.put(ID,newStudent);
System.out.println("成功添加学生："+students.get(ID).name);
i++;

}else{
System.out.println("该学生已被占用");
continue;
}
}
}
public void testKeySet(){
Set<String> keySet =students.keySet();
System.out.println("总共有："+students.size()+"个学生！");
for(String stuId:keySet){
Student st=students.get(stuId);
if(st!=null)
System.out.println("学生："+st.name);
}
}
public static void main(String[] args) {
MapTest mt=new MapTest();
mt.testPut();
mt.testKeySet();
}
}

Map接口
1. Map接口提供了一中映射关系，其中的元素是键值对（key-value）的形式存储的，能够实现根据Key快速查找value。Key-value可以是任何对象，是以Entry类型的对象实例存在的。
2.Key是不可以重复的，Value是可以重复的。Key-value都可以为null，不过只能有一个key是null。
3.map支持泛型，Map<K,V>
4.每个键最多只能映射到一个值
5.Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法
6.通过put<K key,V value>,remove<Object key>操作数据
7.HashMap中的Entry对象是无序排列的，HashMap是Map的一个重要实现类，也是最常用的，基于哈希表是实现

1、List<>()这是一个有序序列。因为List是一个接口，并不能实例化。因此我们需要将用Arraylist来实现。
2、Arraylist是一个数组序列也是list的一个重要的实现类，用来执行list的增删改查等。
List<>() a=new Arraylist<>(); 或者通过构造参数的形式实现。
3、在现实开发当中，课程等成员变量是私有化的，需要用get（）和set（）方法。
4、对象被存入集合都变成object类型了 取出时需要类型强转。但在List<类型>()声明了类型的就只能存入该类型的数据，并且提取时也只会是该类型，不用强转。
例：Course temp = (Course)coursesToSelect.get(0);//强转
5、调用Add()方法添加到List中。有两种方法：
a) 直接添加，例：CoursesToSelect.add(cr1);
b) 可以指定添加的位置，例：CoursesToSelect.add(0,cr1);
6、如果添加到List中的长度大于他目前的长度，则系统会出现异常，即数组下表越界异常
7、list中还有addAll(List list)
就是将一个List里面的元素一股脑的全都加进去
一般定义一个数组，如何把一个数组转换成List？ 调用方法Arrays.asList(Object[] obs);//可以将一个数组转换为一个List，然后可以将这个元素传进addAll()里面
当然还有addAll（index,List list）方法
8、迭代器只是用来遍历集合中的元素，本身不具备任何存储元素的功能，换而言之，迭代器是依赖于某个集合而存在的，本身不能独立存在。
读取元素三种方法：
a)for（）
b)Iterator是一个接口,依赖于集合存在的
Iterator it=courseToSelect.iterator();
while(it.hasNext()){} //迭代
c)foreach
9、使用set（index,Object element）修改元素，index表示索引位置，element表示新对象。

Set接口及其实现类——HashSet
Set是元素无序并且不可以重复的集合，被称为集；
HashSet——哈希集，是Set的一个重要实现类。
1、Set没有像List中set()方法一样就修改，因为List是有序的，可以指定位置，而Set是无序的。
2、查询遍历时，Set不能用get()方法去获取，因为无序没有指定索引ID，但可以使用foreach和iterator来遍历，但是每次遍历出来可能顺序都不一样，还是因为无序造成的。
3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。
4、Set还可以添加null；无序演示（如图）

collection存储的是一个个对象

Map是以<Key,Value>存储

总结关于list类型的一下用法：

泛型中除了可以添加规定的类型还可以添加规定类型的子类型。
定义子类型的时候要在父类型中添加一个无参的构造方法，否则出错，因为调用子类型的构造方法时，系统会默认调用父类的无参构造方法（super();）。
1.泛型集合中不能使用基本数据类型List<int>course。必须为引用类型List<Course> course
2.可以通过使用包装类限定允许存入的基本数据类型。

1.创建对象
List list = new ArrayList();
2.向list对象中添加数据
（1）Course crre = new Course("1","数据结构");//一个类的对象
list.add(crre);//将对象添加到list中
（2）Course[] crre = {new Course("",""),new Course("","");//对象的数组
list.addAll(0,Arrays.asList(course));//切记Arrays.asList方法
3.获取集合中的元素
（1）Course temp = (Course)list.get(0);//注意强转
（2）Iterator it = list.iterator();
while(it.hasNext()){
Course cr = (Course)it.next();//迭代遍历，使用iterator方法
}
（3）for(Object obj:list){
Course cr = (Course)obj;
}//foreach方法 ，注意Object的使用
4.集合中参数的修改
list.set(2,new Course("",""));
5.集合中数据的删除
(1)list.remove(位置）;
(2)Course[] crr = {(Course)list.get(位置）(Course)list.get(位置）}；
list.removeAll(Arrays.asList(crr));//参考addAll
6.带有泛型的list
List<Course> course = new ArrayList<Course>();//相当于添加进去的元素有了具体类型，不再是Object
7.list可以添加子类型的对象
8.list不能直接添加基本类型（int,float等）的对象，如果要添加，需要使用其包装类