Java进阶

1.Map主要实现类 HashMap<K,V>（无序集合）  集合底层是哈希表 由数组加单向链表或红黑树

HashMap主要子类 LinkedHashMap<K,V> （可预知的迭代顺序）集合底层是哈希表加链表 存储和取出元素的顺序是一致的

Map接口中定义了很多方法，常用的如下：
（1）public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。

　　存键值对的时候，key不重复，返回值V是null

　　存键值对的时候，key重复，会使用新的value替换旧的，返回被替换的value

（2）public V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。　　

　　删除时，如果key存在，则返回其value值

　　删除时，如果key不存在，则返回null

　　
（3）public V get(Object key) 根据指定的键，在Map集合中获取对应的值。

　　取值时，key存在，则返回对应的值

　　取值时，如果不存在，则返回null

（4）public boolean containsKey（Object key）：判断集合中是否包含指定的键

　　

（5）public Set<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。

　　

for(String s : map.keySet()){
            System.out.println(s + map.get(s));
        }

（6）public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
　　键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。
　　操作步骤与图解：
　　1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示: entrySet() 。
　　2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
　　3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示: getkey() getValue()

public class DemoMap {
    public static void main(String[] args) {
        show();
    }
    public static void show(){
        Map<String,String> map = new HashMap<>();
        String v = map.put("姓名", "李晨");
        map.put("成龙","中国");
        map.put("吴彦祖","中国");
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //第一种方法，迭代器比那里
        Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, String> entry = iterator.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key  + "=" + value);
        }
        //第二种方法，增强for循环遍历
        for(Map.Entry<String,String> entry : entrySet){ //从entrySet集合中拿到entry对象
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}

HashMap存储自定义类型键值：

　　Map集合需保证键是唯一的：

　　　　作为Key的元素，必须重写hashcode和equals方法，以保证key唯一

public class DemoMap2 {
    public static void main(String[] args) {
        method02();

    }

    private static void method02() {
        //key用Person类来做，person类就必须重写Hashcode和equals方法
        HashMap<Person,String> map = new HashMap<>();
        map.put(new Person("女王",18),"英国");
        map.put(new Person("秦始皇",22),"秦国");
        map.put(new Person("普京",25),"俄国");
        map.put(new Person("女王",18),"毛里求斯");
        Set<Map.Entry<Person, String>> entrySet = map.entrySet();
        for(Map.Entry<Person,String> entry : entrySet){
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(value + " - - > " + key);
        }

    }

    public static void method01(){
        //创建HashMap对象,因为String作为Key已经重写了hashcode方法和equals方法，所以key不会出现重复
        HashMap<String,Person> map = new HashMap<>();
        map.put("北京",new Person("张三",22));
        map.put("上海",new Person("李四",18));
        map.put("广州",new Person("王五",25));
    }
}

Map集合练习
需求：计算一个字符串中每个字符出现次数。

public class MapTest {
public static void main(String[] args) {
//友情提示
System.out.println("请录入一个字符串:");
String line = new Scanner(System.in).nextLine();

// 定义 每个字符出现次数的方法
findChar(line);
}
private static void findChar(String line) {
//1:创建一个集合 存储 字符 以及其出现的次数
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
//2:遍历字符串
for (int i = 0; i < line.length(); i++) {
char c = line.charAt(i);
//判断 该字符 是否在键集中
if (!map.containsKey(c)) {//说明这个字符没有出现过
//那就是第一次
map.put(c, 1);
} else {
//先获取之前的次数
Integer count = map.get(c);
//count++;
//再次存入 更新
map.put(c, ++count);
}
}
System.out.println(map);
}
}

Map斗地主案例：

LinkedHashMap（HashMap的子类）

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

2.Hashtable<K,V>集合 底层也是一个哈希表，是一个线程安全的集合，单线程的集合，速度慢

　　之前学的所有的集合都可以存储空，包括HashMap能存储空值空键，但HashTable不行，不能存储空值

　　Hashtable（HashMap取代了它）和vector（Arraylist取代）一样，在JDK1.2之后，被更先进的集合取代，但其子类Properties依然活跃在历史舞台

　　Properties集合是一个唯一和IO流相结合的集合

 

 3.JDK9中的集合优化  of方法 只适用于List，Map，set接口 不适用与其子类

　　（1）of方法返回值是一个不可改变的集合，不能使用add和put方法

 　  （2）Set和Map接口在调用of方法时，不能有重复的元素

斗地主案例Map版本

package basicpart.day01.DataStructure;

import java.util.*;

public class MapDouDiZhu {
    public static void main(String[] args) {
        //通过pai方法获取牌
        Map<Integer, String> map = pai();
        System.out.println(map);
        //获取一个打乱牌的顺序
        List<Integer> order = getOrder();
        System.out.println(order);
        //遍历顺序集合去发牌
        gameSet(map, order);
    }

    private static void gameSet(Map<Integer, String> map, List<Integer> order) {
        List<String> player01 = new ArrayList<>();
        List<String> player02 = new ArrayList<>();
        List<String> player03 = new ArrayList<>();
        List<String> dipai = new ArrayList<>();
        for (int i = 0; i < order.size(); i++) {
            if(i >= 51){
                String s = map.get(order.get(i));
                dipai.add(s);
            } else if(i %3 ==0){
                String s = map.get(order.get(i));
                player01.add(s);
            } else if(i %3 == 1){
                String s = map.get(order.get(i));
                player02.add(s);
            } else if(i %3 ==2){
                String s = map.get(order.get(i));
                player03.add(s);
            }
        }
        System.out.println(dipai);
        System.out.println(player01);
        System.out.println(player02);
        System.out.println(player03);
    }


    private static Map<Integer, String> pai() {
        List<String> colors = List.of("♦", "♣", "♥", "♠");
        List<String> numbers = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
        List<String> pocker = new ArrayList<>();
        pocker.add("大王");
        pocker.add("小王");
        for (String number : numbers) {
            for (String color : colors) {
                pocker.add(color + number);
            }
        }
        Map<Integer, String> map = new HashMap<>();
        for (int i = 0; i <= 53; i++) {
            map.put(i, pocker.get(i));
        }
        return map;
    }

    public static List<Integer> getOrder() {
        List<Integer> order = new ArrayList<>();
        for (int i = 0; i < 54; i++) {
            order.add(i);
        }
        Collections.shuffle(order);
        return order;
    }
}

 4.异常处理

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?
编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

throw：

　　使用格式：throw new xxxException（“异常产生的原因”）

　　注意：　　

　　　　1.throw关键字必须写在方法的内部

　　　　2.new 后边的对象必须是Exception或者Exception的子类对象

　　　　3.throw关键字抛出指定的异常对象，我们就必须处理处理这个异常对象，如果是RuntimeException或其子类异常，可以不处理，交给JVM

　　　　　　如果是编译异常，就必须处理，要么throws，要么try...catch...

 　　　　注意：空指针异常和索引越界异常都是运行期异常，我们不用处理，默认交给JVM处理

Objects非空判断

　　还记得我们学习过一个类Objects吗，曾经提到过它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），那么在它的源码中，对对象　　为null的值进行了抛出异常操作。
　　public static <T> T requireNonNull(T obj) :查看指定引用对象不是null。

5.声明异常throws（交给别人处理，谁调用的方法，就交给谁，最终给JVM处理）

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲
解该方式），那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
声明异常格式：修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{ }

public class DemoException {
    public static void main(String[] args) throws FileNotFoundException {
        readFile("c://a.txt");
    }
    private static void readFile(String fileName) throws FileNotFoundException {
        if(!fileName.equals("d://a.txt")) {
            throw new FileNotFoundException("路径错误");
        }
    }
}

注意：FileNotFoundException是编译异常，找到了就要进行处理，IOException也是，且是它的父类，两个都出现是，抛出父类异常就可以了

6.捕获异常 try...catch...

try-catch的方式就是捕获异常。
捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
捕获异常语法如下：

public class DemoException {
    public static void main(String[] args) {
        try{
        readFile("c://a.txt");}
        catch (FileNotFoundException e){
            System.out.println("catch -- 传递的文件路径错误");
        }
        System.out.println("程序继续");
    }
    private static void readFile(String fileName) throws FileNotFoundException {
        if(!fileName.equals("d://a.txt")) {
            throw new FileNotFoundException("路径错误");
        }
    }
}

 如何获取异常信息：
Throwable类中定义了一些查看方法:

apublic String getMessage() :获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
public String toString() :获取异常的类型和异常描述信息(不用)。
public void printStackTrace() :打印异常的跟踪栈信息并输出到控制台。
包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

7.finally代码块  一般用于资源回收  无论程序是否出现异常，都会执行该代码块

必须和try一起使用

使用一个try，多个catch时：

　　若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。  （因为会出现多态）
（1）如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
（2）父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

8.自定义异常

异常类如何定义:
1. 自定义一个编译期异常: 自定义类 并继承于 java.lang.Exception 。
2. 自定义一个运行时期的异常类:自定义类 并继承于 java.lang.RuntimeException 。

9.多线程

并发与并行:
　　并发：指两个或多个事件在同一个时间段内发生。（交替执行）
　　并行：指两个或多个事件在同一时刻发生（同时发生）。

线程与进程：

　　进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运　　行一个程序即是一个进程从创建、运行到消亡的过程。
　　线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。　　
　　一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
　　简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

开启多线程：

1.先创建一个线程继承Thread：
public class MyThread01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run" + i);
        }
    }
}
2.创建其子类，并执行start方法启动线程
public class DemoThread {
    public static void main(String[] args) {
        MyThread01 thread1 = new MyThread01();
        Person p1 = new Person("chris");
        p1.run();
        thread1.start();
    }
}

内存图解：