集合的练习

ArrayDeque 类
  特点: 
	1.基于数组的双端队列的实现
	2.增加删除的效率低,查询和修改的效率高
		  
LinkedList
  特点：
	1.底层是基于链表的双端队列
	2.增加删除的效率高,查询和修改的效率低
	3.同时也实现了List接口
		   
使用LinkedList模拟栈结构和队列结构

package com.sxt.listsondemo;

import java.util.ArrayDeque;
import java.util.LinkedList;

public class ArrayDequeLinkedListDemo {
	public static void main(String[] args) {
		ArrayDeque ad = new ArrayDeque();
		
		LinkedList ll = new LinkedList();
	}
}

————————————————————————————
随机生成球队

package com.sxt;

import java.util.ArrayList;
import java.awt.List;

/*	科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，
		尼日利亚、日本，美国，中国，新西 兰，巴西，
		比利时，韩国，喀麦隆，洪都拉斯，意大利	*/
public class ListWork01 {
	public static void main(String[] args) {
		String[] arr ={"科特迪瓦", "阿根廷", "澳大利亚", "塞尔维亚", "荷兰", "尼日利亚", "日本",
				"美国", "中国", "新西兰", "巴西", "比利时", "韩国", "喀麦隆", "洪都拉斯", "意大利"}; 
		
		ArrayList list = arrToList(arr);
		System.out.println(list);
		
		for (int i = 1; i <= 4; i++) {
			System.out.println();
			System.out.println("第" + i + "组");
			for (int j = 0; j < 4; j++) {
				int randomNum = getRandomNum(0, list.size()-1);
				System.out.print(list.get(randomNum) + " ");
				list.remove(randomNum);
				
			}
		}
	}
	private static ArrayList arrToList(String[] arr) {
		ArrayList list = new ArrayList();
		for (String s : arr) {
			list.add(s);
		}
		return list;
	}
	
	public static int getRandomNum(int start, int end) {
		return (int)(Math.random()*(end - start + 1) + start);
	}
}

————————————————————————————

 三．有如下Student对象，
	private String name;  
	private int age;  
	private int score;  
	private String classNum; 
	其中，classNum 表示学生的班号，例如“class05”。 
	有如下List List list = new ArrayList();
	list.add(new Student(“Tom”, 18, 100, “class05”)); 
	list.add(new Student(“Jerry”, 22, 70, “class04”));
	list.add(new Student(“Owen”, 25, 90, “class05”)); 
	list.add(new Student(“Jim”, 30,80 , “class05”)); 
	list.add(new Student(“Steve”, 28, 66, “class06”));
	list.add(new Student(“Kevin”, 24, 100, “class04”));
	在这个list 的基础上，完成下列要求： 
	1） 计算所有学生的平均年龄
	2） 计算各个班级的平均分 

package com.sxt.practice;

import java.util.ArrayList;
import java.util.List;


public class Practice02 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new Student("Tom", 18, 100.0, "class05"));
		list.add(new Student("Jerry", 22, 70.0, "class04"));
		list.add(new Student("Owen", 25, 90.0, "class05"));
		list.add(new Student("Jim", 30, 80.0, "class05"));
		list.add(new Student("Steve", 28, 66.0, "class06"));
		list.add(new Student("Kevin", 24, 100.0, "class04"));
		
		int sumAge = 0;
		double sum04 = 0.0; 
		double sum05 = 0.0; 
		double sum06 = 0.0; 
		
		int count04 = 0;
		int count05 = 0;
		int count06 = 0;
		// 判断每个班级再来求平均分
		for (Object object : list) {
			if (object instanceof Student) {
				Student s = (Student) object;
				Integer age = s.getAge();
				sumAge += age;
				String classNum = s.getClassNum();
				if (classNum.equals("class04")) {
					sum04 += s.getScore();
					count04++;
				} else if (classNum.equals("class05")) {
					sum05 += s.getScore();
					count05++;
				} else if (classNum.equals("class06")) {
					sum06 += s.getScore();
					count06++;
				}
			}
		}
		
		System.out.println("所有学生的平均年龄是: " + sumAge / list.size());
		System.out.println("class04的平均分是: " + sum04/count04);
		System.out.println("class05的平均分是: " + sum05/count05);
		System.out.println("class06的平均分是: " + sum06/count06);
		
	}
}

class Student {
	private String name;
	private Integer age;
	private Double score;
	private String classNum;
	public Student() {
		super();
	}
	public Student(String name, Integer age, Double score, String classNum) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
		this.classNum = classNum;
	}
	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 Double getScore() {
		return score;
	}
	public void setScore(Double score) {
		this.score = score;
	}
	public String getClassNum() {
		return classNum;
	}
	public void setClassNum(String classNum) {
		this.classNum = classNum;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", score=" + score + ", classNum=" + classNum + ", getName()="
				+ getName() + ", getAge()=" + getAge() + ", getScore()=" + getScore() + ", getClassNum()="
				+ getClassNum() + ", getClass()=" + getClass() + ", hashCode()=" + hashCode() + ", toString()="
				+ super.toString() + "]";
	}
	
}

————————————————————————————

四．（List）已知有一个Worker 类如下： 
	public class Worker
	 { private int age; 
	private String name; 
	private double salary; 
	public Worker (){} 
	public Worker (String name, int age, double salary)
	{ this.name = name; 
	this.age = age; 
	this.salary = salary; } 
	public int getAge() { return age; } 
	public void setAge(int age) { this.age = age; } 
	public String getName() { return name; } 
	public void setName(String name) { this.name = name; } 
	public double getSalary(){ return salary; } 
	public void setSalary(double salary){ this.salary = salary; } 
	public void work(){ 
	System.out.println(name + “ work”); } } 
	完成下面的要求 
	1) 创建一个List，在List 中增加三个工人，基本信息如下：
	姓名 年龄 工资 
	zhang3 18 3000 
	li4    25 3500 
	wang5  22 3200 
	2) 在li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，
	工资3300 
	3) 删除wang5 的信息 
	4) 利用for 循环遍历，打印List 中所有工人的信息 
	5) 利用迭代遍历，对List中所有的工人调用work方法。
	使用 至少六种方式遍历 集合
	6) 存储重复元素并且去除 (使用两种方式)
 

package com.sxt.practice;

import java.util.ArrayList;
import java.util.List;

public class Practice03 {
	public static void main(String[] args) {
		List list = new ArrayList();
		// 1) 创建一个List，在List 中增加三个工人
		list.add(new Worker("zhang3", 18, 3000.0));
		list.add(new Worker("li4", 25, 3500.0));
		list.add(new Worker("wang5", 22, 3200.0));
		System.out.println(list);
		// 2) 在li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资3300
		list.add(1, new Worker("zhao6", 24, 3300.0));
		System.out.println(list);

		// 通过名字找出Worker对象,删除之
		// for (Object object : list) {
		// if (object instanceof Worker) {
		// Worker w = (Worker) object;
		// String name = w.getName();
		// if (name.equals("wang5")) {
		// list.remove(object);
		// }
		// }
		// }

		for (int i = 0; i < list.size(); i++) {
			Object object = list.get(i);
			if (object instanceof Worker) {
				Worker w = (Worker) object;
				String name = w.getName();
				if (name.equals("wang5")) {
					list.remove(object);
				}
			}
		}
		System.out.println(list);

		// 5) 利用迭代遍历，对List中所有的工人调用work方法。
		for (Object object : list) {
			if (object instanceof Worker) {
				Worker w = (Worker) object;
				w.work();
			}
		}
		
		// 6) 存储重复元素并且去除 (使用两种方式)
		list.add(new Worker("li4", 25, 3500.0));
		
		for (int i = 0; i < list.size() - 1; i++) {
			for (int j = i+1; j < list.size(); j++) {
				if (list.get(i).equals(list.get(j))) {
					list.remove(j);
					j--;
				}
			}
		}
		System.out.println(list);
		
	}
}

class Worker {
	private String name;
	private Integer age;
	private Double salary;

	public Worker() {
		super();
	}

	public Worker(String name, Integer age, Double salary) {
		super();
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	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 Double getSalary() {
		return salary;
	}

	public void setSalary(Double salary) {
		this.salary = salary;
	}

	@Override
	public String toString() {
		return "Worker [name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}

	public void work() {
		System.out.println(name + "work");
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Worker other = (Worker) 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;
		if (salary == null) {
			if (other.salary != null)
				return false;
		} else if (!salary.equals(other.salary))
			return false;
		return true;
	}
	
}

————————————————————————————

  五．自己封装一个MyStack 类,底层利用LinkedList实现,表示“栈”
  这种数据结构。
	栈在表示上，就如同一个单向开口的盒子，每当有新数据进入时，
	都是进入栈顶。其基 本操作为push 和pop。
	push 表示把一个元素加入栈顶，pop 表示把栈顶元素弹出。
	栈的特点：先进后出。
	封装的MyStack必须具备如下方法：
	1） push(Object o)：表示把元素放入栈
	2） Object pop()：返回栈顶元素，并把该元素从栈中删除。
	如果栈为空，则返回 null 值
	3） Object peek()：返回栈顶元素，但不把该元素删除。
	如果栈为空，则返回null值。
	4） boolean isEmpty()：判断该栈是否为空
	5） int size()：返回该栈中元素的数量
	要求:
	6) 编写测试类测试使用MyStack存储元素和遍历元素

package com.sxt.practice;

import java.util.AbstractCollection;
import java.util.EmptyStackException;
import java.util.Iterator;
import java.util.LinkedList;

public class Practice04 {
	public static void main(String[] args) {
		MyStack ms = new MyStack();
		ms.push("A");
		ms.push("B");
		ms.push("C");
		
//		System.out.println(ms.pop());
//		System.out.println(ms.pop());
//		System.out.println(ms.pop());
//		System.out.println(ms.pop());
		
//		while (!ms.isEmpty()) {
//			System.out.println(ms.pop());
//		}
		
		System.out.println(ms.toString());
		System.out.println(ms.peek());
		ms.pop();
		System.out.println(ms.peek());
		
	}
}

class MyStack extends AbstractCollection {
	private LinkedList list;

	public MyStack() {
		list = new LinkedList();
	}
	
	public Object push(Object item) {
		list.addFirst(item);
		return item;
    }
	
	public Object pop() {
		Object obj = null;
		try {
			obj = list.removeFirst();
		} catch (Exception e) {
			throw new EmptyStackException();
		}
        return obj;
    }
	
	public Object peek() {
        if (isEmpty())
            throw new EmptyStackException();
        return list.peekFirst();
    }
	
	public boolean isEmpty() {
		return list.isEmpty();
	}
	
	public int size() {
		return list.size();
	}
	
	@Override
	public Iterator iterator() {
		return list.iterator();
	}
}