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{

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

}

//moneyrule

package comparator;


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


@Override
public int compare(Girl g1, Girl g2) {
if(g1.getMoney()>g2.getMoney()){
return -1;
}else if(g1.getMoney()return 1;
}else{
if(g1.getFace()>g2.getFace()){
return -1;
}else if(g1.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 ts1=new TreeSet(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 ts2=new TreeSet(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 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 keys=map.keySet();   // 获取所有的key
System.out.println("所有的key是:");
for(String key:keys){
System.out.print(key+"  ");
}
System.out.println();
System.out.println("所有的value是:");
Collection values=map.values();
for(String value:values){
System.out.print(value+"  ");
}
System.out.println();
System.out.println("*********遍历整个map集合**************");
Set> entrySet = map.entrySet();
for(Map.Entry 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....");


}


}






你可能感兴趣的:(java)