Map集合及异常机制

学习目标：

1.Comparator接口的使用；

2.Map集合。

一、Comparator接口的使用

此接口定义排序只能按照compareTo()定义的排序规则；

如果同一类对象要有多种排序方式，应该为该类定义不同的比较器(实现Comparator接口的类)TreeSet有一个构造方法允许给定比较器，它就会根据给定的比较器对元素进行排序

eg：package comparator;
public class Girl {
private String name;
private int face;
private double money;
public Girl() {
}
public Girl(String name, int face, double money) {
super();
this.name = name;
this.face = face;
this.money = money;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getFace() {
return face;
}
public void setFace(int face) {
this.face = face;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
     @Override
public String toString() {
return "Girl [name=" + name + ", face=" + face + ", money=" + money
+ "]";
}
}

//facerule

package comparator;

import java.util.Comparator;
// 以face为第一排序规则
public class FaceRule implements Comparator<Girl>{

@Override
public int compare(Girl g1, Girl g2) {
if(g1.getFace()>g2.getFace()){
return -1;
}else if(g1.getFace()<g2.getFace()){
return 1;
}else{
if(g1.getMoney()>g2.getMoney()){
return -1;
}else if(g1.getMoney()<g2.getMoney()){
return 1;
}else{
return g1.getName().compareTo(g2.getName());
}
}
} 
}

//moneyrule

package comparator;


import java.util.Comparator;
// 以money为第一排序规则
public class MoneyRule implements Comparator<Girl>{


@Override
public int compare(Girl g1, Girl g2) {
if(g1.getMoney()>g2.getMoney()){
return -1;
}else if(g1.getMoney()<g2.getMoney()){
return 1;
}else{
if(g1.getFace()>g2.getFace()){
return -1;
}else if(g1.getFace()<g2.getFace()){
return 1;
}else{
return g1.getName().compareTo(g2.getName());
}
}
} 
}

//test

package comparator;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<Girl> ts1=new TreeSet<Girl>(new FaceRule());
ts1.add(new Girl("小红",80,20.5));
ts1.add(new Girl("小草",99,1.1));
ts1.add(new Girl("小翠",60,20.5));
ts1.add(new Girl("小娟",80,60.5));
ts1.add(new Girl("小花",40,50.5));
System.out.println("以face为第一标准：");
for(Girl g:ts1){
System.out.println(g);
}
System.out.println("********************************");
System.out.println("以money为第一标准：");
TreeSet<Girl> ts2=new TreeSet<Girl>(new MoneyRule());
ts2.add(new Girl("小红",80,20.5));
ts2.add(new Girl("小草",99,1.1));
ts2.add(new Girl("小翠",60,20.5));
ts2.add(new Girl("小娟",80,60.5));
ts2.add(new Girl("小花",40,50.5));
for(Girl g:ts2){
System.out.println(g);
}
}
}

二、Map集合

 实现Map接口的集合类用来存储“键-值”映射对。不能把包含重复的键，但值可有多个。

Map接口方法：

eg:package map;
import java.util.*;
import java.util.Map.Entry;
public class HashMapDemo {
public static void main(String[] args) {
HashMap<String,String> map=new HashMap<>();
map.put(null,null);
map.put("apple","苹果");
map.put("sport","足球");
map.put("car","宝马汽车");
map.put("country","中国");
System.out.println("现在map集合中共有键值对："+map.size());
System.out.println("删除之前：key为sport的元素值："+map.get("sport"));
map.remove("sport"); 
System.out.println("删除之后：key为sport的元素值："+map.get("sport"));
System.out.println("包括key为car的键值对吗？"+map.containsKey("car"));
System.out.println("包括key为animal的键值对吗？"+map.containsKey("animal"));
System.out.println("包括value为\"宝马汽车\"的键值对吗？"+map.containsValue("宝马汽车"));
Set<String> keys=map.keySet();   // 获取所有的key
System.out.println("所有的key是：");
for(String key:keys){
System.out.print(key+"  ");
}
System.out.println();
System.out.println("所有的value是：");
Collection<String> values=map.values();
for(String value:values){
System.out.print(value+"  ");
}
System.out.println();
System.out.println("*********遍历整个map集合**************");
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for(Map.Entry<String, String> me:entrySet){
System.out.println(me.getKey()+"========>"+me.getValue());
}
}
}

（1）HashMap类:散列存放

（2）TreeMap类:“key-value”中的“key”是可“排序”的。

（3）Map.Entry接口Map中内部定义的一个接口，专门用来保存“key-value”的内容。

(4)Hashtable类：

只有一个子类Properties(属性集)

线程同步；不可存储null键或null值；多线程操作下环境效率低。HashMap与其相反。

使用 setProperty(String key,String value)方法，因为存放的“键-值”对都是字符串

取值也应该使用getProperty(Stringkey)。

package map;
import java.util.Properties;
public class PropertiesDemo {
public static void main(String[] args) {
Properties pro=new Properties();
pro.setProperty("oper","linux");
pro.setProperty("time","2018");
pro.setProperty("vip","yes");
System.out.println(pro.getProperty("vip"));
System.out.println(pro.getProperty("abc","没有找到对应的属性名，这是默认值"));
}
}

学习目标：

1.异常的概念与原理；

2. 异常的分类；

3. 处理异常的方法；

4.自定义异常。

一、异常的概念与原理

  （1）定义：

异常是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序。

try: 执行可能产生 异常的代码。

catch:捕获异常。

finally：无论是否发生异常，代码总能执行。

throws：声明方法可能要抛出的各种异常。

throw:手动抛出异常对象。

（2）编译运行中所发生的的两大问题：

错误 (Error) ： JVM 系统内部错误或资源耗尽等严重情况－属于 JVM 需要负担的责任；

异常 (Exception) ：其它因编程错误或偶然的外在因素导致的一般性问题。

程序员通常只能处理异常(Exception)，而对错误(Error)无能为力。

（3）异常处理机制原理： Java 程序在执行过程中如果出现异常，会 自动生成一个异常类对象 ，该异常对象将被自动提交给 JVM( 在程序没有显式处理异常的情况下 ) ，这个过程称为抛出 (throw) 异常。

二、异常分类：

（1）常见异常：

a. RuntimeException

b. ArithmeticException ：数学计算异常

c. NullPointerException ：空指针异常

d. ArrayOutOfBoundsException ：数组索引越界异常

e. ClassCastException ：类型转换异常

f. SQLException

g. IOException

h. ClassNotFoundException

（2）Exception与RuntimeException区别：

Exception 在程序中是必须进行处理

RuntimeException 可以不使用 try…catch 进行处理，但是如果有异常产生，则异常将由 JVM 进行处理。

三、处理异常方法

（1） 使用 try-catch 块捕获异常， catch 块可以有多个代码段；

eg：package exception;
import java.io.IOException;
public class CheckException {
public static void main(String[] args) {
Runtime r=Runtime.getRuntime();
try {
r.exec("calc");
} catch (IOException e) {
e.printStackTrace();
}
}
}

（2）try-catch-finally: 在 try-catch 块后加入 finally 块

 是否发生异常都执行,不执行的唯一情况

eg：

package exception;
public class Finally {
public static void main(String[] args) {
int result=method();
System.out.println("结果是："+result);
}
public static int method(){
try{
int a=100;
int b=1;
int c=a/b;
return c;
}catch(Exception e){
System.out.println("发生异常啦...");
}finally{
return 999;
}
}
}

(3)多重catch: 排列 catch 语句的顺序：先子类后父类,

          发生异常时按顺序逐个匹配

         只执行第一个与异常类型匹配的 catch 语句

(4)try-finally不能捕获异常，仅用来当发生异常时，用来释放资源。

eg：

package exception;
public class RuntimeExceptionDemo {
public static void main(String[] args) {
int a=100;
int b=0;
String str=null;
int[] array=new int[5];
try{
array[5]=100;
str.equals("abc");
int c=a/b;
}catch(NullPointerException e){
System.out.println("空指针异常~~~");
}catch(ArithmeticException e){
System.out.println("算数异常~~~");
}catch(Exception e){
System.out.println("以上catch都没有捕获到异常，由最大父类Exception处理异常");
}finally{
System.out.println("无论异常是否发生，都会执行");
}

System.out.println("main()方法执行完毕！");
}
}

（5）throw与throws区别：

 1.throw用来手动抛出异常对象。

 2.throws用于方法声明处，用于抛出该方法体内部可能发生的异常类型。一旦在方法声明处通过throws抛出某种类型的异常，则在该方法体内部就不用处理该类型的异常,交给方法调用处处理该类型的异常。

四、自定义异常

   继承自 Exception 。习惯上包装一下父类的构造方法。

格式：

public class MyException extends Exception {

    public MyException() {

    super();

    }

    public MyException(String msg) {      

            super(msg);   

    }

}

eg：

package throwdemo;
import java.io.IOException;
public class ThrowDemo {
public static void main(String[] args) {
try{
throw new ArithmeticException(); //throw手动抛出异常对象
}catch(Exception e){
System.out.println("发生算数异常了...");
}
int a=100;
System.out.println("end....");


}


}