JAVA学习日志10（set集合和map）

JAVA学习日志10

Set集合
1.是Collection的子类 Set也是一个接口
2.特点:

1. set集合存的数据不能重复
2. set集合是无序 存与取获取的顺序不一样
3. set集合没有索引
4. set集合方法都是Collection的方法
5. 实现类 : 实例化对象的时候 只能实例化其子类

• set集合的遍历方法（一）
  1.没有泛型的set 可以把其转换成数组 toArray() 方法

public static void main(String[] args) {
	Set set = new HashSet();
	set.add(1);
	set.add(2);
	set.add(3);
	Object []obj=set.toArray();
	for(int i=0;i<set.size();i++) {
		System.out.println(obj[i]);
	}
}

2.有范型的set，在使用toArray转化时，参数要写明转换的后的数组类型和长度

public static void main(String[] args) {
	Set<MyClass> set = new HashSet<MyClass>();
	set.add(new MyClass("No1","小明",19));
	set.add(new MyClass("No2","小红",19));
	MyClass[] line = set.toArray(new MyClass [set.size()]);
	for(int i=0;i<line.length;i++) {
		System.out.println(line[i]);
	}
}

• set集合的遍历方法（二）
  使用迭代器

public static void main(String[] args) {
	Set<MyClass> set = new HashSet<MyClass>();
	set.add(new MyClass("No1","小明",19));
	set.add(new MyClass("No2","小红",19));
	Iterator ite = set.iterator();
	while(ite.hasNext()) {
		System.out.println(ite.next());
	}
}

• set集合的遍历方法（三）
  1.使用加强的for循环，加强的for循环 其实也是由迭代器实现的，只不过是进行了封装。所以在for循环里通过集合的方法来对元素进行改动时还是会出现并发错误
  2.语法（这里的变量a相当于迭代器里的当前元素）
  for(数据类型 变量a :需要遍历的集合与数组){
  得到每次遍历的数据
  }

public static void main(String[] args) {
	Set<MyClass> set = new HashSet<MyClass>();
	set.add(new MyClass("No1","小明",19));
	set.add(new MyClass("No2","小红",19));
	for(MyClass temp:set) {
		System.out.println(temp);
	}
}

HashSet
hash表的结构，在jdk1.8之前hash表是由 数组+链表 组成的，1.8之后是由 数组+链表、数组+链表/红黑树 组成的。hash的数组里存储的的是hash值，每个数组的单元又会指向一个地址，这个地址存储的是对应hash值的元素。故hash值不同的元素存的组是不同的。

• set存的数据是唯一的，不重复的
  Object类里有两个方法 hashcode、equals。元素存储时先通过hashcode算出hash值，根据对应的hash值在数组里找到应该存储的组。如果数组里没有找到该hash值，则把该hash值存入数组，元素也存入链表。元素在存入组内时通过equals方法判断是否已经由内容相同的元素（不同的内容可能会有相同的hash值），没有则存入。
  当new 到两个对象并给他们的成员变量赋予相同的值时，他们的地址值是不同的，所以hash值也基本是不同的，这样两个对象都会存到set里。如果set里不想存储成员变量相同的对象，可以重写hashcode 和 equals方法

LinkedHashSet
LinkHashSet 相比于HashSet在链表部分多了一条链，这条链用来记录元素的顺序，这样就实现了有序

• 使用场景:1. 除去重复 2.有序

Map
map是双列集合，是以键值进行存储的，一个键（key）一个对应的值（value）。键是唯一的。Map不能实例化，只能实例化子类。

• 一些方法

  V put(K key ,V value)	添加 ( 以键值对来进行存储)
  V remove(Object key)	根据键来删除
  V get(Object key)	根据键来获取值
  Set keySet()	获取所有的键，返回类型是set集合
  boolean isEmpty()	判断是否有元素
  void clear()	清楚集合中所以的数据
  boolean containsKey(Object key)	判断键是否存在
  boolean containsValue(Object value)	判断值是否存在
  int size()	获取集合的长度
  Set<Map.Entry<K,V>> entrySet()	返回类型是Set<Map.Entry<K,V>>

• Map的遍历方法（一）
  把Map里不重复的key获取到set里，遍历set时根据key去找到value

public static void main(String[] args) {
	Map<Integer, MyClass> map = new HashMap<Integer, MyClass>();
	map.put(1, new MyClass("No1","小明",19));
	map.put(2, new MyClass("No2","小红",19));
	Set<Integer> keySet = map.keySet();
	for(Integer temp:keySet) {
		System.out.println(temp+" "+map.get(temp));
	}
}

• Map的遍历方法（二）
  通过entryset把map里的键值对成对（键 - 值）的获取到一个set里，通过set遍历每一对键值

public static void main(String[] args) {
	Map<Integer, MyClass> map = new HashMap<Integer, MyClass>();
	map.put(1, new MyClass("No1","小明",19));
	map.put(2, new MyClass("No2","小红",19));
	Set<Entry<Integer, MyClass>>kvset = map.entrySet();
	for(Entry<Integer, MyClass> temp:kvset) {
		System.out.println(temp.getKey()+" "+temp.getValue());
	}
}

HashMap LinkedHashMap
HashSet的底层也是使用HashMap来实现的，HashSet 其实只需要 HashMap 键的那一部分就可以
待补充

Collections
工具类

public static int binarySearch(List<? extends Comparable<? super T>> list,T key)	查找指定的值的索引
public static void fill(List<? super T> list,T obj)	对集合中的数据进行填充 填充的数据就是obj
public static int frequency(Collection<?> c,Object o)	查询当前数据o在集合出现的次数
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)	得到集合中最大的值
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)	得到集合中最小的值
public static boolean replaceAll(List list,T oldVal,T newVal)	把集合中旧的值 使用新的值进行全部替换
public static void reverse(List<?> list)	控制反转
public static void shuffle(List<?> list)	随机置换
public static <T extends Comparable<? super T>> void sort(List list)	排序
public static void swap(List<?> list,int i,int j)	根据索引来交换集合中的值

生成斗地主的扑克牌

public static void main(String[] args) {
	String []huase = new String[] {"红桃","方块","梅花","黑桃"};
	String []nums = new String[] {"A","1","2","3","4","5","6","7","8","9","J","Q","K"};
	Map<Integer, String> pai = new HashMap<Integer, String>();
	int count=2;
	pai.put(0, "大王");
	pai.put(1, "小王");
	//循环嵌套创建好扑克牌，把牌放到map里
	for(int i=0;i<huase.length;i++) {
		for(int j=0;j<nums.length;j++) {
			pai.put(count, huase[i]+nums[j]);
			count++;
		}
	}
	//取出map的key即牌的索引，存到list里
	Set<Integer>  indexs = pai.keySet();
	List<Integer> newIndex = new ArrayList<Integer>();
	for(Integer temp  :indexs) {
		newIndex.add(temp);
	}
	//洗牌
	Collections.shuffle(newIndex);
	//构建4个玩家，存牌的索引，用treeSet存储，treeSet里的数据会自动排序
	TreeSet<Integer> play1 = new TreeSet<Integer>();
	TreeSet<Integer> play2 = new TreeSet<Integer>();
	TreeSet<Integer> play3 = new TreeSet<Integer>();
	TreeSet<Integer> dipai = new TreeSet<Integer>();
	
	
	for(int i=0;i<newIndex.size();i++) {
		if(i>newIndex.size()-4) {
			dipai.add(newIndex.get(i));
		}else if(i%3==1) {
			play1.add(newIndex.get(i));
		}else if(i%3==2){
			play2.add(newIndex.get(i));
		}else if(i%3==0) {
			play3.add(newIndex.get(i));
		}
	}
	//展示
	System.out.println("玩家一");
	for(Integer index:play1) {
		System.out.print(pai.get(index)+" ");
	}
	System.out.println("\n玩家二");
	for(Integer index:play2) {
		System.out.print(pai.get(index)+" ");
	}
	System.out.println("\n玩家三");
	for(Integer index:play3) {
		System.out.print(pai.get(index)+" ");
	}
	System.out.println("\n底牌");
	for(Integer index:dipai) {
		System.out.print(pai.get(index)+" ");
	}

}