千锋逆战班学习第二十三天 集合练习（一）

千锋逆战班
在千锋"逆战”学习第23天,
每个人生阶段都需要努力去扮好自己的角色,越努力越轻松,越坚强越幸运!
加油!

2（List）有如下代码

import java.util.*; 
public class TestList{ 
public static void main(String args[]){ 
List list = new ArrayList(); 
list.add(“Hello”); 
list.add(“World”); 
list.add(1, “Learn”); 
list.add(1, “Java”); 
printList(list); 
} 
public static void printList(List list){ 
//1 
} 
} 
要求：
1) 把//1 处的代码补充完整，要求输出 list 中所有元素的内容
2) 写出程序执行的结果
3) 如果要把实现类由 ArrayList 换为 LinkedList，应该改哪里？ArrayList 
和 LinkedList 使用上有什么区别？实现上有什么区别？
4) 如果要把实现类由 ArrayList 换为 Vector，应该改哪里？ArrayList 和
Vector 使用上有什么区别？实现上有什么区别？

public class TestList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//List<String> list=new ArrayList<String>();
		//List list=new ArrayList();
		List list=new ArrayList();
		list.add("Hello");
		list.add("World");
		list.add(1,"Lean");
		list.add(1, "java");
		printList(list);
	}
	public static void printList(List list) {
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
	}
}
Hello
java
Lean
World
3. 题
    List list=new LinkedList();     
    ArrayList
        1. 基于数组
        2. 默认容量为10，每次扩容上一次的一半；内存空间连续
        3. 增删元素较慢--移动元素
        4. 查询较快--下标
        5. 线程不安全
    LinkedList
         1. 基于链表
         2. 内存空间不连续
         3. 增删元素较快
         4. 查询较慢
         5. 线程不安全
4. 题
    List list=new Vector();     
    Vector
        1. 基于数组
        2. 初始大小：10
        3. 扩容：每次扩容一倍，内存空间连续
        4. 增删较慢，查询较快 
        5. 线程安全
        6. java的最早的集合

3（List）写出下面程序的运行结果

public class Test3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> list=new LinkedList<String>();
		list.add("Hello");
		list.add("World");
		list.add("Hello");
		list.add("Lean");
		list.add("World");
		list.remove(0);
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
	}

}

World
Hello
Lean
World

5（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 方法。

import java.util.ArrayList;
import java.util.*;

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 void work() {
		System.out.println(name+"work");
	}
	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 int hashCode() {
		int result=0;
		if(name!=null) {
			result=name.hashCode();
		}
		return result+age;
	}
	public boolean equals(Worker worker){
		if(this==worker) {
			return true;
		}
		if(worker==null) {
			return false;
		}
		if(worker.getClass()!=this.getClass()) {
			return false;
		}
		if(this.name == worker.name &&(this.age == worker.age)&& (this.salary == worker.salary)) {
			return true;
		}else {
			return false;
		}

	}
}
public class Test5{
	public static void main(String[] args) {
		List<Worker> list=new ArrayList<Worker>();
		list.add(new Worker("zhang3",18,3000));
		list.add(new Worker("li4",25,3500));
		list.add(new Worker("wang5",22,3200));
		list.add(1, new Worker("zhao6",24,3300));
		list.remove(3);
		list.add(new Worker("wang5",22,3200));
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
		for(Iterator<Worker> it=list.iterator();it.hasNext();) {
			it.next().work();
		}

总结

集合：

1. Collection体系集合：
   I. Collection父接口：该体系结构的根接口，代表一组对象，称为“集合”，每个对象都是该集合的“元素”。
   II. List接口的特点：有序、有下标、元素可重复。
   III. Set接口的特点：无序、无下标、元素不可重复。

2. List子接口：
   I. 特点：有序、有下标、元素可以重复。
   II. 继承可父接口提供的共性方法，同时定义了一些独有的与下标相关的操作方法。

3. List实现类：
   I. JDK8的ArrayList，实际初始长度是0
   II. 首次添加元素时，需要实际分配数组空间，执行数组扩容操作
   III. 真正向数组中插入数据，（Lazy懒）用的时候再创建，或再加载，有效的降低无用内存的占用

4. ArrayList：
   I. 数组结构存储，查询快，增删慢。//注册（1次）-> 查询（N次）
   II. JDK 1.2发布，执行效率快，线程不安全。

5. Vector：
   I. 数组结构存储，查询快，增删慢。
   II. JDK 1.0发布，执行效率慢，线程安全。

6. LinkedList：
   I. 链表（链接列表）结构存储，查询慢、增删快。
   II. 了解：Queue接口：队列、双端队列
   III. 了解：栈结构Last In First Out（后进先出）
   IV. 了解：队列结构First In First Out（先进先出）