JavaEE学习笔记-(2)java集合框架

JCF:java集合框架

• Collection：单值类型集合

  1.List

  类型	底层实现
  ArrayList(数组元素个数)	数组
  LinkedList()	链表
  Vector(数组元素个数,步长)	数组
  Stack()	数组模拟栈

  2.Set

  ​

  类型	底层实现
  HashSet(分组组数,加载因子)	哈希表
  TreeSet(比较器对象)	红黑树

  @HashSet

  特点：无序 唯一
  数据结构：哈希表 -》 哈希吗值 -》 hashCode()

    创建对象：
    HashSet<泛型> set = new HashSet<>();
  
    添加元素：
    set.add(元素);
    Collections.addAll(set,元素,元素,元素....);
    set1.addAll(set2);
  
    判断集合里面是否包含：
    set.contains(元素)
  
    得到集合大小：
    set.size()
  
    删除元素：
    set.remove(元素);
  
    foreach + 迭代器
    
    HashSet验证唯一：
    	HashSet的唯一：hashCode() + equals()
  
    	hashCode():得到对象的哈希码值 -》 决定去到哪一个小组
  
    	equals():挨个每个属性比较 看看到底是不是同一个对象
  
  
    	java中视为相等的两个对象哈希码值一定要一样
    		x.equals(y) == true
    		x.hashCpde() == y.hashCode()
  

  import java.util.*;
  public class Exec1{
  	public static void main(String[] args){
  
  		ArrayList<String> list = new ArrayList<>();
  
  		Collections.addAll(list,"张三","李四","李四","张三","王五");
  
  		//将集合里面的重复元素去除
  		//张三 李四 王五
  
  		ArrayList<String> temp = new ArrayList<>();
  		for(String name : list){
  			if(!temp.contains(name)){
  				temp.add(name);
  			}
  		}
  		System.out.println(temp);
  		
  
  	}
  }
  

  import java.util.*;
  public class Exec1{
  	public static void main(String[] args){
  
  		HashSet<User> mry = new HashSet<>();
  		User u1 = new User("张丽","普通用户",1200);
  		User u2 = new User("汪美丽","普通用户",2900);
  		User u3 = new User("赵小雪","普通用户",300);
  		User u4 = new User("张欣","普通用户",590);
  		User u5 = new User("罗浩","普通用户",1900);
  		User u6 = new User("罗浩","普通用户",1900);
  
  		//将所有用户放进美容院集合里面
  		Collections.addAll(mry,u1,u2,u3,u4,u5,u6);
  		/* u6 添加失败
  			覆盖 hashCode() 和 equals() 方法
          */
          
  		//System.out.println(mry.size());
  
  		//将所有积分>1200分的用户等级修改成超级vip
  		//修改等级 -》 参与生成哈希码值 -》 删除 + 修改 + 添加
  
  		//ArrayList  LinkedList  HashSet
  
  		LinkedList<User> list = new LinkedList<>();
  
  		for(Iterator<User> car = mry.iterator();car.hasNext();){
  			User uu = car.next();
  
  			if(uu.jiFen > 1200){
  				car.remove();
  				uu.dengJi = "超级VIP";
  				list.add(uu);
  			}
  		}
  
  		//mry -> 普通用户
  		//list -》 超级vip
  
  		mry.addAll(list);
  
  		System.out.println(mry);
  
  
  		//打印set集合对象的时候 显示：
  			//[对象1:等级,对象2:等级....]
  
  		//分别统计普通用户 和超级vip占用的比例
  		int x = 0;
  		int y = 0;
  		for(User uu : mry){
  			if(uu.dengJi.equals("普通用户")){
  				x++;
  			}else{
  				y++;
  			}
  		}
  		System.out.println("普通用户比例：" + x * 100 / mry.size()  + "%");
  		System.out.println("超级VIP比例：" + y * 100 / mry.size()  + "%");
  
  	}
  }
  class User{
  	String name;
  	String dengJi;//等级 -》 普通用户 超级vip
  	int jiFen;//积分
  
  	public User(String name,String dengJi,int jiFen){
  		this.name = name;
  		this.dengJi = dengJi;
  		this.jiFen = jiFen;
  	}
  
  	//只要两个对象所有属性都视为相等对象
  
  	@Override
  	public int hashCode(){
  		return name.hashCode() + dengJi.hashCode() + jiFen;
  	}
  	@Override
  	public boolean equals(Object obj){
  		//if if if
  		return this.name.equals(((User)obj).name) &&
  			this.dengJi.equals(((User)obj).dengJi) &&
  				this.jiFen == ((User)obj).jiFen;
  	}
  
  	@Override
  	public String toString(){
  		return name + ":" + dengJi;
  	}
  
  }
  

  @TreeSet

  ​ 一次添加一个元素: set.add(obj)
  ​ 一次添加多个元素: Collections.addAll(set,o1,o2,o3);
  ​ 元素个数： set.size();
  ​ 删除元素: set.remove(obj);
  ​ 清空整个集合: set.clear();
  ​ 遍历：
  ​ 1.foreach
  ​ 2.Iterator 迭代器
  ​ 3.forEach()

  ​ TreeSet特有的方法：
  ​ first() last() 得到第一个/最后一个元素

  ​ pollFirst() pollLast() 得到并删除第一个/最后一个元素

​

​ 如何利用比较器 脱离开一个类不做修改的情况下 指定这个类的排序规则
​ Comparator
​ public int compare(T t1,T t2){
​ …;
​ }

​

​

import java.util.*;
public class Homework{
	public static void main(String[] args){
		Set<Student> cjd = new TreeSet<>(new StudentComparator());
		Student s1 = new Student("明明",80,60,90);
		Student s2 = new Student("红红",60,90,80);
		Student s3 = new Student("凉凉",90,90,91);
		Student s4 = new Student("小王",60,60,58);
		Collections.addAll(cjd,s1,s2,s3,s4);

		//02.请遍历所有元素 查看名次表    
		{
			cjd.forEach(System.out::println);
		}
		System.out.println("=====================================");
		//03.据说红红英语考试作弊 英语成绩清零   
		{
			Set<Student> temp = new TreeSet<>(new StudentComparator());
			for(Iterator<Student> car = cjd.iterator(); car.hasNext(); ){
				Student stu = car.next();
				if("红红".equals(stu.name)){
					car.remove();//1.TestTreeSet5
					stu.english = 0;//2.
					temp.add(stu);//3.TestTreeSet6
				}
			}
			cjd.addAll(temp);

			cjd.forEach(System.out::println);
		}

		//04.小王同学英语成绩有阅卷错误 成绩应该+10
		{

		}

		//05.请打印所有平均分高于85的同学~
		{
			for(Student stu : cjd){
				if(stu.chinese + stu.math + stu.english > 255){
					System.out.println(stu);
				}
			}
		}



	}
}
/*
	01.要求 ： 脱离开Student类制定Student类的比较规则		
	该规则要求：
		优先按照学生三科成绩的平均分降序排列
		如果分数相同 则按照名字排列
		如果分数和名字都相同 -> 也不能舍弃元素
*/
class StudentComparator implements Comparator<Student>{
	@Override
	public int compare(Student s1,Student s2){
		int sum1 = s1.chinese + s1.math + s1.english;
		int sum2 = s2.chinese + s2.math + s2.english;
		if(sum1 != sum2)
			return sum2 - sum1;//分高的在前 降序
		if(!s1.name.equals(s2.name))
			return s1.name.compareTo(s2.name);
		return 1; //
	}
}
class Student{
	String name;
	int chinese;
	int math;
	int english;
	public Student(String name,int chinese,int math,int english){
		this.name = name;
		this.chinese = chinese;
		this.math = math;
		this.english = english;
	}
	@Override
	public String toString(){
		return name + ": " + chinese + " , " + math + " , " + english;
	}
}

Comparable 和 Comparator 有什么区别?
这两个接口都是用于制定排序比较的规则的
Comparable 形容词 有能力比较的
一个类如果实现了这个接口 代表这个类型对象 是可以进行比较的 可以直接放入TreeSet完成排序
Comparator 名词 比较专用的工具
一个类如果实现了这个接口 代表这个类型的对象 是用于比较另一个类型的工具而已
它的对象应该在创建TreeSet的时候 作为参数传给TreeSet

​ 它们包结构就不一样：

​ Comparable java.lang.Comparable

​ Comparator java.util.Comparator

​ 它们当中的抽象方法不同：

​ Comparable public int compareTo(1)

​ Comparator public int compare(1,2)

• Map：键值对类型集合

  类型	底层实现
  HashMap/ Hashtable (分组组数，加载因子)	哈希表
  TreeMap(比较器对象)	红黑树

  Map的基本用法

  如何创建Map集合 泛型限定主键和值两个类型：
  	Map<K,V> map = new HashMap<>();
  
  如何添加元素 不再使用add() 而是put()
  	map.put(k1,v1)
  	*:注意 有map.putAll(另一个Map) 但是没有Collections.putAll();
  
  如何得到元素个数：
  	System.out.println(map.size());
  
  如何通过主键对象得到对应的值对象：
  	System.out.println(map.get(k));
  
  判断是否包含指定的主键：
  	System.out.println(map.containsKey(k));
  
  判断是否包含指定的值：
  	System.out.println(map.containsValue(v));
  
  如何删除一个键值对：
  	map.remove(k);
  
  如何清空整个键值对集合：
  	map.clear();
  

  集合该如何完成遍历~

  keySet() : 得到所有主键对象组成的Set集合 map.get(k) => 得到值

  values() : 得到所有的值对象组成的Collection集合 不能反向找k
  entrySet() : 得到所有键值对对象(Map.Entry)组成的Set集合

​

import java.util.*;
public class Exec1{
	public static void main(String[] args){

		Map<String,Integer> map = new HashMap<String,Integer>();

			map.put("[蜀] 关云长", 90);
			map.put("[蜀] 诸葛孔明" ,38);
			map.put("[魏] 张文远" ,88);
			map.put("[魏] 夏侯妙才",80);
			map.put("[群] 吕奉先" ,100);
			map.put("[吴] 周公瑾" ,85);
			map.put("[吴] 鲁子敬" ,32);
			map.put("[魏] 郭奉孝" ,20);

		//请问我们总共收录了多少个英雄的信息? 
		System.out.println(map.size());





		//主键 -》 Set<主键类型> set = map.keySet();
		//值 -》 Collection<值类型> cs = map.values();
		//主键+值 -》 Set<Map.Entry<主键,值>> set = map.entrySet();


		//请问 总共有多少个英雄名字像鬼子?	 
		int count1 = 0;
		Set<String> set1 = map.keySet();
		for(String name : set1){
			if(name.length() > 7){
				count1++;
			}
		}
		System.out.println("有"+count1+"个鬼子");
		//请问 总共有多少个吴国的武将
		int count2 = 0;
		Set<String> set2 = map.keySet();
		for(String name : set2){
			if(name.contains("[蜀]")){
				count2++;
			}
		}
		System.out.println("有"+count2+"个蜀国的武将");
		//请问 所有英雄的平均武力值是多少	
		int sum = 0;
		Collection<Integer> cs = map.values();
		for(Integer power: cs){
			sum += power;
		}
		System.out.println("平均值："+sum / map.size());

		int s=0;
		Collection<Integer> cs1 = map.values();
				for(Integer power: cs){
					if(power>80){
						s++;
						}
		}
		System.out.println("大于80:"+ s);
	}
}