Java day 16-17

Day16

Map集合

1.Map 一个根接口，几个实现类HashMap Hashtable TreeMap

采用多态的方式创建对象

ctrl+1 提示出来选第一个 自动补全

Map<String, String> hm = newHashMap<String, String>();

存储数据put方法放置数据

第一次采用put 放置数据的时候返回的是null

第二次放置键相同的数据会返回上一次的值

功能：

删除功能

void clear():移除所有的键值对元素。

V remove(Object key)：根据键删除键值对元素，并把值返回。

2.HashMap

HashMap<key,value> hm = newHashMap<key,value>();

HashMap 底层数据结构哈希表 特点:元素无序且唯一 元素唯一 是靠元素重写 equlse方法和hashCode方法。

功能：

1.判断功能

boolean containsKey(Object key)：判断集合是否包含指定的键

boolean containsValue(Object value):判断集合是否包含指定的值

boolean isEmpty()：判断集合是否为空

2.获取功能

Set<Map.Entry<K,V>> entrySet():返回一个键值对的Set集合

V get(Object key):根据键获取值

Set<K> keySet():获取集合中所有键的集合

Collection<V> values():获取集合中所有值的集合

Set<K> keySet():获取集合中所有键的集合

V get(Object key):根据键获取值

Map 集合的数据结构只跟键有关 跟值没关系

Entry<K,V> 键值对对象 ,把键和值封装起来看做一个对象

getKey()返回与此项对应的键。

V getValue()返回与此项对应的值。

例题：

HashMap集合键是Integer值是Student的案例

importjava.util.HashMap;

importjava.util.Map.Entry;

importjava.util.Set;

public class MapDemo {

    public static void main(String[] args) {

        HashMap<Integer,Student> hm =newHashMap<Integer, Student>();

        hm.put(1,new Student("Tom", 21));

        hm.put(2,new Student("Tom", 22)); // 键相同值覆盖

        hm.put(3,new Student("Anny", 22));

        hm.put(4,new Student("Green", 23));

        hm.put(5,new Student("lucy", 21));

        System.out.println(hm);

        // 方法1

        Set<Integer>keySet = hm.keySet();

        for (Integer key : keySet) {

            System.out.println(key+"  "+hm.get(key).getName()+"  "+ hm.get(key).getAge());

        }

        // 方式2

    System.out.println("------------------------------------------------");

        Set<Entry<Integer,Student>> entrySet = hm.entrySet();

        for (Entry<Integer, Student> en :entrySet) {

            Integerkey = en.getKey();

            Students = en.getValue();

            System.out.println(key + "         "+ s.getName() + "         "+ s.getAge());

        }

    }

}

importjava.io.Serializable;

public class Studentimplements Serializable, Comparable<Student> {

    private static final longserialVersionUID = 1L;

    private String name;

    private int age;

    public Student() {

        super();

        // TODO Auto-generated constructor stub

    }

    public Student(String name,int age) {

        super();

        this.name= name;

        this.age= age;

    }

    public String getName() {

        return name;

    }

    public voidsetName(String name) {

        this.name= name;

    }

    public intgetAge() {

        return age;

    }

    public voidsetAge(intage) {

        this.age= age;

    }

    @Override

    public String toString() {

        return "Student[name=" + name+ ", age="+ age + "]";

    }

    @Override

    public inthashCode() {

        final intprime = 31;

        int result = 1;

        result= prime * result + age;

        result= prime * result + ((name==null)? 0 : name.hashCode());

        return result;

    }

    @Override

    public booleanequals(Object obj) {

        if (this == obj)

            return true;

        if (obj ==null)

            return false;

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

            return false;

        Studentother = (Student) obj;

        if (age!= other.age)

            return false;

        if (name==null){

            if (other.name !=null)

                return false;

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

            return false;

        return true;

    }

    @Override

    public intcompareTo(Student stu) {

        // 年龄相同不能说明是同一个人

        int num =this.age- stu.age;

        // 如果年龄相同,比较姓名

        int result = num == 0 ?this.name.compareTo(stu.name) : num;

        return result;

    }

}

3. LinkedHashMap

LinkedHashMap的概述:Map接口的哈希表和链接列表实现，具有可预知的迭代顺序

LinkedHashMap的特点：底层的数据结构是链表和哈希表，元素有序并且唯一

元素的有序性由链表数据结构保证唯一性由哈希表数据结构保证

LinkedHashMap<key,value>map=newLinkedHashMap<key,value>();

有序:指的是存的顺序跟取的顺序一致

例题：

public class LinkedHashMapDemo{

    public staticvoid main(String[] args) {

        LinkedHashMap<Integer,String> map = new LinkedHashMap<Integer, String>();

        map.put(1,"Tom");

        map.put(5,"Anny");

        map.put(6,"Green");

        map.put(3,"Lucy");

        map.put(2,"Orange");

        map.put(4,"Grey");

        //第二种方式遍历

        Set<Entry<Integer,String>> entrySet = map.entrySet();

        for(Entry<Integer, String> en : entrySet) {

            Integerkey = en.getKey();

            Stringvalue = en.getValue();

            System.out.println(key+ "    " + value);

        }

    }

}

4.TreeMap

TreeMap：数据结构是红黑树

特点:元素唯一,而且还能对元素进行排序 :自然排序和比较器排序

排序的元素必须实现Comparable接口 重写 CmcompareTo(T)

TreeMap<key,value> treeMap = newTreeMap< key,value>();

TreeMap 不允许插入null键

例题：

import java.util.Set;

import java.util.TreeMap;

public class TreeMapDemo {

    publicstatic void main(String[] args) {

        TreeMap<Integer,String> map = new TreeMap<Integer, String>();

        map.put(1,"关羽");

        map.put(2,"张飞");

        map.put(0,"刘备");

        map.put(3,"赵云");

        Set<Integer>keySet = map.keySet();

        for(Integer key : keySet) {

            System.out.println(key+ "---" + map.get(key));

        }

    }

}

5. HashMap和Hashtable的区别: 查看API可以知道

HashMap: 线程不安全,效率高.允许null值和null键

Hashtable: 线程安全 , 效率低.不允许null值和null键

6.集合嵌套

1) HashMap嵌套HashMap

例:案例

    基础班

        张三 ---20

        李四 ---22

    就业班

        王五--- 21

        赵六 ---23

import java.util.HashMap;

import java.util.Set;

public class MapDemo {

    publicstatic void main(String[] args) {

        //先创建两个小集合

        HashMap<String,Integer> jcMap = new HashMap<String, Integer>();

        jcMap.put("张三", 21);

        jcMap.put("李四", 22);

        HashMap<String,Integer> jyMap = new HashMap<String, Integer>();

        jyMap.put("王五", 24);

        jyMap.put("赵六", 23);

        //创建一个大集合

        HashMap<String,HashMap<String, Integer>> bigMap = new HashMap<String,HashMap<String, Integer>>();

        bigMap.put("基础班", jcMap);

        bigMap.put("就业班", jyMap);

        Set<String>keySet = bigMap.keySet();

        for(String bigkey : keySet) {

            System.out.println(bigkey);

            //取出每一个小集合

            HashMap<String,Integer> hashMap = bigMap.get(bigkey);

            Set<String>minSet = hashMap.keySet();

            for(String minkey : minSet) {

                System.out.println("\t"+ minkey + "---" + hashMap.get(minkey));

            }

            System.out.println();

        }

    }

}

2) HashMap嵌套ArrayList

例：三国演义

        郭嘉

       周瑜

笑傲江湖

       令狐冲

       林平之

神雕侠侣

       杨过

       郭靖

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map.Entry;

import java.util.Set;

public class MyMapDemo {

publicstatic void main(String[] args) {

        ArrayList<String>sg = new ArrayList<String>();

        sg.add("郭嘉");

        sg.add("周瑜");

        ArrayList<String>xajh = new ArrayList<String>();

        xajh.add("令狐冲");

        xajh.add("林平之");

        ArrayList<String>sjxl = new ArrayList<String>();

        sjxl.add("杨过");

        sjxl.add("郭靖");

        HashMap<String,ArrayList<String>> map = new HashMap<String,ArrayList<String>>();

        map.put("三国演义", sg);

        map.put("笑傲江湖", xajh);

map.put("神雕侠侣", sjxl);

        Set<Entry<String,ArrayList<String>>> entrySet = map.entrySet();

        for(Entry<String, ArrayList<String>> en : entrySet) {

            Stringkey = en.getKey();

            System.out.println(key);

            ArrayList<String>list = en.getValue();

            for(String v : list) {

                System.out.println("\t"+v);

            }

            System.out.println();

        }

    }

}

3) ArrayList嵌套HashMap

例：周瑜---小乔

    吕布---貂蝉

郭靖---黄蓉

    杨过---小龙女

    令狐冲---任盈盈

    林平之---岳灵珊

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Set;

public class MyMapDemo4 {

    publicstatic void main(String[] args) {

        HashMap<String,String> sgmap = new HashMap<String, String>();

        sgmap.put("周瑜", "小乔");

        sgmap.put("吕布", "貂蝉");

        HashMap<String,String> sjmap = new HashMap<String, String>();

        sjmap.put("郭靖", "黄蓉");

        sjmap.put("杨过", "小龙女");

        HashMap<String,String> xamap = new HashMap<String, String>();

        xamap.put("令狐冲", "任盈盈");

        xamap.put("林平之", "岳灵珊");

        ArrayList<HashMap<String,String>>arrayList=new ArrayList<HashMap<String, String>>();

        arrayList.add(sgmap);

        arrayList.add(sjmap);

        arrayList.add(xamap);

        for(HashMap<String, String> hm : arrayList) {

            Set<String>keySet = hm.keySet();

            for(String key : keySet) {

                System.out.println(key+ "        " + hm.get(key));

            }

            System.out.println();

        }

    }

}

Day17

异常类

异常类：

第一种情况:严重问题,不处理，开发中:内存溢出! 开发团队,集体研究这个问题!(假设加载大量图片的时候:ImageLoader)

两个具体的子类:Error Exception

第二种情况和第三种情况都属于异常的范畴:

Exception的分类:异常类

1)编译时期异常:只要不是RuntimeException中的异常都属于编译时期异常:比如:IOException(IO流中的),ParseException(解析异常)

出现的原因:要么语法有问题,要么使用的是Sun公司提供的一些类的中的方法,(这个方法本身调用的时候就会异常存在),调用者必须处理,不处理不行,需要编译通过

2)运行时期异常:RuntimeException

可能由于我们代码的逻辑不够严谨导致的问题举例,NullPointerException:空指针异常。

需要个对象进行非空判断,来防止该问题的出现。

2.如何处理异常?

两种方式:

1)标准格式:try...catch...finally:捕获异常!

2)throws 抛出异常

首先:方式1:处理异常:

try...catch...finally

变形格式:

try...catch

try...catch...catch

try...finally...(多线程的时候:Lock锁)

经常使用的格式:

try{

可能有很多行代码---->一旦有出现问题了

}catch(异常类名 变量名){

输出语句处理

}

有多个异常存在,如何处理呢?

1)方式1:

针对多个异常分别的try...catch :在实际开发中,这种做法比较麻烦

2)方式2:

try{

可能会出现问题的多个语句

}catch(异常类名1 变量名){

输出语句处理

}catch(异常类名2 变量名){

输出语句处理

}

注：针对多个异常进行处理,第一个异常如果是大异常,那么后面可以不用再给了，将大异常放在小异常的后面。

多个异常一块进行处理,只要try语句中的代码和catch语句中的代码所描述的异常类的信息一致,那么直接走catch里面的代码,try...catch语句结束。

例题：

public class ExceptionDemo {

    publicstatic void main(String[] args) {

        method1();

        method2();

        method3();

    }

    privatestatic void method3() {

        inta = 10;

        intb = 0;

        int[]arr = {0,1,2};

        try{

            System.out.println(arr[3]);

            System.out.println(a/b);

        }catch(ArrayIndexOutOfBoundsExceptione){

            System.out.println("数组中不存在的索引");

        }catch(ArithmeticExceptione){

            System.out.println("除数不能玩为0");

        }catch(Exceptione){

            System.out.println("程序可能出现问题");

        }

    }

    privatestatic void method2() {

        inta = 10 ;

        intb = 0 ;

        int[]arr = {0,1,2} ;

        try{

            System.out.println(arr[3]);

            System.out.println(a/b);

        }catch(ArithmeticExceptione){

            System.out.println("除数不能为0");

        }catch(ArrayIndexOutOfBoundsExceptione){

            System.out.println("数组中不存在索引");

        }

    }

    privatestatic void method1() {

        inta = 10;

        intb = 0;

        try{

            System.out.println(a/b);

        }catch (ArithmeticException e) {

            System.out.println("除数不能为0");

        }

        int[]arr = {1,2,3} ;

        try{

            System.out.println(arr[3]);

        }catch(ArrayIndexOutOfBoundsExceptione){

            System.out.println("数组中不存在索引");

        }

    }

}

3.针对多个异常进行处理,Jdk7以后又一种新的处理方式:

 try{

可能会出现问题的代码

....

...

}catch(异常类名1 | 异常类名2 ....变量名){

处理异常...

}

这个格式的注意事项:

1)针对多个异常类名之间是一种平级关系

2)这种格式在实际开发中,虽然有多个异常,但是针对具体的异常给出具体的处理!

public class ExceptionDemo2 {

    publicstatic void main(String[] args) {

        inta = 10 ;

        intb = 0 ;

        int[]arr = {1,2,3} ;

        try{

            System.out.println(a/b);

            System.out.println(arr[3]);

        }catch(ArithmeticException| ArrayIndexOutOfBoundsException  e){

            System.out.println("程序出问题");

            e.printStackTrace();

        }

    }

}

4.异常处理第二种方式:

throws:抛出异常

在方法声明上抛出异常,由于,编译时期异常,调用者必须要处理

实际开发中,尽量的不要在main()方法抛出异常,在字方法中可以抛出异常,讲课为了方便,就在main方法抛出

面试题:

throws和throw的区别?

throws:抛出

后面跟的异常类名,可以跟多个异常类名,中间用逗号隔开

throws在方法声明上抛出,表示异常的一种可能性，由调用者去处理

throw:抛出

后面跟的异常对象(匿名对象),只能跟具体的一个异常对象

throw在方法中的语句中抛出,表示异常的绝对性

在实际开发中:

throws要比throw用的比较多,而try...catch...又比throws用的比较多。

5．编译时期:Java程序必须给予处理,否则编译不通过(必须显示处理)

运行时期异常:可以处理,也可以像编译时期一样进行显示处理

6.try里面的代码一旦出问题了,那么Jvm java虚拟机就会针对这个问题抛出一个异常,然后和Catch里面的所描述异常进行是否匹配,如果一致就会产生一个异常对象,然后去处理这个异常对象,就会调用异常中的一些方法

try{

可能有问题的代码

}catch(异常类名 变量名){

...

}

常用的方法:

public String getMessage() 消息字符串

public String toString() 描述字符串:

1)当前类的全路径名称(指的是当前异常类名所在的包的全路径名称)

2)": "（冒号和一个空格）

public void printStackTrace():

该方法是里面包含了消息字符串以及当前出现错误的异常的时候所描述哪个包下以及代码中具体的错误出现第几行

返回值是void,也就直接在控制台输出

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class ExceptionDemo2 {

    publicstatic void main(String[] args) {

        Stringstr = "2017-11-18" ;

        //创建SimpleDataFormat对象

        SimpleDateFormatsdf = new SimpleDateFormat("yyyy-MM-dd") ;

        try{

            Datedate = sdf.parse(str) ;           

            System.out.println(date);

        }catch (ParseException e) {

            e.printStackTrace();

        }

    }

}

7. 捕获异常的标准格式:  try...catch...finally

用法:

finally经常用在数据库中或者IO流中,用来释放资源的

finally中的代码一定会执行.

finally中的不执行只有一种情况:就是Jvm退出了---------->System.exit(0) ;

面试题:

final,finalize,和finally的区别?

区别:

final:表示最终的,终态的意思

可以修饰类:类不能继承

可以修饰成员方法:成员方法被重写

可以修饰成员变量:此变量是一个常量:自定义常量:  public static final intORANGLE = 100 ;

finalize:它表示通过gc垃圾回收器回收不用的对象或者是变量,System.gc():实质,调用的是重写了Object类中的

finalize()方法,表示回收没有跟多引用对象或者变量等等...

finally:不能单独使用,和try...catch...finally中一块使用,(异常,IO,数据库中中使用的),是用来释放资源

finally中的代码一定会执行,并且除非Java虚拟机Jvm退出了,才不会执行!

面试题:

如果catch里面有return语句,那么finally中的代码还会执行吗?

如果可以,是在return前执行还是return后执行?

会执行;并且在return 前执行!

8. 异常的注意事项:

1)子类在重写父类中的方法的时候,如果父类中方法有抛出异常,那么子类重写的这个方法,

抛出异常不能够比父类中该方法异常大,(要么是父类中该方法异常的子类)(最起码应该保存一致)(父亲坏了,儿子不能比父亲更坏)

2)子类继承父类,要重写父类中的方法的时候,如果本身父类中该方法没有异常,那么在子类中重写该方法的时候,不能抛出异常,只能捕获异常。

二、File类

1.IO流之前要先懂得如何封装硬盘上的以文件或者目录,使用File类

File,是用来描述文件或者目录(文件夹)的路径的抽象表现形式

常用的构造方法:

public File(String pathname):给定路径名以字符串来表示当前这个文件或者文件夹(开发中推荐使用第一种构造方法)

public File(String parent,String child)根据 parent 路径名字符串和 child 路径名字符串创建一个新 File对象

public File(File parent, String child)根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例

2. 使用File对象可以创建文件或者文件夹

里面跟创建有关的成员方法:

public boolean mkdir()创建此抽象路径名指定的目录(文件夹)。

如果当前某个盘符下已经有了这个目录(文件夹),不会在创建了.

public boolean createNewFile():创建文件的,如果已经有这个文件了,不在创建,并且该方法本身就会编译时期异常IOException

throws IOException

public boolean mkdirs()创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。(创建文件夹,文件夹不存在,才开始创建)

注意事项:

自己要清楚要创建的是文件夹还是文件,每个方法都不一样!

没有带盘符,默认到当前项目下创建文件或者文件夹

3. 如果不小心创建文件或者文件夹的时候,没有写盘符那么就会当前项目下进行创建

    publicboolean delete()删除此抽象路径名表示的文件或目录

删除不能删除带有文件或者文件夹的目录

注意事项:

删除的方法不能删除带有目录或者文件的文件夹

删除多个目录,必须逐一删除!

4. File类中的重命名功能:

public boolean renameTo(File dest)重新命名此抽象路径名表示的文件。

1)使用这个功能:当两个抽象路径一致,那么只是重命名

2)当这两个抽象路径不一致,有剪切并且改名了

5. File类中的判断功能:

public boolean isDirectory():判断是否是文件夹       经常用到

public boolean isFile():判断是否是一个标准文件      经常用到

public boolean canRead():判断是否可读

public boolean canWriter():判断是否可写

public boolean isHidden():判断是否是隐藏文件

public boolean isAbsolute():判断次路径名是否是绝对路径

6. File类中的获取功能:

public File getAbsolutePath():获取当前文件或者文件夹绝对路径

public String getPath():获取相对路径

public long length()返回由此抽象路径名表示的文件的长度

public long lastModified()返回此抽象路径名表示的文件最后一次被修改的时间

public String getName():获取名称

File类的高就获取功能:

public String[] list():返回对象是一个字符串数组,当前哪个一盘符下的所有的文件以及文件夹的字符串名称数组

public File[] listFiles():返回对象是一个File数组,当前哪个盘下的所有的文件以及文件夹的File数组

三、IO流

1.IO流:设备和设备之间的数据传输

设备和设备指的是:硬盘和内存之间的数据传输

IO流的分类:

按流的方向分:

输入流:读数据的

输出流:写数据的

按数据类型分:

字节流:

字节输入流:InputStream

字节输出流:OutputStream

字符流

字符输入流:Reader

字符输出流:Writer

2. 针对输出流中写数据的方法:

public abstract void write(int b):将指定的字节写入到输出流中

public void write(byte[] b):将指定的字节数组写入到输出流中

public void write(byte[] b, int off,intlen):将字节数组的一部分写入到输出流中

3. 写入了这个数据,数据和数据之间换行

需要写入换行符号,每一个系统他们对应IO这块换行符号是不一样的

对于windows操作系统来说:换行符号:\r\n

对于Linux操操作系统来说:\n

对于Mac操作系统来说:\r

如何给这个文件追加写入数据呢?

public FileOutputStream(File file,booleanappend):第二个参数设置为true,表示写入文件的末尾处。