使用IDEA学JAVA第七天

今天是寒假学JAVA第七天，主要学习了集合框架、异常处理，希望大家认真学习。

一、集合框架（续）

1.泛型机制

基本概念

通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。
为了避免上述错误的发生，从jdk1.5开始增加泛型机制，也就＜数据类型＞的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错，如：
List lt1 = new LinkedList();

泛型机制的本质
泛型机制的本质就是参数化类型，也就是让数据类型作为参数传递，其中E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数，实际参数主要用于给形式参数初始化，一旦初始化成功，以后所有的E全部被实参取代，如：

//其中i叫做形式参数，负责占位 // int i = 5; // int i = 10; public void show(int i){
其中E叫做形式参数，负责占位 E= String; E-Student; public interface List{
其中5叫做实际参数，给形参初始化 show(5); show(10);
/／其中String叫做实际参数，给形参初始化
List ltl=…; List 1t2=…;

2.Queue集合（重点:先进先出）

基本概念
java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。该集合的主要用于描述具有先进先出特征的数据结构，叫做队列（first in first out FIFO）该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势。
常用的方法

boolean add(E e) ﹣将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回
true，如果当前没有可用的空间，则抛出 IllegalStateException. E element()﹣获取，但是不移除此队列的头。
boolean offer (E e) -
将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于add(E)，后者可能无法插入元素，而只是抛出一个异常。
E peek()- 获取但不移除此队列的头；如果此队列为空，则返回null。 poll()﹣获取并移除此队列的头，如果此队列为空，则返回
null。 remove() ﹣获取并移除此队列的头

练习：准备一个Queue集合，将数据11、22、33、44、55依次入队并打印，然后查看队首元素并打印，然后将队列中所有数据依次出队并打印。

public class queueTest01 {
    public static void main(String[] args) {
        //准备一个Queue集合
        Queue<Integer> queue = new LinkedList<>();
        //将数据11,22,33,44,55依次入队并打印
        for(int i = 1;i <= 5;i++){
            queue.offer(i*11);
            System.out.println(queue);
        }
        //查看队首元素并打印
        Integer it = queue.peek();
        System.out.println("队首元素：" + it);
        //将队列元素出队并打印
        int len = queue.size();
        for (int i = 1;i <= len; i++){
            Integer it1 = queue.poll();
            System.out.print(" " + it1);
        }
    }
}

3.Set集合（重点）

基本概念
java.util.Set集合是Collection集合的子集合，与List集合平级。该集合中元素没有先后放入次序，并且不允许重复。该集合的主要实现类是：HashSet类和TreeSet类。其中HashSet类的底层是采用哈希表进行数据管理的。其中TreeSet类的底层是采用二叉树进行数据管理的。
常用的方法
参考Collection集合中的方法即可！
练习：准备一个Set集合指向HashSet对象，向该集合中添加元素"two"并打印，再向集合中添加元素"one"并打印，再向集合中添加元素"three"并打印，再向集合中添加"one"并打印。

public class SetTest {
    @Test
    public void setTest(){
        Set<String> set = new HashSet<>();
        boolean b = set.add("two");
        System.out.println("b = " + b);
        System.out.println(set);
        b = set.add("one");
        System.out.println("b = " + b);
        System.out.println(set);
        b = set.add("three");
        System.out.println("b = " + b);
        System.out.println(set);
        b = set.add("four");
        System.out.println("b = " + b);
        System.out.println(set);
        b = set.add("five");
        System.out.println("b = " + b);
        System.out.println(set);
        b = set.add("one");
        System.out.println("b = " + b);
        System.out.println(set);

    }

练习：随机生成10个1~20之间的随机数放入Set集合中并打印。

@Test
    public void RandomSetTest(){
        HashSet<Integer> set = new HashSet<>();
        // 创建一个Random对象
        Random random = new Random();
        // 循环10次，每次生成一个1~20之间的随机数并添加到HashSet中
        /*for(int i = 0; i < 10; i++) {
            boolean b = set.add(random.nextInt(20) + 1);
            if(b = false){
                i--;
            }
        }*/
        //while循环可以不用去重，因为他用的是集合的大小，而Set集合会去重，只关注数量即可
        while(set.size() < 10){
            set.add(random.nextInt(20) + 1);
        }
        // 打印HashSet中的所有元素
        System.out.println(set);
    }
}

4.Map集合（重点）

基本概念
java.util.Map集合中存取元素的基本单位是：单对元素，其中类型参数如下：

K﹣此映射所维护的键（Key）的类型，相当于目录。V﹣映射值（Value）的类型，相当于内容。
该集合中key是不允许重复的，而且一个key只能对应一个value。 该集合的主要实现类有HashMap类和TreeMap类。

常用的方法

put(K key, V value) - 将Key-Value对
存入Map，若集合中已经包含该Key，则替换该Key所对应的Value,返回值为该Key原来所对应的Value，若没有则返回null V
get (Object key)﹣返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null.boolean
containsKey(Object key)﹣如果此映射包含对于指定键的映射关系，则返回true。 boolean
containsValue(Object value)↑rnute. Nge true. V remove (Object key)-
从此映射中移除指定键的映射关系（如果存在）。

Map集合的遍历方式
方式一：自动调用toString方法
方式二：调用keySet方法获取Map集合中所有的key
方式三：调用entrySet方法获取Map集合中所有的键值对
Map集合是面向查询优化的数据结构，在大数据量情况下有着优良的查询性能，经常用于根据key检索value的业务场景。
代码练习：

public class MapTest {
    @Test
    public void HashMapTest(){
        Map<Integer,String> map = new HashMap<>();
        //向集合中添加元素
        map.put(1,"郝俊芳");
        map.put(2,"容嬷嬷");
        map.put(3,"玛丽");
        map.put(4,"绿如水");
        System.out.println(map);
        String value = map.get(3);
        System.out.println("3=" + value);
        boolean b = map.containsKey(5);
        System.out.println(b);
        b = map.containsKey(2);
        System.out.println(b);
        b = map.containsValue("特斯拉");
        System.out.println(b);
        b = map.containsValue("郝俊芳");
        System.out.println(b);
        //根据key，删除map中的元素
        String v = map.remove(3);
        System.out.println("删除的值为：" + v);
    }

    @Test
    public void IteratorMapTest(){
        Map<Integer,String> map = new HashMap<>();
        //向集合中添加元素
        map.put(1,"郝俊芳");
        map.put(2,"容嬷嬷");
        map.put(3,"玛丽");
        map.put(4,"绿如水");
        System.out.println(map);
        //Map集合遍历，方式一
        System.out.println(map);
        System.out.println("------------------------");
        //使用KeySet方法遍历Map集合，方式二
        Set<Integer> set = map.keySet();
        for(Integer it : set){
            System.out.println(it + "=" + map.get(it));
        }
        System.out.println("====================");
        //使用entrySet遍历集合中元素，方式三
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for(Map.Entry<Integer,String> e:entries){
            System.out.println(e);
        }

        //遍历所有的key和value
        System.out.println("集合中所有的<key,value>:");
        Iterator<Map.Entry<Integer,String>> iter3 = map.entrySet().iterator();
        while (iter3.hasNext()) {
            Map.Entry<Integer,String> entry = iter3.next();
            System.out.println("<" + entry.getKey() + "," + entry.getValue() + ">");

        }

    }
}

二、异常机制

1.基本概念

异常就是不正常的含义,在Java语言中体现为为运行阶段发生的情误。 java.lang. Throwable关关是Java语言中所有错误（Error类）和异常（Exception类）的超类。 其中Error类主要用于描述比较严重无法编码解决的错误，如：JVM挂了等。其中Exception类主要用于描述比较轻微可以编码解决的错误，如：0作为除数等。

2.基本分类

java.lang.Exception类的所有子类主要分为两大类：
RuntimeException类﹣运行时异常，也叫做非检测性异常。
IOException和其它异常 ﹣其它异常，也叫做检测性异常。
﹣所谓检测性异常就是指在编译阶段能够被编译器检测出来的异常。

注意：当程序执行过程中发生了异常但没有手动处理时，该异常由Java虚拟机采用默认方式处理，而默认处理方式
就是打印异常的名称、异常的原因以及异常发生的位置并终止程序。
异常的避免
在以后的开发中尽量使用if条件判断来避免异常的发生。

3.异常的捕获

(1）语法格式

try{ 编写所有可能发生异常的语句
} catch（异常类型 变量名）{
编写针对该类异常进行处理的语句：}
finally {
编写无论是否发生异常都需要处理的语句：
}

(2）注意事项

a．当编写多个catch分支时，切记将小类型放到大类型的前面，懒人的写法： catch(Exception e) {
b.finally主要用于善后处理，如：关闭已经打开的文件、删除临时创建的文件等

(3）执行流程
try{
a:
b:﹣可能发生异常的语句
c;
catch(…){
d:
finally{
e;}
当程序执行过程中没有发生异常时的执行流程：a b c e
当程序执行过程中发生异常后的执行流程：a b d e;

4.异常的抛出

(1）基本概念
在某些特殊情况下异常不便于处理或无法处理时，就可以将异常转移给该方法的调用者，这个过程就叫做异常的抛出。
(2）语法格式
访问权限 返回值类型 方法名（形参列表） throws 异常类型，…
方法体；
(3）方法重写的原则

a．要求方法名相同、参数列表相同、返回值类型相同，从jdk1.5开始允许返回子类类型：
b．要求访问权限不能变小，可以相同或变大：
c．要求不能抛出更大的异常：

5.自定义异常

基本概念
虽然ava官方提供了大量的异常类，但没有提供针对年龄不合理的异常，此时若希望描述这样的异常信息，程序员自定义异常类。
实现流程

a．自定义xxxException继承自Exception或者其子类。
b．提供两个版本的构造方法，一个是无参构造方法，另外一个是字符串作为参数的构造方法。

练习：
编程实现Person类的封装，特征有：姓名和年龄，要求重写toString方法
编程实现PersonTest类，在main方法中使用有参方式构造对象并打印
代码如下：

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) throws AgeException {
        setName(name);
        setAge(age);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws AgeException {
        if(age > 0 && age < 150){
            this.age = age;
        }else{
            throw new AgeException("年龄不合理！");
        }
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class AgeException extends Exception{
    public AgeException() {
    }
    public AgeException(String msg){
        super(msg);
    }
}

public class PersonTest {
    public static void main(String[] args) {
        Person p = null;
        try {
            p = new Person("吴波",20);
        } catch (AgeException e) {
            e.printStackTrace();
        }
        System.out.println(p);
    }
}

总结

学的东西越来越难了，继续加油！！