集合一

集合的作用：

在类的内部对数据进行组织
简单而且快速的搜索大数量条目
有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素
有的集合接口提供了映射关系，可以通过关键字（key）去快速的查找到对应的唯一对象，而这个关键字可以是任意类
集合与数组的对比：

数组的长度固定而集合的长度可变
数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象。

List接口及其实现类——ArrayList

List是元素有序并且可以重复的集合，被称为序列。
List是可以精确的控制每个元素的插入位置或者删除某个位置的元素
ArrayList——数组序列，是List的一个重要实现类
ArrayList的底层是由数组实现的。
ArrayList 元素单个，效率高，多用于查询。
Vector 是线程安全的

泛型
集合中的元素，可以是任意类型的对象（对象的引用），如果把某个对象放入集合，则会忽略他的类型，而把他当做object处理；
泛型则是规定了某个集合只可以存放特定类型的对象，会在编译期间进行类型检查，可以直接按指定类型获取集合元素。
泛型不能使用基本类型（如int,long,boolean等），如果必须使用则使用基本类型的包装类

Iterator是什么
一些集合类提供了内容遍历的功能，通过java.util.Iterator接口。这些接口允许遍历对象的集合。依次操作每个元素对象。当使用Iterators时，在获得Iterator的时候包含一个集合快照。通常遍历一个Iterator的是不建议修改集合本省。

ArrayList和Vector的区别
ArrayList与Vector主要从两方面来说：
一、同步性：
Vector是线程安全的，也就是说是同步的，而ArrayList是线程不安全的，不是同步的。
二、操作：
由于Vector支持多线程操作，所以在性能上就比不上ArrayList了。
三、数据增长：
ArrayList和Vector都有一个初始的容量大小，当存储进去他们里面的元素个数超出容量的时候，就需要增加ArrayList和Vector的存储空间，每次增加存储空间的时候不是只增加一个存储单元，是增加多个存储单元。
Vector默认增加原来的一倍，ArrayList默认增加原来的0.5倍。
Vector可以由我们自己来设置增长的大小，ArrayList没有提供相关方法。
Vector中的set方法是用来替换原来的值的vt.set(0,"zero");如果单纯用来添加内容add,put都可以。

HashMap和Hashtable的区别
都属于Map接口的类，实现了将唯一键映射到特定的值上。
一、历史原因
Hashtable是基于陈旧的Dictionary类的，HashMap是java1.2引进的Map接口的一个实现。
二、同步性
Hashtable是线程安全的，也就是说是同步的，而HashMap是线程不安全的，不是同步的。
三、值
HashMap类没有分类或者排序，它允许一个null键和多个null值。
Hashtable类似于HashMap，但是不允许null键和null值。
四、效率
Hashtable比HashMap慢，因为它是同步的。
使HashMap同步
 Map m = Collections.synchronizedMap(hashMap);  来达到同步的效果。

LinkedList与ArrayList有什么区别
两者都实现List接口，不同之处在于：
1、ArrayLis是基于动态数组实现的，LinkedList是基于链表的数据结构。
2、get访问List内部任意元素时，ArrayList的性能要比LinkedList性能好。LinkedList中的get方法是要按照顺序从列表的一端开始检查，直到另一端。
3、对于新增和删除操作LinkedList要强于ArrayList，因为ArrayList要移动数据。
附加：
LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get,remove,insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用做堆栈（stack),队列（queue)或双向队列（deque);
注意LinkedList没有同步方法。如果多个线程同事访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
List list = Collections.synchronizedList(new LinkedList());

数组Array和列表集合ArrayList有什么区别
Array可以包含基本类型和对象类型，ArrayList只能包含对象类型
Array大小是固定的，ArrayList大小是动态的。
ArrayList提供了更多的方法和特性，如addAll(),removeAll(),iterator();等
对于基本类型数据，集合使用自动装箱来减少编码工作量，但是，当处理固定大小的基本数据类型的时候，这种方法比较慢。

Set接口及其实现类——HashSet 

set是元素无序并且不可以重复的集合，被称为集
HashSet——哈希集，是Set的一个重要实现类
以下为代码，使用/*************/标识类的分割线

package com.imooc.collection;

public class ChildCourse extends Course {

}
/***********************/

package com.imooc.collection;

/**
* 课程类
* @author lihf
*
*/
public class Course {
public String id;
public String name;
public Course(String id,String name){
this.id=id;
this.name=name;
}
public Course(){

}
}
/**************************/
package com.imooc.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**

b8c8
* 备选课程类
* @author lihf
*
*/
public class ListTest {

/**
* 用于存放备选课程的list
*/
public List coursesToSelect;
public ListTest(){
//List为借口，不能直接实例化
this.coursesToSelect = new ArrayList();
}
/**
* 用于往coursesToSelect中添加备选课程
*/
public void testAdd(){
//创建一个课程对象，并且通过调用add方法，添加到备选课程list中
Course cr1 = new Course("1","数据结构");
coursesToSelect.add(cr1);
Course temp = (Course)coursesToSelect.get(0);
System.out.println("添加了课程："+temp.id+":"+temp.name);

Course cr2 = new Course("2","C语言");
coursesToSelect.add(0, cr2);  //指定添加位置
Course temp2 = (Course)coursesToSelect.get(0);
System.out.println("添加了课程："+temp2.id+":"+temp2.name);

coursesToSelect.add(cr1);
Course temp0 = (Course)coursesToSelect.get(2);
System.out.println("添加了课程："+temp0.id+":"+temp0.name);

//添加位置参数大于当前集合的长度（数组下标越界异常）
/*Course cr3 = new Course("3","test");
coursesToSelect.add(4, cr3);*/

Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 = (Course)coursesToSelect.get(3);
Course temp4 = (Course)coursesToSelect.get(4);
System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+","+temp4.id+":"+temp4.name);

Course[] course2 = {new Course("5","高等数学"),new Course("6","大学英语")};
coursesToSelect.addAll(2,Arrays.asList(course2));
Course temp5 = (Course)coursesToSelect.get(2);
Course temp6 = (Course)coursesToSelect.get(3);
System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+","+temp6.id+":"+temp6.name);
}

/**
* 获取list中元素的方法
* @param args
*/
public void testGet(){
int size = coursesToSelect.size();
System.out.println("有如下课程待选：");
for(int i=0;i<size;i++){
Course cr = (Course) coursesToSelect.get(i);
System.out.println("课程："+cr.id+":"+cr.name);
}
}
/**
* 通过迭代器来遍历List
* @param args
*/
public void testIterator(){
//通过集合的iterator方法，取得迭代器的实例
Iterator it = coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问)：");
while(it.hasNext()){
Course cr = (Course) it.next();
System.out.println("课程："+cr.id+":"+cr.name);
}
}

/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach(){
System.out.println("有如下课程待选(通过for each访问)：");
for(Object obj:coursesToSelect){
Course cr = (Course) obj;
System.out.println("课程："+cr.id+":"+cr.name);
}
}

/**
* 修改List中的元素
* @param args
*/
public void testModify(){
coursesToSelect.set(4,new Course("7","毛概"));
}
/**
* 删除List中的元素
* @param args
*/
public void testRemove(){
/*Course cr = (Course)coursesToSelect.get(4);
System.out.println("我是课程："+cr.id+":"+cr.name+"我即将被删除");
coursesToSelect.remove(cr);//coursesToSelect.remove(4);
System.out.println("成功删除课程");*/

System.out.println("即将删除4和5位置上的数据");
Course[] courese = {(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(5)};
coursesToSelect.removeAll(Arrays.asList(courese));
System.out.println("成功删除课程");

}

/**
* 往List中添加一些奇怪的东西
* @param args
*/
public void testType(){
System.out.println("是否能在list中添加一些奇怪的定西呢？");
coursesToSelect.add("我不是课程，我只是一个无辜的字符串！！");
}

public static void main(String[] args) {
ListTest t = new ListTest();
t.testAdd();
t.testGet();
t.testIterator();
t.testForEach();
t.testModify();
t.testForEach();
t.testRemove();
t.testForEach();
}
}
/************************/
package com.imooc.collection;

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

public class SetTest {

public List<Course> coursesToSelect;

public SetTest(){
this.coursesToSelect = new ArrayList<Course>();
}

public void testAdd(){
//创建一个课程对象，并且通过调用add方法，添加到备选课程list中
Course cr1 = new Course("1","数据结构");
coursesToSelect.add(cr1);
Course temp = (Course)coursesToSelect.get(0);
//System.out.println("添加了课程："+temp.id+":"+temp.name);

Course cr2 = new Course("2","C语言");
coursesToSelect.add(0, cr2);  //指定添加位置
Course temp2 = (Course)coursesToSelect.get(0);
//System.out.println("添加了课程："+temp2.id+":"+temp2.name);

/*coursesToSelect.add(cr1);
Course temp0 = (Course)coursesToSelect.get(2);
System.out.println("添加了课程："+temp0.id+":"+temp0.name);*/

//添加位置参数大于当前集合的长度（数组下标越界异常）
/*Course cr3 = new Course("3","test");
coursesToSelect.add(4, cr3);*/

Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 = (Course)coursesToSelect.get(2);
Course temp4 = (Course)coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+","+temp4.id+":"+temp4.name);

Course[] course2 = {new Course("5","高等数学"),new Course("6","大学英语")};
coursesToSelect.addAll(2,Arrays.asList(course2));
Course temp5 = (Course)coursesToSelect.get(4);
Course temp6 = (Course)coursesToSelect.get(5);
//System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+","+temp6.id+":"+temp6.name);
}

/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach(){
System.out.println("有如下课程待选(通过for each访问)：");
for(Object obj:coursesToSelect){
Course cr = (Course) obj;
System.out.println("课程："+cr.id+":"+cr.name);
}
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
SetTest st = new SetTest();
st.testAdd();
st.testForEach();
//创建一个学生对象
Student student = new Student("1", "小名");
System.out.println("欢迎学生："+student.name+"来选课");
//创建一个Scanner对象，用来接收从键盘输入的课程ID
Scanner console = new Scanner(System.in);
for(int i=0;i<3;i++){
System.out.println("请输入课程ID:");
String courseId = console.next();
for(Course cr:st.coursesToSelect){
if(cr.id.equals(courseId)){
student.courses.add(cr);
/**
* Set中，添加某个对象，无论添加多少次
* 最终只会保留一个该对象（的引用）
* 并且，保留的是第一次添加的那个
*/
/*student.courses.add(null);
student.courses.add(cr);*/
}
}
}
st.testForEachForSet(student);

}
public void testForEachForSet(Student student){
System.out.println("共选择了："+student.courses.size()+"门课程");
//打印输出学生所选择的课程
for(Course cr:student.courses){
System.out.println("选择了课程:"+cr.id+":"+cr.name);
}
}

}
/************************/
package com.imooc.collection;

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

/**
* 学生类
* @author lihf
*
*/
public class Student {

public String id;
public String name;
public Set<Course> courses;

public Student(String id,String name){
this.id=id;
this.name=name;
this.courses = new HashSet<Course>();
}
}
/****************************/
package com.imooc.collection;

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

public class TestGeneric {

/**
* 带有泛型——Course,的List类型属性
*/
public List<Course> course;

public TestGeneric(){
this.course = new ArrayList<Course>();
}

/**
* 测试增加
* @param args
*/
public void testAdd(){
Course cr1 = new Course("1","大学语文");
course.add(cr1);
//泛型集合中，不能添加泛型规定的类型及其子类型以外的对象，否则会报错！
//course.add("收拾收拾");
Course cr2 = new Course("2","Java基础");
course.add(cr2);
}

/**
* 测试循环便利
* @param args
*/
public void testForEarch(){
for(Course cr:course){
System.out.println(cr.id+":"+cr.name);
}
}

/**
* 泛型集合可以添加泛型的子类型的对象实例
* @param args
*/
public void testChild(){
ChildCourse ccr = new ChildCourse();
ccr.id="3";
ccr.name="我是子类型的课程对象实例~~~";
course.add(ccr);
}

/**
* 泛型不能使用基本类型
* @param args
*/
public void testBasicType(){
List<Integer> list = new ArrayList<Integer>();
list.add(1);
System.out.println("基本类型必须使用包装类作为泛型："+list.get(0));
}

public static void main(String[] args) {
TestGeneric tg = new TestGeneric();
tg.testAdd();
tg.testChild();
tg.testForEarch();
tg.testBasicType();
}
}

Map接口

Map提供了一种映射关系，其中的元素是以键值对（key-value)的形式存储的，能够实现根据key快速查找value
Map中的键值对以Entry类型的对象实例形式存在
键（key值）不可重复，value值可以重复
每个键最多只能映射到一个值
Map接口提供了分别返回key值集合，value值集合以及Entry(键值对）集合的方法
Map支持泛型，形式如：Map<key,value>
HashMap类

HashMap是Map的一个重要实现类，也是最常用的，基于哈希表实现
HashMap中的Entry对象是无序排列的
Key值和value值都可以为null，但是一个HashMap只能有一个key值为null的映射（key值不可重复）