JavaSE10

package day10;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 线程安全的集合：
 * 常用的集合实现类：ArrayList,LinkedList，HashSet它们都不是
 * 线程安全的，多线程情况下使用会出现并发问题
 * Collections提供了集合转换为线程安全的方法
 * @author 臻冉
 *
 */
public class CollectionSystemDemo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		System.out.println(list);

		//将该集合转化为线程安全的
		list = Collections.synchronizedList(list);
		System.out.println(list);
		
		Set<String> set= new HashSet<String>();
		set = Collections.synchronizedSet(set);
		
	}
}

package day10;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 双端队列
 * java.util.Deque接口，它继承自java.until.Queue
 * 
 * 双端队列的特点：
 * @author 臻冉
 *
 */
public class DequeDemo {
	public static void main(String[] args) {
		Deque<String> deque = new LinkedList<String>();
		/*
		 * 入队操作 offer()
		 */
		deque.offer("one");
		deque.offer("two");
		deque.offer("three");
		deque.offer("four");
		System.out.println(deque);
		
		//从队首方向入队
		deque.offerFirst("zero");
		System.out.println(deque);
		deque.offerLast("ten");
		System.out.println(deque);
		
		//出队操作(队首)并删除
		String str = deque.pollFirst();
		System.out.println(str);
		
		//出队操作(队首)并删除
		String str2 = deque.pollLast();
		System.out.println(str2);
		
	}
}

HashMap

package day10;
/**
 * HashMap内部有数组保存键值对，存储元素时根据Key的hashcode值计算数组索引，并将键值对存入，
 * 获取时也根据该计算索引直接找到该元素，所以HashMap根据这个方式避免了查找元素时对数组的遍历
 * 操作，所以其不受元素的多少而影响查询性能
 * 
 * 由于Key的hashcode决定键值对在HashMap中数组索引位子，而equals方法决定着Key是否重复，所以这个方法要妥善重写
 * 
 * hashcode与equals方法是定义在Object中的，所以要妥善的重写这两个方法，当我们定义的类需要重写equals
 * 和hashcode时，必须遵循以下原则：
 * 1、成对重写，当我们需要重写一个类的equals方法时，就应当同重写hashcode方法。
 * 2.一致性，当两个对象equals比较为true时，hashcode值应当相等
 * 3、稳定性，当参与equals比较的属性没有发生变化的情况下，多次强调用hashcode方法返回的数字不应当有变化。
 * @author 臻冉
 *
 */
public class Key {
	private int x;
	private int y;
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + x;
		result = prime * result + y;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Key other = (Key) obj;
		if (x != other.x)
			return false;
		if (y != other.y)
			return false;
		return true;
	}
}

package day10;

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

/**
 * java.util.Map接口
 * Map称为查找表，该数据结构体现的样子是一个“多行两列”的表格，左列称为Key,右列称为value;
 * Map总是根据Key查找对应的value,
 * 存储元素也要求key-value成对存入，key什么类型都可以
 * 
 * 常用的实现类：java.util.HashMap散列表，哈希表HashMap是基于散列算法实现的Map，当今世界上最快的查询结构
 * @author 臻冉
 *
 */
public class MapDemo {
	public static void main(String[] args) {
		Map<String,Integer> map = new HashMap<String,Integer>();
		/**
		 * V put(Key key,Value value);
		 * 将给定的Key-value键值对存入到Map中，Map有一个要求
		 * key值不允许重复（key的equals比较决定），若使用Map一有的Key存入value,
		 * 则是替换value操作，那么put方法返回的就是被替换的value,若没有替换，则返回null
		 * 
		 * 对应value是包装类型的情况，切记，不要用基本类型接受返回值，因为会触发自动拆装箱特性
		 * 否则会引发空指针异常
		 */
		
		/*Integer score = map.put("语文", 96);//如果值没有被替换，则返回null
		Integer score2 = map.put("语文", 99);
		System.out.println(score2);*/
		
		map.put("语文", 98);
		map.put("英语", 96);
		map.put("数学", 92);
		map.put("化学", 100);
		System.out.println(map);
		
		//map集合的长度size()
		int size = map.size();
		//System.out.println(size);
		/*
		 * V get(Key key)
		 * 根据给定的key获取对应的value，若给定的key不存在，则返回为null
		 */
		//查看数学成绩
		int n = map.get("数学");
		//System.out.println(n);
		
		/*Scanner scanner = new Scanner(System.in);
		while(true){
			System.out.println("请输入你要查询的科目：");
			String str = scanner.next();
			Integer m = map.get(str);
			if(m==null){
				System.out.println("没有此科目，请重新填写科目：");
				continue;
			}
			System.out.println(m);
		}*/
		
		/*
		 * V remove(key key)
		 * 删除当前map给定的key所对应的这组键值对
		 * 对应的value，若给的那个key在map中不存在，再返回null
		 */
		Integer mm = map.remove("英语");
		System.out.println("被删掉的value"+mm);
		System.out.println(map.size()+","+map);
		
		/*
		 * 判断当前map是否包含给定的key或value
		 */
		boolean ck = map.containsKey("英语");
		System.out.println(ck);
		
		boolean v = map.containsValue(98);
		System.out.println(v);
		
		//清空集合
		map.clear();
		System.out.println(map.size());
		
		//判断集合是否为空
		System.out.println(map.isEmpty());
		
		
	}
}

```java
package day10;

import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * Map的遍历
 * Map有3种：
 * 1、遍历所有的key
 * 2、遍历所有的key-value键值对
 * 3、遍历所有的value(相对不常用)
 * @author 臻冉
 *
 */
public class MayDemo02 {
	public static void main(String[] args) {
		Map<String,Integer> map = new HashMap<String,Integer>();
		map.put("语文",96);
		map.put("数学", 100);
		map.put("英语", 89);
		map.put("化学", 100);
		System.out.println(map);
		
		//可以有序的存入集合
		Map<String,Integer> linked = new LinkedHashMap<String,Integer>();
		linked.put("语文",96);
		linked.put("数学", 100);
		linked.put("英语", 89);
		linked.put("化学", 100);
		System.out.println(linked);
		
		/*List:有序 可重复
		 * Set:无序 不能重复
		 * 1.遍历所有的key:
		 * Map提供了方法：keySet()
		 * Set keySet()
		 * 将当前Map中所有的Key()存入一个集合后返回遍历这个set集合等于遍历了所有的key
		 */
		map.keySet();
		
		Set<String> keyset = map.keySet();
		for(String key:keyset){
			System.out.println(key);
		}
		
		
		/*
		 * 3.遍历所有的value(相对不常用)
		 * Collection values()
		 * 将当前的Map中所有的values以一个集合的形式返回
		 */
		Collection<Integer> values = map.values();
		for(Integer v:values){
			System.out.println(v);
		}
		
		//求集合中科目平均值
		double sum=0.0;
		for(Integer v:values){
			sum += v;
		}
		System.out.println(sum/map.size());
		
		//UI --->前端--->后端（控制层--->业务层--->持久层(数据库操作)--->数据库表设计
		/*
		 * 2.遍历所有的key-value键值对
		 * 遍历每一组键值对，在Map接口中定于了一个内部接口，java.util.Map.Entry
		 * Entry的每个实例用于表示当前Map中的一组键值对，提供了两个常用方法；
		 * K getKey():获取key的值
		 * V getValue()：获取value值
		 * 
		 * 不同的Map实现类都实现了Entry,并用实现类中的每个实例表示一个具体的键值对
		 * 
		 * Set<>  entrySet()该方法会将Map中所有键值对存入一个集合返回
		 */
		Set<Entry<String,Integer>> entry = map.entrySet();
		for(Entry<String,Integer> e:entry){
			String key = e.getKey();//从Entry中获取Map中的每一个Key
			Integer value = e.getValue();//从Entry中获取Map中的每一个value
			System.out.println(key+","+value);
		}
		  
	}
}

实例

package day10;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class ListAndMapDemo {
	 public static void main(String[] args) {
	  Map<String,Double> tv=new HashMap<String,Double>();
	  tv.put("平板电视", 3500.00);
	  tv.put("家庭影音", 12000.0);
	  
	  Map<String,Double> washing=new HashMap<String,Double>();
	  washing.put("对开门冰箱", 8800.00);
	  washing.put("立式柜空调", 6800.00);
	  
	  Map<String,Double> cosmetics=new HashMap<String,Double>();
	  cosmetics.put("兰蔻", 3000.00);
	  cosmetics.put("欧莱雅", 280.00);
	 
	  List<Map<String,Double>> list=new ArrayList<Map<String,Double>>();
	  list.add(tv);
	  list.add(washing);
	  list.add(cosmetics);
	 System.out.println(list);
	 
	 for(Map<String,Double> map:list){
	  System.out.println(map);
	  Set<Entry<String, Double>> entry=map.entrySet();
	  for(Entry<String, Double> e:entry){
	   String key=e.getKey();//从Entry中获取Map中的每一个key
	   Double value=e.getValue();//从Entry中获取Map中的每一个value
	   System.out.println(key+","+value);
	  }
	  }
	 }
	}

package day10;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class MapAndListDemo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("admin");
		list.add("passward");
		list.add("address");
		
		List<Integer> list2 = new ArrayList<Integer>();
		list2.add(300);
		list2.add(500);
		list2.add(800);
		
		List<Double> list3 = new ArrayList<Double>();
		list3.add(100.89);
		list3.add(1000.00);
		list3.add(3000.98);
		
		Map<String,Object> map = new HashMap<String,Object>();
		map.put("username", list);
		map.put("list2", list2);
		map.put("list3", list3);
		
		//获取用户信息
		Object obj = map.get("username");
		System.out.println(obj);
		
		//编写map集合中的list集合所有元素
		Set<Entry<String,Object>> entry = map.entrySet();
		for(Entry<String,Object> e:entry){
			String key = e.getKey();
			List<Object> li = (List<Object>)e.getValue();
			for(Object o:li){
				System.out.println(o);
			}
		}
		
	}
}

Set

package day10;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import day09.Point02;

/**
 * set集合：不可重复，无序
 * 实现Set接口的类是HashSet
 * @author 臻冉
 *
 */
public class SetDemo {
	public static void main(String[] args){
		Set<String> set = new HashSet<String>();
		set.add("1");
		set.add("2");
		set.add("33");
		set.add("47");
		set.add("15");
		set.add("6");
		set.add("bb");
		set.add("6");
		System.out.println(set);
		
		Set<Point02> set2 = new HashSet<Point02>();
		//Set集合是不能重复  是通过equals作比较
		set2.add(new Point02(2,3));
		set2.add(new Point02(4,3));
		set2.add(new Point02(3,3));
		set2.add(new Point02(2,9));
		set2.add(new Point02(2,3));
		System.out.println(set2.size());
		System.out.println(set2);
		
		List<Point02> list = new ArrayList<Point02>();
		
		//list集合可重复，有序
		
		list.add(new Point02(2,3));
		list.add(new Point02(5,3));
		list.add(new Point02(7,4));
		list.add(new Point02(2,3));
		list.add(new Point02(8,3));
		list.add(new Point02(4,3));
		System.out.println(list.size());
		System.out.println(list);
		
	}
}

栈

package day10;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 栈：
 * 栈可以存储一组元素，但是存取元素必须遵循：先进后出原则；
 * 栈可以通过双端队列Deque实现
 * 
 * 通常栈用于“后退”这样的操作
 * @author 臻冉
 *
 */
public class StackDemo {
	public static void main(String[] args) {
		Deque<String> stack = new LinkedList<String>();
		//入栈操作（队首入列）方法push()
		stack.push("one");
		stack.push("two");
		stack.push("three");
		stack.push("four");
		System.out.println(stack);
		
		//出栈操作
		String s = stack.peek();
		System.out.println(s);
		System.out.println(stack);
		
		//出队操作（从队首删除并返回一个元素）pop()
		String str= stack.pop();
		System.out.println(str);
		System.out.println(stack);
		while(!stack.isEmpty()){
			String str2= stack.pop();
			System.out.println("出栈后的："+stack);
		}
		
		//pop和poll两者在实现所有数据结构不同：
		//poll是基于队列结构实现的方法，当队列中没有元素时，调用该方法返回null
		//pop是基于栈结构实现的方法，当栈中没有元素时，调用该方法会发生异常
		//pop和poll都是取出linkedList的第一个元素，并将该元素删除，等效于：removeFirst
		String str3 = stack.pop();
		System.out.println(str3);//当主函数中空时，将没有什么东西拿来出队
		
	}
}

队列

package day10;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 队列可以保存一组元素，但是存取元素必须遵循：先进先出原则
 * Java.until.Queue接口规定了队列乡关存取元素等操作。
 * Queue继承自Java.util.Collection,所以集合的相关方法也具备，
 * 比如，clear等常用功能；
 * 常用实现类Java.until.LinkedList
 * 
 * @author 臻冉
 *
 */
public class QueueDemo {
	public static void main(String[] args) {
		Queue<String> queue = new LinkedList<String>();
		//入队操作:Queue提供了入队方法offer()
		queue.offer("one");
		queue.offer("翠花");
		queue.offer("three");
		queue.offer("four");
		//System.out.println(queue);
		
		//引用队首元素，不做出队操作（返回队首的元素，但是并不删除）peek方法
		
		String str = queue.peek();
		//System.out.println(str);
		//System.out.println(queue);
		
		//出队操作（从队首删除并返回一个元素）poll()
		
		/*while(queue.poll()!=null){
			String str2 = queue.poll();
			System.out.println("清理"+str2);
			System.out.println(queue);
		}*/
		
		//是这把队列中所有元素出队操作并删除(用循环做)
		String str2 = queue.poll();
		System.out.println(str2);
		System.out.println(queue);
		/*for(int i=0;i<queue.size();i++){
			queue.poll();
		}
		System.out.println("queue:"+queue);*/
		
		while(!queue.isEmpty()){
			queue.poll();
		}
		System.out.println("queue:"+queue);
		
	}
}

实例

package day10;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class UstAndMapDemo {
	public static void main(String[] args) {
		Map<String,Double> tv = new HashMap<String,Double>();
		tv.put("平板电视", 3500.00);
		tv.put("家庭影音", 12000.00);
		
		Map<String,Double> washing = new HashMap<String,Double>();
		washing.put("对开门冰箱", 8888.88);
		washing.put("立式空调", 6800.00);
		
		Map<String,Double> cosmetics = new HashMap<String,Double>();
		cosmetics.put("兰蔻", 3000.00);
		cosmetics.put("欧莱雅", 288.00);
		
		
		
		List<Map<String,Double>> list = new ArrayList<Map<String,Double>>();
		
		list.add(tv);
		list.add(washing);
		list.add(cosmetics);
		System.out.println(list);
		
		//遍历List集合并且便利出map中的所有key和value
		for(Map<String, Double> map:list){
			//System.out.println(map);
			//Set<String> strings = map.keySet();
			Set<Entry<String,Double>> entry = map.entrySet();
			for(Entry<String,Double> e:entry){
				String key = e.getKey();
				Double value = e.getValue();
				System.out.println(key+","+value);
			}
			
			
			/*for(String key:strings){
				System.out.println(key);
				System.out.println(map.get(key));
			}*/
		}
		
	}
}