MAP、多线程

一，Map的练习
–1，代码
package cn.tedu.util;

	import java.util.*;

	//测试 HashMap实现类
	public class Test5 {
	    public static void main(String[] args) {
	       

	        //TODO Map的练习: 统计用户输入的字符串中的每个字符出现的次数
	        String input = new Scanner(System.in).nextLine();
	        //准备map存数据{a=1,b=2}
	        HashMap<Character,Integer> map2 = new HashMap<>();
	        for (int i = 0; i < input.length(); i++) {
	            char key = input.charAt(i); //获取每个字符
	            //获取以前的value
	            Integer value = map2.get(key);
	            if(value == null){//没存过就是默认值null直接存1
	                map2.put(key,1);
	            }else{//有值了就直接+1
	                map2.put(key,value+1);
	            }
	        }
	        System.out.println(map2);
	    }
	}

二，HashMap
–1，创建对象
HashMap()
构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
–2，常用方法
同Map接口
–3，测试
package cn.tedu.util;

	import java.util.HashMap;

	//测试 HashMap
	public class Test1 {
	    public static void main(String[] args) {
	        //1,创建对象
	        //使用默认的加载因子0.75(可以达到的阈值),使用默认的容量16(桶的大小)
	        HashMap<Integer,String> map = new HashMap();
	        //存数据时,先算位置.hash(key).
	        //判断,如果这个位置没存过数据是null的话,就把数据直接存入Node[] tab数组中
	        //判断,如果这个位置存过数据,会形成链表  p.next=newnode;
	        map.put(100,"jack");
	        map.put(20,"rose");
	        map.put(15,"tony");
	        map.put(20,"jerry");
	        map.put(30,"tommy");
	        System.out.println(map);
	        //TODO 2,调用方法
	        //TODO 迭代Map集合
	    }
	}

--4，练习
	package cn.tedu.util;

	import java.io.File;
	import java.util.Arrays;
	import java.util.HashMap;

	//HashMap练习
	//需求：列出文件夹里的所有资源，
	// 并把资源存入map中{hello=txt,java=jpg,hi=png}
	public class Test2 {
	    public static void main(String[] args) {
	        //1,指定文件夹的路径
	        String path = "E:\\lpx\\day16";
	        File file = new File(path);
	        //2,列出文件夹里的资源
	        File[] a = file.listFiles();
	        //准备map存数据
	        HashMap<String,String> map = new HashMap();
	        //遍历数组，得到每个资源a[i]
	        for (int i = 0; i < a.length; i++) {
	            //3,判断是文件,获取文件名 hello.txt
	            if(a[i].isFile()){
	//                String name=a[i].getName();//hello.txt
	//                String[] s = name.split(".");//[hello,txt]
	                //截取字符串，准备key  --hello
	  //--a[i].getName()获取文件名称--split(".")按照点切割名字--[0]取数组里0下标处的数据
	                String key = a[i].getName().split("\\.")[0] ;
	                //截取字符串，准备value --txt
	                String value = a[i].getName().split("\\.")[1] ;
	                //存入map
	                map.put(key,value);
	            }
	        }
	        System.out.println(map);
	    }
	}

三，多线程
–1，概述
进程是指正在运行的程序。
线程是被包含在进程里。是操作系统能够调度的最小单位也是实际的运作单位。
一个软件的运行需要依赖至少一个进程。
一个进程的运行需要依赖至少一个线程。
单线程是有1个线程，效率低。多线程拥有>1的线程数，来提高效率。
–2，线程的状态
–刚new出来的线程是新建状态
–可运行状态，等着CPU选中
–运行状态，开始执行任务
–终止状态，任务完成
–阻塞状态，运行状态没法干完活，需要等待。等待时机到了重新回到可运行状 态。。。
–3，并发和并行的区别
–并发是指 多个资源抢占一个CPU
–并行是指 每个资源分配一个CPU，不用抢
四，多线程编程
–1，Thread工具类
–创建对象
Thread() 分配新的 Thread 对象。
–常用方法
static Thread currentThread()
返回对当前正在执行的线程对象的引用。
long getId()
返回该线程的标识符。
void setName(String name)
改变线程名称，使之与参数 name 相同。
String getName()
返回该线程的名称。
void run()
static void sleep(long millis)
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
void start()
使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
void stop()
已过时
–测试
package cn.tedu.util;
//测试 Thread工具类
public class Test3 {
public static void main(String[] args) throws InterruptedException {
//1,创建对象
Thread t = new Thread();
//2,调用方法
System.out.println( t.getId() );//获取线程的id
System.out.println( t.getName() );//获取线程的名字Thread-0
t.setName(“test”);//设置线程名称
System.out.println( t.getName() );//获取线程的名字
t.run();//运行
t.start();//开启线程
t.stop();//结束线程
Thread.sleep(100);//使线程休眠
//获取正在执行任务的线程
Thread t2 = Thread.currentThread();
//获取正在执行任务的线程的名字
System.out.println(t2.getName());
System.out.println(Thread.currentThread().getName());
}
}

--2，继承Thread
    package cn.tedu.util;
	//测试 模拟多线程编程
	public class Test4 {
	    public static void main(String[] args) {
	        //1,启动多个线程 测试
	        for (int i = 0; i < 10; i++) {
	//        new MyThread().run();//没有多线程的效果
	            //start()--1,启动线程--2,找到线程类的run()运行
	            new MyThread().start();
	            //new MyThread() --线程是新建状态
	            //start() -- 从新建状态变成可运行状态(等着CPU选中)
	        }
	        //面试题：run()和start()的区别？
	        //run()只是一个普通的方法调用，没有多线程随机的效果
	        //start()开启线程，找到线程里的业务执行
	        /*2,多线程结果的随机性：
	            Thread-0===1
	            Thread-1===1
	            Thread-6===0
	            Thread-3===0
	            Thread-2===1
	         */
	    }
	}
	//1,创建多线程类--继承Thread
	class MyThread extends Thread{
	    //2,把业务放入重写的run()
	    public void run(){//使线程从可运行状态变换成运行状态
	        //需求：打印10次线程名称
	        for (int i = 0; i < 10; i++) {
	            System.out.println(super.getName()+"==="+i);
	        }
	    }//使线程从运行状态变换成 终止状态
	}
--3，实现Runnable接口