Java集合

1.List

List 是一个接口，不能直接创建对象，需要实现类，eg:ArrayList

eg：

package edu.sdut.cn;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

import javax.activation.CommandInfo;

public class Test9 {
	public static void main(String[] args) {
		
		Scanner sc= new Scanner(System.in) ; 
		// 创建一个List集合，List集合的特点是有序，可重复
		// List 是泛型接口
		// <>里面不能填基本数据类型，只能填对象和类
		// 默认是Object
		List<Integer> list = new ArrayList<>();
		for (int i = 0; i < 4; i++) {
			int x = sc.nextInt() ;  
			list.add(x)   ; 
		}
		
		//输入的数值无序，线对其进行排序，这里需要用到一个Collections类
		//不是Collection,因为后者是接口
		//Collections.sort(list);//默认从小到大排序
		//从大到小排序
		Collections.sort(list,new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return o2-o1; 
			}
		});
		
		//list集合的4种输出方式
		//1.直接输出
		System.out.println(list);
		System.out.println("--------------");
		//2.foreach 输出
		for(Integer a :list)
		{
			System.out.println(a);
		}
		System.out.println("--------------");
		//3.迭代器输出
		Iterator<Integer> it = list.iterator();
		while(it.hasNext())
		{
			Integer a = it.next() ; 
			System.out.println(a);
		}
		System.out.println("--------------");
		//4.下标输入
		for(int i=0 ; i<list.size() ; i++)//size()方法是获取长度，不要和数组的length() 方法所混淆
		{
			System.out.println(list.get(i));
		}
		//其他的一些操作
		System.out.println(list.indexOf(1));//返回集合第一次出现这个元素的位置
		System.out.println(list.isEmpty());//判断集合是不是为空
		list.add(1,2); 	//在指定位置上添加元素
		//详见JDK
	}

}

例题

集合相等问题

Time Limit: 1000 ms Memory Limit: 65536 KiB

Submit Statistic

Problem Description

给定2 个集合S和T，试设计一个判定S和T是否相等的蒙特卡罗算法。
设计一个拉斯维加斯算法，对于给定的集合S和T，判定其是否相等。

Input

输入数据的第一行有1 个正整数n（n≤10000），表示集合的大小。接下来的2行，每行有n个正整数，分别表示集合S和T中的元素。

Output

将计算结论输出。集合S和T相等则输出YES，否则输出NO。

Sample Input

3
2 3 7
7 2 3

Sample Output

YES

Hint

Source

 

代码：

package edu.sdut.cn;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc =new Scanner(System.in) ; 
		int  t = sc.nextInt() ; 
		List list = new ArrayList<>() ; 
		List list1 = new ArrayList<>() ; 
		for(int i =1 ; i<= t ;i++)
		{
			int x = sc.nextInt() ; 
			list.add(x) ; 
		}
		for(int i =1 ;i<= t ; i++)
		{
			int x  = sc.nextInt() ; 
			list1.add(x) ; 
		}
		//先对两个集合进行排序
		Collections.sort(list);
		Collections.sort(list1); 
		
		
		//调用equals方法来判断是否相等,下面这种方法是错误的因为equals是判断两个对象是不是相等，一般来说是比较两个对象的hash值和地址
		//但如果对对象进行了重写，那就比较重写后的两个字符串
		if(list.equals(list1))
		{
			System.out.println("YES");
		}
		else System.out.println("NO");
	}
}

例题2

C~K要找女朋友了！！！

Time Limit: 1000 ms Memory Limit: 131072 KiB

Submit Statistic

Problem Description

临近11.11，C~K看见周围的朋友一个个的都脱单或者正准备脱单了，C~K也想要找一个女朋友了（听说国家会分配？）。MeiK听说了这件事情，表
示C~K终于开悟了，所以他整理了一份候选人名单给C~K。可是C~K心里有自己心动女生的身高区间和年龄限制，所以他想把符合条件的女生
的信息(即符合[身高最小值，身高最大值]闭区间和[年龄最小值，年龄最大值] 闭区间的女生都算符合条件)给筛选出来，但是这可是难住了C~K，事关C~K的幸福，你能帮帮他吗？
ps:由于MeiK比较傻，所以名单里可能会有重复的女生的信息，若信息重复，则第一次输入为有效信息。

Input

第一行输入MeiK的候选人名单里有N个人(N<100000)。
第二行输入四个整数a,b,c,d。分别表示C~K心动女生的身高的最小值和最大值，年龄的最小值和最大值。（题目保证a<=b,c<=d）
接下来输入N行，每行表示一个女生的信息（姓名，身高，年龄，联系方式）

ps：联系方式不超过11个字符。

Output

第一行输出一个n，表示符合条件的女生的数量。
接下来的n行，每一行输出一个符合条件的女生的信息。
输出顺序按身高从低到高排序，若身高相同，则按年龄从高到底排序，若年龄也相同，则按照输入顺序输出。

Sample Input

4
160 170 20 22
女神1 161 19 11111
女神2 167 20 22222
女神2 167 20 22222
女神3 163 21 33333

Sample Output

2
女神3 163 21 33333
女神2 167 20 22222

Hint

Source

C~K

 

代码：

package edu.sdut.cn;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

//首先先创建一个女生类
class GStudent {
	private String name;
	private int hight;
	private int age;
	private String tel;

	public GStudent(String name, int hight, int age, String tel) {
		super();
		this.name = name;
		this.hight = hight;
		this.age = age;
		this.tel = tel;
	}

	public String getName() {
		return name;
	}

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

	public int getHight() {
		return hight;
	}

	public void setHight(int hight) {
		this.hight = hight;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getTel() {
		return tel;
	}

	public void setTel(String tel) {
		this.tel = tel;
	}
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + hight;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + ((tel == null) ? 0 : tel.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;
		GStudent other = (GStudent) obj;
		if (age != other.age)
			return false;
		if (hight != other.hight)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (tel == null) {
			if (other.tel != null)
				return false;
		} else if (!tel.equals(other.tel))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return name + " " + hight + " " + age + " " + tel;
	}

}

public class Test10 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int lhight, hhight;
		int lage, hage;
		int n;
		List<GStudent> list = new ArrayList<>();
		n = sc.nextInt();
		lhight = sc.nextInt();
		hhight = sc.nextInt();
		lage = sc.nextInt();
		hage = sc.nextInt();
		while (n-- > 0) {
			String name = sc.next();
			int hight = sc.nextInt();
			int age = sc.nextInt();
			String tel = sc.next();
			if (hight >= lhight && hight <= hhight && age >= lage && age <= hage) {
				GStudent g = new GStudent(name, hight, age, tel);
				if (!list.contains(g))// 如果不对GStudent类做任何处理的话，这里是判断这个对象是否在这个列表里面。显示结果就会出错
				{                        // 所以我们要对这个类进行处理是其变成不是比较对象而是比较他们的内容，使用hashcode和equals方法来实现这个功能
					list.add(g);
				}
			}
		}
		// 按照题目要求对列表进行排序
		Collections.sort(list, new Comparator<GStudent>() {

			@Override
			public int compare(GStudent o1, GStudent o2) {
				int l = o1.getHight() - o2.getHight();
				if (l != 0) {
					return l;
				} else {
					return o2.getAge() - o1.getAge();
				}
			}
		});
		// 输入结果
		System.out.println(list.size());
		for (GStudent s : list) {
			System.out.println(s);
		}

	}
}

2.Set接口

Set也是一个接口，需要实现类才能实现其功能，eg：HashSet

Set接口和List接口有许多类似的地方，但Set接口有一个不同于List的特点是无序的，不存在重复元素的。

package edu.sdut.cn;

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

public class Test11 {
	
	public static void main(String[] args) {
		
		//这里我们一HashSet实现类来做例子
		
		Set set = new HashSet() ; 
		
		//Set接口的一些操作和List接口的操作几乎没有什么不一样的
		//Set接口只是去除List接口中和下标有关的操作，如get（）操作等，因为Set集合是无序的
		set.add(1) ; 
		set.add(1) ; 
		set.add("afj") ; 
		set.add(true) ; 
		//Set集合的三种输出方式
		//1.直接输出
		System.out.println(set);
		
		System.out.println("------");
		//2.foreach语句
		for(Object o :set)//如果set集合没有写是什么类型的泛型的话，默认是Object类型的
		{
			System.out.println(o);
		}
		System.out.println("------");
		//3.迭代器输出
		Iterator it = set.iterator() ;
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
		
	}
	
}

例子：

题目要求同List例题2 

代码如下：

package edu.sdut.cn;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

class GStudent1 {
	private String name;
	private int hight;
	private int age;
	private String tel;

	public GStudent1(String name, int hight, int age, String tel) {
		super();
		this.name = name;
		this.hight = hight;
		this.age = age;
		this.tel = tel;
	}

	public String getName() {
		return name;
	}

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

	public int getHight() {
		return hight;
	}

	public void setHight(int hight) {
		this.hight = hight;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getTel() {
		return tel;
	}

	public void setTel(String tel) {
		this.tel = tel;
	}
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + hight;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + ((tel == null) ? 0 : tel.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;
		GStudent1 other = (GStudent1) obj;
		if (age != other.age)
			return false;
		if (hight != other.hight)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (tel == null) {
			if (other.tel != null)
				return false;
		} else if (!tel.equals(other.tel))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return name + " " + hight + " " + age + " " + tel;
	}

}

public class Test12{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int lhight, hhight;
		int lage, hage;
		int n;
		Set<GStudent1> set = new HashSet<GStudent1>() ; 
		n = sc.nextInt();
		lhight = sc.nextInt();
		hhight = sc.nextInt();
		lage = sc.nextInt();
		hage = sc.nextInt();
		while (n-- > 0) {
			String name = sc.next();
			int hight = sc.nextInt();
			int age = sc.nextInt();
			String tel = sc.next();
			if (hight >= lhight && hight <= hhight && age >= lage && age <= hage) {
				GStudent1 g = new GStudent1(name, hight, age, tel);
				set.add(g)  ; //这里如果没有对hashcode和equals方法进行重写的话，这道题的输出还是错误的
								//因为set集合不含有重复元素实际上也是调用hashCode方法和equals方法，自带的类型和类
								//都重写好了这个两个方法，但自己写的类还要再次重写这两个方法。
			}
		}
	
		List<GStudent1> list = new ArrayList<GStudent1>(set);
		

		Collections.sort(list, new Comparator<GStudent1>() {

			@Override
			public int compare(GStudent1 o1, GStudent1 o2) {
				int l = o1.getHight() - o2.getHight();
				if (l != 0) {
					return l;
				} else {
					return o2.getAge() - o1.getAge();
				}
			}
		});

		System.out.println(list.size());
		for (GStudent1 s : list) {
			System.out.println(s);
		}

	}
}

3.Map接口

map接口是一种双列集合，它的每一个元素都包括一对键值对（Key——Values）,其中Key相当于一个Set集合，键值对之间存在着一一对应的关系，我们把这种关系称为映射。下面以Map接口的HashMap实现类为例。

 

package edu.sdut.cn;

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;

public class Test13 {
	public static void main(String[] args) {
		
		Map<Integer,Object> map = new HashMap<Integer,Object>() ;//指定的关系是从数字到Object类的映射关系
		
		//向其中加入元素
		map.put(1, 2) ; 
		map.put(1, 3) ; //如果key集合中出现重复元素第二次会把第一次覆盖
		map.put(3, true) ; 
		map.put(2, new Object()) ;
		map.put(4, "out") ; 
		map.put(5, 4) ; 
		//map集合的一些方法
		System.out.println(map.containsKey(1)) ;//判断map中是否含有1这个key值
		System.out.println(map.containsValue("akfh"));//判断map中是否含有这个values值
		map.remove(5) ; //删除key 为5  的这个键值对
		map.replace(4, 3) ; //替换key = 4 的value值 = 3 
		
		//map集合的遍历方法
		//1.直接输出map集合
		System.out.println(map);
		System.out.println("-----");
		//2.通过set集合来进行输出
		Set<Integer> set = map.keySet() ;
		//为了把map集合输出可以用迭代器和foreach语句
		//foreach语句
		for(Integer a:set)
		{
			System.out.println(a+"="+map.get(a));
		}
		System.out.println("-----");
		//迭代器法
		
		Iterator<Integer> it = set.iterator();
		while(it.hasNext())
		{
			Integer a = it.next() ; 
			System.out.println(a+"="+map.get(a));
		}
		System.out.println("-----");
		//通过键值对来进行遍历
		Set<Entry<Integer,Object>> entrySet = map.entrySet();
		Iterator<Entry<Integer, Object>> it1 = entrySet.iterator() ; 
		while(it1.hasNext())
		{
			System.out.println(it1.next());
		}
		//也可以通过map的Foreach方法来遍历
		map.forEach((key,value)->System.out.println(key+"="+value));
		//当然也可以得到一个有关于value值的集合
		Collection<Object> values = map.values() ;
		System.out.println(values);
		map.clear(); //清空map集合
		
		
	}
}

代码如下：

package edu.sdut.cn;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

//创建一个学生类
class Student{
	private String id ; 
	private String name ; 
	private String brithday ; 
	private double score ;

	public Student(String id, String name, String brithday, double score) {
		super();
		this.id = id;
		this.name = name;
		this.brithday = brithday;
		this.score = score;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public String getBrithday() {
		return brithday;
	}

	public void setBrithday(String brithday) {
		this.brithday = brithday;
	}

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}
	
	
	//为了达到题目要求的输出，对toString方法进行重写
	@Override
	public String toString() {
		//需要注意，输出前和输出后的时间格式是不一样的，需要进行时间格式的转化
		ChangeTime(); 
		return "id:"+id+"\tname:"+name+"\tbirthday:"+brithday+"\tscore:"+score ; 
	}
	public void ChangeTime()
	{
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ; 
		try {
			Date date = sdf.parse(brithday) ;
			SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy_M_d") ;
			brithday = sdf1.format(date) ;
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

public class Test14 {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in) ;
		Map<String,Student> map = new  HashMap() ;
		int n = sc.nextInt() ; 
		//读入数据
		while(n-->0)
		{
			String id = sc.next() ; 
			String name = sc.next() ; 
			String birtday = sc.next() ; 
			double score = sc.nextDouble() ; 
			Student student = new Student(id,name,birtday,score) ; 
			map.put(id,student) ; 
		}
		//对关键字进行排序
		Set<String> set = map.keySet() ;
		List<String> list = new ArrayList<>(set) ; 
		//进行从小到大排序
		Collections.sort(list) ;
		//最后将结果输出
		for(String a : list)
		{
			Student s = map.get(a) ;
			System.out.println(s);
		}
	}
	
}