java基础-day16-集合(二).Map 接口 HashMap 线程创建(一)

Set 集合给自定义对象去重

注：如果想利用set集合给自定义对象去重，需要同时重写hashCode()和equals()

import java.util.HashSet;
//这个类用来测试  Set集合自定义对象去重！
//总结：
//！！如果想要使用set集合，给你的自定义  对象  去重的话  ，，需要同时重写hashCode()  和equals()
//重写hashCode()：原来的实现方式是：只要new就会给计算一个新的哈希码值。
			//现在需要按照对象的属性值计算哈希码值，就算new两次，属性值一样时也必须产生相同哈希码值
//重写equals()：原来比的是两个对象间的地址值，现在要去比较两个对象间的属性值，如果属性值都一样，必须相同
public class test1 {
	public static void main(String[] args) {
		HashSet<Student> set = new HashSet<>();
		// 创建元素
		Student s1 = new Student("西门庆", 20);
		Student s2 = new Student("武大郎", 19);
		Student s3 = new Student("潘金莲", 21);
		Student s4 = new Student("小龙女", 23);
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s4);
		Student s5 = new Student("潘金莲", 21);
		Student s6 = new Student("小龙女", 23);
		//！！！往set中添加重复元素--属性值完全相同的两个对象没给去重！！
		set.add(s5);
		set.add(s6);
		System.out.println(s3.hashCode());
		System.out.println(s5.hashCode());
			//满足以下的判断条件，才能给自定义对象去重！！
		 // if ( p.hash == hash &&  ((k = p.key) == key || (key != null && key.equals(k))))
		//条件1：p.hash == hash --判断两个对象的hash值一样吗？不一样！
		//需求1：就算new两次，只要两个对象间的属性值完全一样，给我产生一样的哈希码值就好了 -  重写hashCode()
		//条件2：key.equals(k)--让两个对象间的equals()返回true  -  重写equals()
		System.out.println(set);
	}
}
class Student {
		public Student() {}
		public Student(String name, int age) {
			this.name = name;
			this.age = age;
		}
		private String name;
		private int age;
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		@Override
		public String toString() {
			return "Student [name=" + name + ", age=" + age + "]";
		}
		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + age;
			result = prime * result + ((name == null) ? 0 : name.hashCode());
			return result;
		}
		@Override
		public boolean equals(Object obj) {
			if (this == obj)
					return true;
			if (obj == null)
					return false;
			if (getClass() != obj.getClass())
					return false;
				Student other = (Student) obj;
			if (age != other.age)
					return false;
			if (name == null) {
				if (other.name != null)
				return false;
			} else if (!name.equals(other.name))
				return false;
		return true;
	}		
}

Map 接口

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
一些映射实现则不保证顺序，如 HashMap 类
常见方法：

V put(K key, V value)                       将指定的值与此映射中的指定键关联（可选操作）
V remove(Object key)                        如果存在一个键的映射关系，则将其从此映射中移除（可选操作）
V get(Object key)                           返回指定键所映射的值
void clear()                                从此映射中移除所有映射关系
boolean containsKey(Object key)             如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value)         如果此映射将一个或多个键映射到指定值，则返回 true
boolean equals(Object o)                    比较指定的对象与此映射是否相等
int hashCode()                              返回此映射的哈希码值
boolean isEmpty()                           如果此映射未包含键-值映射关系，则返回 true。 
int size()                                  返回此映射中的键-值映射关系数
void putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中
Collection<V> values()                      返回此映射中包含的值的 Collection 视图
Set<K> keySet()                             返回此映射中包含的键的 Set 视图
Set<Map.Entry<K,V>> entrySet()              返回此映射中包含的映射关系的 Set 视图

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
//这个类用来测试  Map接口
public class test2 {
		public static void main(String[] args) {
			// 1，创建map对象
			// map集合中，需要同时约束键和值的 元素 类型
			Map<Integer, String> map = new HashMap();
			// 2，常用方法
			// 向map中添加数据时，需要同时指定key和value的值
			map.put(9529, "秋香姐");
			map.put(9527, "唐伯虎");
			map.put(9528, "如花");
			map.put(9528, "石榴姐");		
			// 特点：数据无序 + 当key相同时value会被覆盖
			System.out.println(map);
			// map.clear();
			System.out.println(map.containsKey(9527));// 是否包含指定的key
			System.out.println(map.containsValue("如花"));// 是否包含指定的value
			System.out.println(map.equals("石榴姐"));// 判断两者是否相等
			System.out.println(map.get(9528));// 根据指定的key找对应的value
			System.out.println(map.hashCode());// 计算map在内存中的哈希码值
			System.out.println(map.isEmpty());// 判断集合是否为空
			System.out.println(map.size());// 返回集合的长度
			System.out.println(map.remove(9527));// 根据key删除元素
			Collection<String> c = map.values();// 把map中的所有值获取到并存入collection中
			System.out.println(c);
			// 迭代map集合 -- set
			// 1、把所有的key放入set中，遍历set   --  两种方式：iterator()  foreach 
			Set<Integer> set = map.keySet();
			//foreach可以用在数组遍历时，或者List遍历时或者Set遍历时
			for (Integer in : set) {
				System.out.println("key:"+in);
				String value = map.get(in);
				System.out.println("value："+value);
			}	
			Iterator<Integer> it = set.iterator();
			while (it.hasNext()) {
				Integer key = it.next();// 获取set中的元素，也就是每个key
				String value = map.get(key); // 拿着key去map里找对应的value
				System.out.println(key + "===" + value);
			}
			// 2、把key和value封装成Entry对象，并放入set中，遍历set
			Set<Entry<Integer, String>> set2 = map.entrySet();
			Iterator<Entry<Integer, String>> it2 = set2.iterator();
		while (it2.hasNext()) {
			Entry<Integer, String> entry = it2.next();//遍历set得到每个entry对象
					
			Integer key = entry.getKey();//获取每个key
			String value = entry.getValue();//获取每个value
			System.out.println(key+"---"+value);
		}			
	}
}

HashMap

当需要向map中存储元素时，底层会根据hash算法计算对象的存储位置
如果这个位置上没有存过元素，就直接存放，就相当于直接作为数组的元素存在
如果这个位置上存过数据，就会形成链表的结构–hash碰撞/冲突
我们尽量要让每个对象拥有自己的哈希值，尽量放在数组结构上。避免链表的形成，因为链表查询效率低

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
//这个类用来测试Map接口的方法
public class test3 {
	public static void main(String[] args) {
		//1、创建对象
		Map<String,String> map = new HashMap<>();
		//2、存数据
		map.put("1", "jack");
		map.put("2", "rose");
		map.put("3", "tom");
		map.put("4", "jerry");		
		// 3、迭代map集合  --   keySet()     entrySet()
		Set<String> set = map.keySet();//把key都放set里
		for (String key : set) {//遍历set得到每个key
			String value = map.get(key);
			System.out.println( key + " ：：：："+value);
		}	
		Set<Entry<String,String>> set2 = map.entrySet();//把map里的每条记录封装成Entry对象存入set
		for (Entry<String, String> entry : set2) {//遍历set得到每个Entry对象
				System.out.println(  entry.getKey()  +"===="+  entry.getValue() );
		}	
	}
}

统计字符串中字符出现的次数

import java.util.HashMap;
import java.util.Scanner;

//统计字符串中字符的出现次数
public class test4 {
	public static void main(String[] args) {
		//1，接收用户输入的字符串
		String input = new Scanner(System.in).nextLine();
		//定义map存数据，数据的格式类似于：a=1,b=2,c=3
		HashMap<Character, Integer> map = new HashMap<>(); 
		//2，遍历字符串，获取每个字符  i < input.length()  下标最大值是字符串长度-1
		for(int i = 0 ; i < input.length()  ; i++) {
			
			//根据下标，获取对应的字符
			char key = input.charAt(i);
			//3，统计字符出现过几次--map里的value是多少？
			Integer value = map.get(key);
			if( value == null ) {//如果之前没存过字符，value存的就是默认值null
				map.put(key, 1);//把value的默认值null改成1，说明第一次统计这个字符的次数
			}else {//如果value不是默认值，也就是以前就统计过了
				map.put(key, value+1);//把value的值改成原来的数字+1就行
			}
		}
		System.out.println(map);//打印map里存的数据{a=1,b=2,c=3}
	}
}

多线程

进程和线程的区别：
一个软件的运行最少需要一个进程支撑，一个进程又可以启动多个线程来执行
线程是进程的实际单位。也是操作系统可调度的最小单位
如果一个进程，，只包含一个线程 — 单线程程序
如果一个进程，，包含多个线程 — 多线程程序
并发和并行的区别:
如果只有一个CPU在干活，大家都去抢占了CPU资源，发生了资源被抢占的现象–并发
假设有多个CPU在干活，每个CPU干一个任务，只不过是多个CPU一起各干各的–并行
多线程状态:
新建状态–可运行状态–运行状态–阻塞状态–终止状态

多线程创建1：继承Thread

线程 是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程
创建对象:

Thread()          
Thread(Runnable target)  
Thread(Runnable target, String name)  
Thread(String name)                分配新的 Thread 对象

常用方法：

static Thread currentThread()  返回对当前正在执行的线程对象的引用
long getId()                   返回该线程的标识符
String getName()               返回该线程的名称
void setName(String name)      改变线程名称，使之与参数 name 相同
static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
void start()                   使该线程开始执行；Java 虚拟机调用该线程的 run 方法
void stop()                    来终止线程将释放它已经锁定的所有监视器
void run() 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回

//这个类用来测试  多线程编程
public class test5 {
	public static void main(String[] args) {
		//3、创建线程对象
		MyThread thread = new MyThread();//线程状态：新建状态
		//4、启动线程 + 去执行run()
		thread.start();//线程状态：可运行状态，等待CPU调度	
		//5、实现多线程程序：一定是有1个以上的线程对象在执行任务
		MyThread thread2 = new MyThread();
		thread2.start();
		//6、start() 和run() 区别：start()可以实现多线程效果。run()只是当做一个普通的方法调用是一个顺序执行的效果。
		//thread.run();
		//7、程序会自动分配线程名称：命名方式类似于：Thread-0  Thread-1。。。
		thread.setName("美队");//修改线程名称
		thread2.setName("钢铁侠");		
		/*
		* 多线程的随机性：因为程序是交给CPU调度的，CPU的调度过程我们没法控制。
		* 11=Thread-1 10=Thread-0 11=Thread-1
		* 10=Thread-0 11=Thread-1 10=Thread-0 11=Thread-1 10=Thread-0
		*/
	}
}
//1、自定义多线程类：extends Thread
class  MyThread extends Thread{
		//2、把你的业务，重写run()
		@Override
		public void run() {
		//super.run();//默认使用了父类的run()
		for(int i = 0 ; i < 10 ; i++) {
			System.out.println(i+"="+getName());//线程名称
		}
	}
}