学习java的第12天_java

Map集合特点

双列集合，一个数据包含两个值
Map集合元素中，key和value值类型可以相同，也可以不同
Map集合中的元素，key不可以重复，value值可以重复
key于value一一对应

常用子类

HashMap<k,v>;
/*
1. 底层是哈希表，是一个线程不安全集合，
2. HashMap集合是一个无序集合
3. 可以存储null值
*/

LinkedHashMap<k,v>;
/*
1. 底层是哈希表+链表
2. 是有序集合
*/

常用方法

public V put(K key,V value);
public V remove(Object key);
public V get(Object key);
boolean containsKey(Object key);
public Set<K> keySet();
public set<Map.Entry<K,V>> entrySet();

public class Main {
    public static void main(String[] args) {
        show1();
    }
    public static void show1(){
        Map<Integer,String> map = new HashMap<Integer, String>();
        //put 返回值 v
        // 若key值重复则替换，且返回被替换的元素值
        // 若key不重复则返回null
        String s1 = map.put(12, "aa");
        System.out.println(map);
        System.out.println(s1);
        System.out.println("============");
        String s2 = map.put(12, "bb");
        System.out.println(map);
        System.out.println(s2);
        // 可以存储重复元素,但key不能重复
        map.put(13,"bb");
        System.out.println(map);
        System.out.println("============");

        //remove 返回值 v
        // 若key值存在，返回被删除元素
        // 若key值不存在，返回null
        String s3 = map.remove(12);
        System.out.println(map);
        System.out.println(s3);
        System.out.println("============");

        //get 返回值
        // 若key值存在，返回对应值
        // 若key值不存在，返回null
        String s4 = map.get(13);
        System.out.println(map);
        System.out.println(s4);
        System.out.println("============");

        //containsKey 返回值 boolean
        // 若存在返回true,不存在则返回false
        boolean s5 = map.containsKey(13);
        System.out.println(s5);
    }
}

Map集合遍历键找值方式

 public static void show2(){
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1,"lin");
        map.put(2,"ling");
        map.put(3,"wang");
        map.put(4,"wan");
        map.put(5,"li");

        Set<Integer> set = map.keySet();
        for (Integer integer : set) {
            System.out.println(map.get(integer));
        }
        System.out.println("=================");

        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.print(map.get(iterator.next()));
            System.out.print(',');
        }

        
    }

Map集合遍历键值对对象找值方式

Set<Map.Entry<Integer, String>> entries = map.entrySet();
        Iterator<Map.Entry<Integer, String>> it = entries.iterator();
        while (it.hasNext()){
            Map.Entry<Integer, String> next = it.next();
            System.out.println(next.getKey()+"="+next.getValue());
        }

HashMap存储自定义类型键值

//要重写hashCode和equals，保证key值的唯一
public class Person {
    int ID;
    public String name;

    public Person() {
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return ID == person.ID && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(ID, name);
    }

    public Person(int ID, String name) {
        this.ID = ID;
        this.name = name;
    }

    public int getID() {
        return ID;
    }

    public void setID(int ID) {
        this.ID = ID;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class Demo1 {
    public static void main(String[] args) {
        HashMap<Integer,Person> map = new HashMap<>();

        map.put(1,new Person(18,"lin"));
        map.put(2,new Person(19,"ling"));
        map.put(3,new Person(18,"li"));

        Set<Integer> integers = map.keySet();
        for (Integer integer : integers) {
            System.out.println(map.get(integer));
        }
        
        Set<Map.Entry<Integer, Person>> entries = map.entrySet();
        for (Map.Entry<Integer, Person> entry : entries) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
        
    }
}

LinkedHashMap

省略，于HashMap一致，只是保证了元素的存储顺序

HashTable

底层是一个哈希表，单线程安全集合，速度慢
于Vector集合一致
用法与HashMap一致

Hashtable<String,String> table = new Hashtable<>();
table.put()。。。。
    。。。。。

异常概述

在Java等面向对象的编程语言中，异常本身就是一个类，产生异常就是创建一个异常对象并抛出一个异常对象。java处理异常的方式是中断处理
异常并不是语法错误
Throwable是错误和异常的父类

分类

Exception : 编译期异常，进行编译（写代码）时出现的问题;
RuntimeException: 运行期异常，程序运行时出现的问题;
Error : 错误，必须修改源代码

解析

处理方式 throw

throw 关键字;
//在指定方法中抛出指定的异常
/*
注意：
1. throw关键字必须写在方法的内部
2. throw关键字后边new的对象必须是Exception或者Exception的子类
3. throw关键字抛出指定的异常对象，我们必须处理这个异常对象
4. throw关键字后边创建的是RuntimeException或是RuntimeException的子类时，我们可以不处理，默认交给jvm处理（中断程序，打印对象）
5. throw关键字后边创建的是编译异常，我们必须处理
*/

public class Main {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,8};

        System.out.println(get(array,6));


    }
    public static int get(int[] array,int index){

        //首先先对传入的参数进行合法性检验
        if (array==null){
            throw new NullPointerException("格式不正确");
        }
        //NullPointerException 运行期异常，可以不处理，默认交给jvm处理

        if (index<0 || index > array.length-1){
            throw new ArrayIndexOutOfBoundsException("数组越界");
        }
        //ArrayIndexOutOfBoundsException 运行期异常，可以不处理，默认交给jvm处理
        return array[index];


    }
}

Objects非空判断

对对象进行合法性判断

public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
}

可用于简化我们对参数合法性的判断

public static int get2(int[] array,int index){
        //先对参数进行合法性判断
        Objects.requireNonNull(array);
        //Objects.requireNonNull(array,"格式不正确");
        return array[index];
    }

throws

当方法内部抛出异常对象的时候，我们必须处理这个对象，可以使用throws关键字处理异常对象，会把异常对象抛出给方法的调用者处理（自己不处理，会默认让jvm处理）
在方法声明是使

修饰符 返回值 方法名（参数列表）throws 名字A，名字B。。。。{
    throw new 名字A("产生原因");
    throw new 名字A("产生原因");
    ........
}

注意：
- throws关键字必须写在方法声明处
- throws关键字后边的异常声明必须是Exception或者是Exception的子类
- 方法内部如果抛出多个异常对象，那么throws后边必须也声明多个异常，如果存在父子关系，那么直接声明父类异常即可
- 调用一个声明抛出异常的方法，我们就必须处理声明的异常，要么继续使用throws声明抛出，交给方法调用者，最终交给jvm处理，要么用try…catch自己处理

import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo1 {
    //异常由方法抛出，我们必须处理，或者使用throws 异常名，将异常交给jvm处理
    public static void main(String[] args) throws FileNotFoundException {
        equalss("a");
    }
    //FileNotFoundException 是编译期异常


    public static void equalss(String str1) throws FileNotFoundException,IOException{
        if (!str1.equals("c")){
            throw new FileNotFoundException("文件不存在");
        }

        if (!str1.endsWith(".")){
            throw new IOException("错误");
        }
        
        //由于IOException,是FileNotFoundException的父类
        //所以函数声明也可用：public static void equalss(String str1) throws IOException{}
        //将FileNotFoundException省略不写
        //因为所有异常都是Exception的子类
        //suopublic static void equalss(String str1) throws Exception{}
    }
}

try…catch

try{
    可能产生异常的代码
}catch（定义一个变量用于接收异常对象）{
    异常的处理逻辑
}
...
 catch（异常类名 变量名）{
    
}
/*
注意：
1. try中可能抛出多个异常对象，那么就可以使用多个catch来处理
2. 如果产生异常，那么就会执行catch中的代码，如果不产生就不会执行




*/

public class Demo1 {
    public static void main(String[] args)  {
        //使用try处理
        try {
            equalss("a");
        }catch (Exception e){
            System.out.println("文件不存在");
        }

    }

（定义一个变量用于接收异常对象）{
异常的处理逻辑
}
…
catch（异常类名变量名）{

}
/*
注意：

try中可能抛出多个异常对象，那么就可以使用多个catch来处理
如果产生异常，那么就会执行catch中的代码，如果不产生就不会执行


```java
public class Demo1 {
    public static void main(String[] args)  {
        //使用try处理
        try {
            equalss("a");
        }catch (Exception e){
            System.out.println("文件不存在");
        }

    }

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/794294.html

学习java的第12天

发表评论

评论列表（0条）