寒假实训第七天（set 集合map集合和异常）

Set集合(重点)

基本概念

java.util.Set集合是Collection集合的子集合,与List集合平级。该集合中元素没有先后放入次序， 并粗不允许重复。该集合的主要实现类是: HashSet类 和TreeSet类。中HashSet类的底层是 采用哈希表进行数据管理的。其中TreeSet类的底层是采用二叉树进行数据管理的。

常用的方法

参考Collection集合中的方法即可!（不了解的可以看上一篇）

练习:准准一个Set集合指向HashSet对象，向该集合中添加元素"two'并打印，再响集合中添加元素one "并打印，再向集合中添加元素three' '并打印，再向集合中添加"one' "并打印。下面的是我还测试了一些其他方法

@Test
public void setTest(){
    Set set = new HashSet();
    boolean b = set.add("one");
    System.out.println("b = " + b);
    System.out.println(set);
    b = set.add("two");
    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);
    Set<String> set1 = new HashSet();
    set1.add("haha");
    set1.add("ehehe");
    set1.addAll(set);
    System.out.println(set1);
    boolean b1 = set1.contains("haha");
    System.out.println("是否含有元素haha:" + b1);
    b = set1.isEmpty();
    System.out.println("set1是否为空：" + b);
    Iterator iterator = set1.iterator();
    System.out.println(iterator);//地址


}

b = true
[one]
b = true
[one, two]
b = true
[one, two, three]
b = true
[four, one, two, three]
b = true
[four, one, two, three, five]
[haha, four, one, two, three, five, ehehe]
是否含有元素haha:true
set1是否为空：false
java.util.HashMap$KeyIterator@22927a81

意:将对象加入HashSet集合中时，要获取对象的哈希码值通过哈希算法索引到对应的存储空间。




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

这个就是用random随机数生成

@Test
public void randomSetTest(){
    Set<Integer> set = new HashSet();
    Random random = new Random();
    /*for (int i = 0;i < 10;i++){//这是去重
        boolean b = set.add(random.nextInt(20)+1);
        if (b == false){
            i--;
        }
    }*/
    while(set.size()<10){//这个就不用考虑去重，直接看是否有10个，不够继续循环
        set.add(random.nextInt(20)+1);
    }
    System.out.println(set);
}

[16, 2, 19, 20, 5, 6, 7, 9, 10, 14]

Map集合(重点)

基本概念

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

K-此映射所维护的键(Key)的类型，相当于目录。V- 映射值Value)的类型，相当于内容。

该集合中key是不允许重复的，且-个key只能对应-个value。该集合的主要实现类有: HashMap类 和TreeMap类。

常用的方法

V 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) - 如果此映射将-个或多个键映射到指定值，则返回true.v remove (object key) 一从此映射中移除指定键的映射关系(如果存在)。

下面这个代码有点小长，不仅练习了上述方法，还进行了jdk里面的其他方法

@Test
public void hashMapTest(){
    Map<Integer,String> map = new HashMap<>();
    //向集合中添加元素
    map.put(1,"haha");
    map.put(2,"heihei");
    map.put(3,"yaya");
    map.put(4,"wawa");
    System.out.println(map);
    //equals(Object o)比较指定的对象与此映射是否相等。
    boolean b2 =  map.equals("yaya");
    System.out.println("是否有与yaya相等的元素：" + b2);
    //hashCode()返回此映射的哈希码值。
    int h = map.hashCode();
    System.out.println(h);
    //取出关键字处对应的值
    String value = map.get(3);// 返回与此项对应的键
    System.out.println("3 = " + value);
    //看集合中是否包含指定的关键字
    boolean b = map.containsKey(5);
    System.out.println(b);
    b = map.containsKey(3);
    System.out.println(b);
    //看集合中是否包含指定的值
    b = map.containsValue("haha");
    System.out.println(b);
    b = map.containsValue("xixi");
    System.out.println(b);
    //删除map集合中的元素，根据key
    String v = map.remove(3);
    System.out.println("删掉的值为：" + v);
    v = map.remove(9);
    System.out.println("删掉的值为：" + v);
    //putAll(Map<? extends K,? extends V> m)从指定映射中将所有映射关系复制到此映射中
    Map<Integer,String> map1 = new HashMap<>();
    map1.put(7,"xixi");
    System.out.println(map1);
    map1.putAll(map);
    System.out.println(map1);
    //size()返回此映射中的键-值映射关系数。
    int a = map.size();
    int c = map1.size();
    System.out.println("map的大小为：" + a);
    System.out.println("map1的大小为：" + c);
    // values()返回此映射中包含的值的 Collection 视图。
    Collection<String> values = map1.values();
    System.out.println(values);
    //keySet()返回此映射中包含的键的 Set 视图。
    Set<Integer> integers = map1.keySet();
    System.out.println(integers);
}

{1=haha, 2=heihei, 3=yaya, 4=wawa}
是否有与yaya相等的元素：false
-1210490024
3 = yaya
false
true
true
false
删掉的值为：yaya
删掉的值为：null
{7=xixi}
{1=haha, 2=heihei, 4=wawa, 7=xixi}
map的大小为：3
map1的大小为：4
[haha, heihei, wawa, xixi]
[1, 2, 4, 7]
 

Map集合的遍历方式

方式一:自动调用toString法

方式二:调用keySet方法获取Map集合中所有的key

方式三:调用entrySet方法获取Map集合中所有的键值对

Map集合是面向查询优化的数据结构，在大数据量情况下有着优良的查询性能，经常用于根据key检索value的业务场景。

@Test
public void iteratorMapTest(){
    Map<Integer,String> map = new HashMap<>();
    map.put(1,"haha");
    map.put(2,"heihei");
    map.put(3,"yaya");
    map.put(4,"wawa");
    //遍历方式一
    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遍历map集合中的元素，方式三
    Set<Map.Entry<Integer, String>> entries = map.entrySet();//返回此映射中包含的映射关系的 Set 视图
    for (Map.Entry<Integer, String> e :entries){
        System.out.println(entries);
    }
}

{1=haha, 2=heihei, 3=yaya, 4=wawa}
----------------------
1=haha
2=heihei
3=yaya
4=wawa
========================
[1=haha, 2=heihei, 3=yaya, 4=wawa]
[1=haha, 2=heihei, 3=yaya, 4=wawa]
[1=haha, 2=heihei, 3=yaya, 4=wawa]
[1=haha, 2=heihei, 3=yaya, 4=wawa]

07 -异常机制

基本概念

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

基本分类

java.lang. Exception类的所有子类主要分为两大类:

RuntimeException类-运行时异常 ，也叫做非检测性异常。

IOException和其它异常一其它异常 ，也叫做检测性异常。

一所谓检测性异常就是指在编译阶段能够被编译器检测出来的异常。


注意:当程序执行过程中发生了异常但没有手动处理时，该误常由Java虚拟机采用默认方式处理，而默认处理方式就是打印异常的名称、异常的原因以及异常发生的位置并终止程序。

异常的避免

在以后的开发中尽量使用if条件判断来避免异常的发生。

异常的捕获

(1)语法格式

try   编写所有可能发生异常的语句;

catch(异常类型变量名)   编写针对该类异常进行处理的语句:

finally编写无论是否发生异常都需要处理的语句;

(2)注意事项

a.当编写多个catch分支时，切记将小类型放到大类型的前面，懒人的写法:catch(Exception e) (

b.final1y主要用于善后处理，如:关闭已经打开的文件、删除临时创建的文件等

(3)执行流程

try {
a

b

c
}; -可能发生异常的语句

catch( ... ) {d.

finally

当程序执行过程中没有发生异常时的执行流程: a b c e;当程序执行过程中发生异常后的执行流程: a b d e;

看个格式

public void exceptionTest02(){
    FileInputStream fileInputStream = null;
    try {
        fileInputStream = new FileInputStream("c:/a.tet");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }finally {
        try {
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

异常的抛出

(1)基本概念

在某些特殊情况下异常不便于处理或无法处理时，就可以将异常转移给该方法的调用者，这个过程就叫做异常的抛出。

(2)语法格式

访问权限返回值类型方法名(形参列表) throws 异常类型，... {方法体;

(3)方法重写的原则

a.要求方法名相同、参数列表相同、返回值类型相同，从jak1 .5开始允许返回子类类型:

b.要求访问权限不能变小，可以相同或变大;
c.要求不能抛出更大的异常;

看一下对应的一些练习

@Test
public void exceptionTest(){
    //ArithmeticException
    int a = 10;
    int b = 0;
    if (b != 0){
        System.out.println(a/b);
    }
    //ArrayIndexOutOfBoundsException
    int[] arr = new int[5];
    int len = 5;
    if (len < arr.length){
        System.out.println(arr[5]);
    }

    //NullPointException
    String str = null;
    if (str != null){
        System.out.println(str.length());
    }
    //ClassCaseException
    Exception exception = new Exception();
    if (exception instanceof IOException){
        IOException io = (IOException) exception;
        System.out.println(io);
    }

    //NumberForException
    String str1 = "123aa";
    //匹配正确表达式\d+表示数字
    if (str1.matches("\\d+")){
        System.out.println(Integer.parseInt(str1));
    }

    System.out.println("运行结束");
}

其中原来都是有异常的，但是最后都用if语句去避免

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

实现流程.
a.自定义xxxException继承自Exception或者其子类。

b.提供两个版本的构造方法，一个无参构造方法，另外一个是字符串作为参数的构造方法。

public class AgeException extends Exception{
    public AgeException() {
    }

    public AgeException(String message) {
        super(message);
    }
}

练习:
编程实现Person类的封装，特征有:姓名和年龄，要求重写toString方法

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

    @Override
    public String toString() {
        return "Peoson{" +
                "name='" + name + '\'' +
                ", age=" + 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("年龄不合理！");
        }

    }

    public Person() {
    }

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

编程实现PersonTest类，在main方法中使用有参方式构造对象并打印

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

Peoson{name='xixi', age=18}