集合的应用(练习:学生档案)

package com.ljk.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
//import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;

//import com.hanqi.test.Student;
import com.ljk.test.Student;
import com.ljk.test.Major;

public class DataSourceModel {
	public static List<Student> _list () {
		
		List<Student> list = new ArrayList<Student>();
		
		Student s = new Student("小明" , 10);
		Student s1 = new Student("小红" , 12);
		Student s2 = new Student("小刚" , 14);
		Student s3 = new Student("小亮" , 16);
		Student s4 = new Student("小白" , 18);
		Student s5 = new Student("小绿" , 29);
		Student s6 = new Student("小蓝" , 21);
		Student s7 = new Student("小紫" , 4);
		Student s8 = new Student("小绿" , 29);
		
		list.add(s);
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		list.add(s5);
		list.add(s6);
		list.add(s7);
		list.add(s8);
		
		return list;
	}
	
	public static Set<Student> _set () {
		// 自动去重 , 需要重写equals
		Set<Student> set = new HashSet<Student>(_list());
		
		return set;
	}

	public static Map<Integer , Student> _map () {
		
		Map<Integer , Student> map = new HashMap<Integer , Student> ();
		
		List<Student> list = _list();
		
		int count = 1001;
		// 给学生学号;
		for (Student s : list) {
			map.put(count ++, s);
		}
		
		return map;
	}
	
	public static List<Student> quanb() {
		
		Major m1 = new Major("语文");
		Major m2 = new Major("数学");
		Major m3 = new Major("英语");
		Major m4 = new Major("地理");
		Major m5 = new Major("政治");
		List<Major> z = new ArrayList<Major>();
		List<Student> list1 = _list();
		z.add(m1);
		z.add(m2);
		z.add(m3);
		z.add(m4);
		z.add(m5);
		
		/*for (Student s : list) {
			Major m = z.get(0);
			s.getSet().add(m);
		}*/
		
		Random r = new Random();
		for (Student s : list1) {
			for (int i = 0; i < 2; i++) {
				int index = r.nextInt(z.size());//随机数取值范围
				Major m = z.get(index);
				s.getSet().add(m);
			}
		}
		
		
		Map<Integer, Student> map = _map();
		Set<Integer> set1 = map.keySet(); 
		int count = 0;
		for (Integer i : set1) {
			map.put( i , list1.get(count ++ ));
		}
		
		
		Iterator<Integer> ite = map.keySet().iterator(); 
		while (ite.hasNext()) {
			Integer in = ite.next();
			System.out.println("学号 : " + in + map.get(in));
		}
		
		return list1;
	}
	
	
	
	
	//分组开始
	public void fenzu (int i) {
		List<Student> L = _list();
		List<Student> a_list = new ArrayList<Student>();
		List<Student> b_list = new ArrayList<Student>();
		
		System.out.println("总人数 : " + L.size());
		if (L.size() % i == 0) {
			int i1 = L.size() / i;  // 每组人数;
			for (int j = 0; j < L.size(); j++) {
				if (j < i1) {
					a_list.add(L.get(j));
					
				}else {
					b_list.add(L.get(j));
				}
			}
		} else {
			int i2 = (L.size() + 1) / 2;  // 每组人数;
			for (int j = 0; j < L.size(); j++) {
				if (j < i2) {
					a_list.add(L.get(j));
				}else {
					b_list.add(L.get(j));
				}
			}
		}
		
		System.out.println("第一组");
		for (Student s : a_list) {
			System.out.println(s);
		}
		System.out.println("=============================");
		System.out.println("第二组");
		for (Student s : b_list) {
			System.out.println(s);
		}
	
}

 

package com.ljk.test;

public class Major {
	
	private String m; // 专业名字
	
	public Major() {
		super();
	}
	public Major(String m) {
		super();
		this.m = m;
	}

	

	public String getM() {
		return m;
	}

	public void setM(String m) {
		this.m = m;
	}
	
	@Override
	public String toString() {
		return "学科" + m;
	}
}

 

package com.ljk.test;

import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/*问题
 * 
 * 在分组时 ,组数为变量时分组;
 * 
 *  
 * */

public class Practise {
	public static void main(String[] args) {
		//获取到DataSourceModel类里的_list;
		List<Student> list = DataSourceModel._list();
		
		list.add(new Student("paulo" , 29)); // 添加一个学生
		
		// 删除小明开始
		Student student =null;
		for (Student s : list) {
			if (s.getName().equals("小明") ) {
				//list.remove(s); 无法删除  报错;
				//Student st = s;
				student = s;
			}
		}
		list.remove(student);
		// 删除小明结束
		
		Collections.sort(list); 
		//从小到大排
		// 按年龄排序 ;  需要在Student类里继承Comparable 并重写 compareTo
		Collections.reverse(list);
		// 从大到小排; (要先写Collections.sort(list); )
		
		chongfu(list);  // 去重方法;   
		
		//遍历 list 输出所有学生信息 开始;
		for (Student s : list) {
			System.out.println(s);
			System.out.println("=================");
		}
		//遍历 list 输出所有学生信息 结束;
		
		DataSourceModel d = new DataSourceModel();
		
		d.fenzu(2);  //分组 未实现功能   只能传入2 , 分2组;
		
		
		//找人开始
		//.startsWith(); 主要使用方法;
		System.out.println("==============================");
		System.out.println("找到p开头的学生");
		for (Student s2 : list) {
			if(s2.getName().startsWith("p")) {
				System.out.println(s2);
				//break;
			}
		}
		//找人结束
		System.out.println("==============================");
		
		// 找年龄开始
		System.out.println("年龄大于29的");
		for (Student s3 : list) {
			if(s3.getAge() >= 29) {
				System.out.println(s3);
			}
		}
		//找年龄结束
		
		
		System.out.println("=================================");
		Set<Student> set = DataSourceModel._set();
		for (Student s4 : set) {
			System.out.println(s4);
		}
		
		System.out.println("=================================");
		System.out.println("把第二个小绿改成小黑");
		//获取_map方法的返回值;
		Map<Integer , Student> map = DataSourceModel._map(); 
		Set<Integer> set1 = map.keySet(); // 获取键
		int index = 0;
		for (Integer i : set1) {
			if (map.get(i).getName().equals("小绿")) {
				index ++;
				if (index == 2) {
					map.get(i).setName("小黑(原名小绿)");
				}
			}
			if (i == 1007) {
				index = i;
			}
			System.out.println("学号 : " + i + map.get(i));
		}
		
		System.out.println("============================");
		// 删除学生1007 , 使用remove的返回值;
		System.out.println("注销学生 : " + index + map.remove(1007));
		
		
		System.out.println("============================");
		// 迭代
		Iterator<Integer> ite = map.keySet().iterator(); 
		//ite.hasNext() 检查是否有下一个有返回true ; 没有返回 false;
		while (ite.hasNext()) {
			Integer in = ite.next();  // 获取 key 值;
			if (in >=1004 && in<= 1007) {
				if (in == 1005) {
					//map.remove(1005);  运行报错  
					//ite.remove(1005);   迭代删除不加参数
					ite.remove();
				}else {
					System.out.println("学号" + in + map.get(in));
				}
			}
		}
		
		System.out.println("============================");
		System.out.println("所有信息 : ");
		DataSourceModel.quanb(); 
		
		
		
		
		
	}
	
	//去重
	public static void chongfu (List<Student> list) {
		
		for (int i = 0; i < list.size(); i++) {
			for (int j = 0; j < list.size() ; j++) {
				if (list.get(i).getName().equals(list.get(j).getName()) && 
						list.get(i).getAge().equals(list.get(j).getAge()) && 
						i !=j) {
					//DataSourceModel._list().remove(i);
					list.remove(i);
				}
			}
		}
	}
	
	

 

package com.ljk.test;

import java.util.HashSet;
import java.util.Set;

public class Student implements Comparable<Student> {
	private String name ;
	private Integer age ;
	//public Major major;
	// 有一个成员属性 , 属性是一个只能放Major类的set集合;
	private Set<Major> set = new HashSet<Major>();
	public Student() {
		super();
	}
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	
	// get set 开始
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}
	
	public Set<Major> getSet() {
		return set;
	}

	public void setSet(Set<Major> set) {
		this.set = set;
	}
	// get set 结束
	
	
	
	// toString
	@Override
	public String toString() {
		return "名字 : " + name + "|| 年龄 : " + age  + "||" + set;
	}


	//重写方法 排序使用;
	@Override
	public int compareTo(Student o) {
		return this.age.compareTo(o.age);
	}
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((age == null) ? 0 : age.hashCode());
		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 == null) {
			if (other.age != null)
				return false;
		} else if (!age.equals(other.age))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	
	
}