java学习之路 之 Java集合练习题

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

import org.junit.Test;

/**
 * 集合 : 解决批量的对象的存储问题, 优点:长度可变,灵活,不用考虑下标.  缺点:只能存对象
 * 数组 : 解决批量的数据的存储问题, 优点:可以存任意类型的数据. 缺点:内存连续,长度固定,需要处理复杂的下标
 * 
 * 分类 :
 * 		Collection接口 : 只能存放无序可重复的单个对象.
 * 			Set接口 : 只能存放无序不可重复单个对象
 * 				HashSet
 * 				TreeSet
 * 				LinkedHashSet
 * 
 * 			List接口 : 只能存放有序可重复单个对象, 和数组最像的
 * 				ArrayList 基于数组实现
 * 				Vector 基于数组实现 
 * 				LinkedList 基于链表实现		
 * 
 * 		Map接口 : 存放的是双对象.
 */
class Point {
	int x;
	int y;
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	@Override
	public String toString() {
		return "Point [x=" + x + ", y=" + y + "]";
	}
	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Point) {
			if (this.x == ((Point)obj).x && this.y == ((Point)obj).y) {
				return true;
			}
		}
		return false;
	}
	@Override
	public int hashCode() {
		return Integer.parseInt(x + "" + y);
	}
}

public class CollectionTest {
	
	@Test
	public void testIterator() {
		List<Integer> list = new LinkedList<Integer>();
		list.add(100);
		list.add(50);
		list.add(40);
		list.add(500);
		list.add(200);
		
		// 使用迭代器, 每次使用迭代器时必须获取新鲜的, 即时通过集合对象方法获取
		Iterator<Integer> it = list.iterator(); // 内部指针指向第一个元素前面
		//list.add(300); 集合内容一旦发生变化, 以上的迭代器就不可用的了.
		while (it.hasNext()) { // 如果内部指针的后面有元素,返回true
			Integer integer = it.next(); // 真的获取下一个对象, 并同时移动内部指针, 注意!!! 在循环中next方法只允许调用一次!!!!!!!
			System.out.println(integer);
		}
				
	}
	
	@Test
	public void testArrayList2() {
		// 1 创建一个List集合对象, 添加20个30以内的随机整数, 并打印输出
		List<Integer> list = new ArrayList<Integer>(); // 泛型 : 特别指定集合中只能存储某种类型的对象
		// 一旦使用泛型, 集合类型固定, 类型安全
		//list.add("abc");
		
		for (int i = 0; i < 20; i++) {
			list.add((int)(Math.random() * 30));
		}
		int sum = 0;
		for (Integer integer : list) { // 一旦使用了泛型, 集合中的元素肯定是某类型, 所以可以直接取出
			sum += integer;
		}
		System.out.println("sum:" + sum);
		
		for (Integer object : list) {
			System.out.println(object);
		}
	}
	@Test
	public void exer4() {
		// 声明一个Set集合,只能保存Double类型的数据, 保存10个随机100以内的数, 找出最大值和最小值,打印输出.
		Set<Double> set = new HashSet<Double>();
		for (int i = 0; i < 10; i++) {
			set.add(Math.random() * 100);
		}
		double maxValue = -Double.MAX_VALUE; // 先假定它最小
		for (Double double1 : set) {
			if (double1 > maxValue) {
				maxValue = double1;
			}
		}
		System.out.println(set);
		System.out.println("max:" + maxValue);
		
	}
	
	
	@Test
	public void testArrayList() {
		List list = new ArrayList(); // 有序可重复
		list.add(200);
		list.add(new Integer(200));
		list.add("abc");
		list.add("xxx");
		list.add("abc"); // 500, 200, 200, abc, xxx, abc
		list.add(0, 500); // 非末端插入
		list.set(0, 5000); // 替换
		System.out.println(list);
		list.remove(Integer.valueOf(200)); // 当成下标来用
		list.remove(list.size() - 1); 
		System.out.println(list);//[5000, 200, abc, xxx]
		Object object = list.get(2); // 获取下标为2的元素
		System.out.println(object);
		// List集合遍历
		System.out.println("-------------------------------------");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("-------------------------------------");
		for (Object obj : list) {
			System.out.println(obj);
		}
		
	}
	
	@Test
	public void exer3() {
		// 1 创建一个List集合对象, 添加20个30以内的随机整数, 并打印输出
		List list = new ArrayList();
		for (int i = 0; i < 20; i++) {
			list.add((int)(Math.random() * 30));
		}
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
	
	@Test
	public void exer32() {
		// 1 创建一个List集合对象, 添加20个30以内的随机整数, 并打印输出
		// 2 添加20个30以内的随机整数, 不允许重复.
		List list = new ArrayList();
		while (list.size() != 20) {
			int rand = (int)(Math.random() * 30);
			// 判断已经存在的元素中是否包含这个对象, 如果不包含才添加
			if (!list.contains(rand)) {
				list.add(rand);
			}
		}
		for (Object object : list) {
			System.out.println(object);
		}
	}
	
	
	// 写一个类Point, 坐标随机生成,5以内
	// 创建20个Point对象, 添加到Set集合中, 遍历打印输出
	@Test
	public void exer2() {
		Set set = new HashSet();
		
		set.add(new Point(10, 20)); // 元素重复的标准是 对象.equals(新元素)返回true, 并且hashCode()方法的返回值也一样
		set.add(new Point(10, 20));
		
		for (Object object : set) {
			System.out.println(object);
		}
	}
	
	@Test
	public void testHashSet() {
		Set set = new HashSet(); // 无序并内容不可重复
		boolean b1 = set.add(new Integer(200));
		System.out.println(b1);
		set.add(300);// set.add(Integer.valueOf(300));
		set.add("abc");
		set.add(new Point(10, 30));
		boolean b4 = set.add(200);// 再次添加相同的元素会失败!!
		System.out.println(b4);
		set.add("xxx");
		boolean b6 = set.add("abc"); // 再次添加相同的元素会失败!!
		System.out.println(b6);
		
		System.out.println("size:" + set.size()); // 获取容量
		System.out.println(set);
		
		set.remove("abc");
		set.remove(300);
		boolean b7 = set.remove(300);
		System.out.println(b7);
		System.out.println(set);
		System.out.println("------------------------------------");
		// 集合遍历, 把其中所有元素挨个访问, 增强型for
		/*
		for (元素类型 对象 : 集合) {
			System.out.println(对象);
		}*/
		for (Object object : set) {
			System.out.println(object);
		}
		
		
	}
	
	@Test
	public void exer13() {
		// 1 创建一个Set集合, 2 保存20个40以内的随机整数, 必须保证20个.
		Set set = new HashSet();
		for (int i = 0; i < 20; i++) {
			boolean b = set.add((int)(Math.random() * 40));
			if (!b) {
				i--;
			}
		}
		// 遍历
		for (Object obj : set) {
			System.out.println(obj);
		}
	}
	
	
	@Test
	public void exer12() {
		// 1 创建一个Set集合, 2 保存20个40以内的随机整数, 必须保证20个.
		Set set = new HashSet();
		while (set.size() != 20) {
			set.add((int)(Math.random() * 40));
		}
		System.out.println("size:" + set.size());
		// 遍历
		for (Object obj : set) {
			System.out.println(obj);
		}
	}
	
	@Test
	public void exer1() {
		// 1 创建一个Set集合, 保存20个40以内的随机整数, 遍历打印输出
		Set set = new HashSet();
		for (int i = 0; i < 20; i++) {
			set.add((int)(Math.random() * 40));
		}
		System.out.println("size:" + set.size());
		// 遍历
		for (Object obj : set) {
			System.out.println(obj);
		}
	}
}

package com.guigu.javae.collection;

import java.util.List;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

import com.atguigu.javase.home.Student;

public class CollectionTest {
	
	@Test
	public void test6() {
		List<Student> list = new ArrayList<Student>();
		for (int i = 0; i < 10; i++) {
			list.add(new Student(i + 1, 5, (int)(Math.random() * 101)));
		}
		System.out.println(list);
		
		Collections.sort(list); // 需要可比较
		System.out.println(list);
		
		Collections.reverse(list); //反转 不需要可比较
		System.out.println(list);
		
		Collections.shuffle(list); //不需要可比较
		System.out.println(list);
		
		System.out.println("max:" + Collections.max(list));// 需要可比较
		System.out.println("min:" + Collections.min(list));// 需要可比较
		
	}
	
	@Test
	public void test5() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add((int)(Math.random() * 20));
		}
		System.out.println(list);
		
		Collections.sort(list);
		System.out.println(list);
		
		Collections.reverse(list); //反转
		System.out.println(list);
		
		Collections.shuffle(list);
		System.out.println(list);
		
		
	}
	
	@Test
	public void test1() {
		Set<Integer> set1 = new TreeSet<Integer>(); // 无序(不按添加顺序), 内部使用了自然排序
		set1.add(100);
		set1.add(20);
		set1.add(0);
		set1.add(50);
		set1.add(10);
		set1.add(30);
		set1.add(40);
		
		for (Integer integer : set1) {
			System.out.println(integer);
		}
		
		System.out.println("---------------------------");
		
		Set<Student> set2 = new TreeSet<Student>(); // 添加的对象所属的类必须实现Comparable. 原因是要实现自然排序,必须对象可比
		// 去重不再依据equals和hashCode, 依据的是compareTo, 如果方法返回0,代表对象重复
		set2.add(new Student(3, 1, 100));
		set2.add(new Student(2, 2, 80));
		set2.add(new Student(1, 3, 30));
		set2.add(new Student(5, 4, 40));
		set2.add(new Student(2, 5, 50));
		
		for (Student student : set2) {
			System.out.println(student);
		}
	}
	
	@Test
	public void exer1() {
		Map<String, String> map = new HashMap<String, String>();
		String url = "q=iphone6s&commend=all&ssid=s5-e&search_type=item&sourceId=tb.index&ie=utf8&initiative_id=tbindexz_20160813&app=detailproduct&through=1";
		String[] parameters = url.split("&");
		for (int i = 0; i < parameters.length; i++) {
			//System.out.println(parameters[i]);
			String[] arr = parameters[i].split("=");
			map.put(arr[0],arr[1]);
		}
		// 遍历
		Set<String> keys = map.keySet();
		Iterator<String> iterator = keys.iterator();
		while (iterator.hasNext()) {
			String parmName = iterator.next();
			String parmValue = map.get(parmName);
			System.out.println(parmName + "------------" + parmValue);
		}
	}
	
	@Test
	public void test3() {
		Map<String, Student> map = new HashMap<String, Student>();
		//Student s1 = new Student(1, 1, 10);
		map.put("s1", new Student(1, 1, 10));
		map.put("s2", new Student(2, 2, 20));
		map.put("s3", new Student(3, 3, 30));
	}
	
	@Test
	public void test4() throws FileNotFoundException, IOException {
		Properties properties = new Properties();
		properties.load(new FileInputStream("config.properties")); // 自动处理文本文件,并其中的内容,其中的=左边的字符串作为了键,右边的字符串作为了值
		
		String host = properties.getProperty("host");
		int port = Integer.parseInt(properties.getProperty("port").trim());
		String abc = properties.getProperty("abc");
		System.out.println(host);
		System.out.println(port);
		System.out.println(abc);
	}
	
	@Test
	public void test2() {
		Set<Integer> set = new HashSet<Integer>();
		set.add(1);
		set.add(2);
		set.add(5);
		set.add(3);
		set.add(4);
		set.add(3);
		System.out.println(set);
	}
}
package com.guigu.javase.home;

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

import org.junit.Test;

public class HomeWork {
	
	@Test
	public void work1() {
		// 写一个Student类, 包含属性id[1-30), grade[1-6], score[0-100], 所有属性都是随机生成
		// 创建一个Set集合, 保存20个对象, 如果两个对象的id是一样的,则不允许添加.
		// 使用迭代器遍历集合,打印输出对象的信息, 并找出分数最高的同学和分数最低的同学, 最后打印输出最高分和最低分同学信息.
		Set<Student> set = new HashSet<Student>();
		for (; set.size() != 20;) {
			int id = (int)(Math.random() * 29 + 1);
			int grade = (int)(Math.random() * 6 + 1);
			double score = (int)(Math.random() * 1001) / 10.0;
			set.add(new Student(id, grade, score));
		}
		for (Student student : set) {
			System.out.println(student);
		}
		System.out.println("---------------------------");
		Student maxScoreStudent = null;
		Student minScoreStudent = null;
		Iterator<Student> iterator = set.iterator();
		while (iterator.hasNext()) {
			Student student = iterator.next();
			if (maxScoreStudent == null) {
				maxScoreStudent = student;
				minScoreStudent = student;
			}
			if (student.getScore() > maxScoreStudent.getScore()) {
				maxScoreStudent = student;
			} 
			if (student.getScore() < minScoreStudent.getScore()) {
				minScoreStudent = student;
			}
		}
		System.out.println(maxScoreStudent);
		System.out.println(minScoreStudent);
	}
}

class Student implements Comparable<Student> {
	
	private int id;
	private int grade;
	private double score;
	
	public Student() {
	}

	public Student(int id, int grade, double score) {
		super();
		this.id = id;
		this.grade = grade;
		this.score = score;
	}

	public int getId() {
		return id;
	}

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

	public int getGrade() {
		return grade;
	}

	public void setGrade(int grade) {
		this.grade = grade;
	}

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", grade=" + grade + ", score=" + score + "]";
	}
	
	/*
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		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 (id != other.id)
			return false;
		return true;
	}
	*/

	@Override
	public int compareTo(Student o) {
		return (int)(this.score - o.score);
	}	
}
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


import org.junit.Test;


public class MapTest {

	@Test
	public void test1() {
		Map<Integer, String> map = new HashMap<Integer, String>(); //空词典
		map.put(5, "five"); // 写入词条
		map.put(2, "two");
		map.put(0, "zero");
		map.put(4, "four");
		map.put(2, "TWO"); // 如果出现键相同的情况, 键对应的老的值就会被覆盖

		System.out.println(map.size());

		String value = map.get(4); // 根据键,获取值, 查词典
		System.out.println(value);

		map.remove(0); // 把0和"zero"同时删除

		// 遍历Map集合,先遍历它的所有键
		Set<Integer> set = map.keySet(); // 获取map中的所有键的一个Set集合
		Iterator<Integer> it = set.iterator();
		while (it.hasNext()) {
			Integer key = it.next();
			String valueString = map.get(key);
			System.out.println(key + "-----------------" + valueString);
		}

	}
}