1、集合框架
概念与作用
集合的概念
在现实生活中：很多的事物凑在一起
数学中的集合：具有共同属性的事物发总体，例如有理数和整数。
java中的集合类：是一种工具类，就像是容器，储存任意数的具有共同属性的对象。
集合的作用
1、在类的内部，对数据进行组织；
2、简单而快速的搜索大数量的条目；
3、有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素；
4、有的集合接口，提供了映射关系，可以通过关键字（key）去快速查找到对应的唯一对象，而这个关键字可以是任意类型。
与数组的对比-----为何选择集合而不是数组？
>数组的长度固定，集合长度可变
>数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象
体系结构
2、Collection接口、子接口以及实现类
Collection接口
>是List、Set和Queue接口的父接口
>定义了可用于操作List、Set和Queue的方法增删查改
List接口及其实现类——ArrayList
>List是元素有序并且可以重复的集合，被称为序列
> List可以精确的控制每个元素的插入位置，或删除某个位置
>ArrayList——数组序列，是List的一个重要实现类
>ArrayList底层是由数组实现的
实现功能——模拟学生选课系统
>选择课程（往集合中添加课程）
>删除所选的某门课程（删除集合中的元素）
>查看所选课程
>修改所选课程
3、创建学生类和课程类
创建学生类
代码
package imooc_collection_map_demo;
import java.util.HashSet;
import java.util.Set;
/**
* 学生类
* @author abc25
*
*/
public class Student {
public String id;
public String name;
public Set courses;
public Student(String id,String name) {
this.id = id;
this.name = name;
this.courses = new HashSet();
}
}
创建课程类
代码
package imooc_collection_map_demo;
/**
* 课程类
* @author abc25
*
*/
public class Course {
public String id;
public String name;
public Course(String id,String name) {
this.id = id;
this.name = name;
}
}
4、添加课程
第一步：添加课程1
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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);;
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
}
}
结果
第二步：添加课程2
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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);
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
}
}
结果
第三步：异常
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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);
Course cr3 = new Course("3","test");
coursesToSelect.add(4,cr3);
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
}
}
结果：显示数组下标越界异常
第四步：添加课程3和课程4
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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);
//以下方法会抛出数组下标越界异常
//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);
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
}
}
结果
第五步：添加课程5、课程6
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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);
//以下方法会抛出数组下标越界异常
//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(2);
Course temp6 = (Course) coursesToSelect.get(3);
System.out.println("添加了两门课程：" + temp5.id + ":" + temp5.name + ";" + temp6.id + ":" + temp6.name);
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
}
}
结果
5、课程查询
第一步
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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);
//以下方法会抛出数组下标越界异常
//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(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);
}
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
It.testGet();
}
}
结果
第二步
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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("添加了课程：" + temp.id +":" + temp.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(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);
}
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
It.testGet();
}
}
结果
第三步
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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);
}
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
It.testGet();
It.testIterator();
}
}
结果
第四步
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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);
}
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
It.testGet();
It.testIterator();
It.testForEach();
}
}
结果
6、课程修改
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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","毛概"));
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
It.testGet();
It.testIterator();
It.testForEach();
It.testModify();
It.testForEach();
}
}
结果
7、课程删除
第一步：删除4位置上的课程
代码
package imooc_collection_map_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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);
System.out.println("成功删除课程!");
testForEach();
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
It.testGet();
It.testIterator();
It.testForEach();
It.testModify();
It.testForEach();
It.testRemove();
}
}
结果
第二步：再删除5位置上的课程
代码
package imooc_collection_map_demo;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* 备选课程类
* @author abc25
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
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("即将删除4位置和5位置上的课程");
Course[]courses = {(Course) coursesToSelect.get(4),(Course)coursesToSelect.get(5)};
coursesToSelect.removeAll(Arrays.asList(courses));
// coursesToSelect.remove(4);
System.out.println("成功删除课程!");
testForEach();
}
public static void main(String[] args) {
ListTest It = new ListTest();
It.testAdd();
It.testGet();
It.testIterator();
It.testForEach();
It.testModify();
It.testForEach();
It.testRemove();
}
}
结果
泛型
泛型<>;规定List定义的容器只能存储某种类型的元素。不用泛型的话是什么类型的元素都可以插入，因为插入集合是忽略其类型，把它看成为Object类型，取出时需要强行转换对应的类型。
编写带有泛型的集合
List<Course> courseToSelect;
在构造方法中(实例化的时候也可以不在构造方法，直接实例就可以)
this.courseToSelect=new ArrayList<Course>(); //带有泛型-Course的List类型属性就创建了
泛型集合中，不能添加泛型规定的类型以及其子类型以外的对象，否则会报错。
运用了泛型的话，用foreach语句时 存储变量应该为泛型的类型。for(Course a:courseToSelect),不必再用Object取出再强转，因为已经规定容器里装的都是Course类型。
总结关于list类型的一下用法：
1.创建对象
List list = new ArrayList();
2.向list对象中添加数据
（1）Course crre = new Course("1","数据结构");//一个类的对象
list.add(crre);//将对象添加到list中
（2）Course[] crre = {new Course("",""),new Course("","");//对象的数组
list.addAll(0,Arrays.asList(course));//切记Arrays.asList方法
3.获取集合中的元素
（1）Course temp = (Course)list.get(0);//注意强转
（2）Iterator it = list.iterator();
while(it.hasNext()){
Course cr = (Course)it.next();//迭代遍历，使用iterator方法
}
（3）for(Object obj:list){
Course cr = (Course)obj;
}//foreach方法 ，注意Object的使用
4.集合中参数的修改
list.set(2,new Course("",""));
5.集合中数据的删除
(1)list.remove(位置）;
(2)Course[] crr = {(Course)list.get(位置）(Course)list.get(位置）}；
list.removeAll(Arrays.asList(crr));//参考addAll
6.带有泛型的list
List<Course> course = new ArrayList<Course>();//相当于添加进去的元素有了具体类型，不再是Object
7.list可以添加子类型的对象
8.list不能直接添加基本类型（int,float等）的对象，如果要添加，需要使用其包装类
Set接口及其实现类——HashSet
Set是元素无序并且不可以重复的集合，被称为集；
HashSet——哈希集，是Set的一个重要实现类。
1、Set没有像List中set()方法一样就修改，因为List是有序的，可以指定位置，而Set是无序的。
2、查询遍历时，Set不能用get()方法去获取，因为无序没有指定索引ID，但可以使用foreach和iterator来遍历，但是每次遍历出来可能顺序都不一样，还是因为无序造成的。
3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。
4、Set还可以添加null；无序演示（如图）
Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法
Map支持泛型，形式如：Map<K,V>
HashMap类
HashMap是Map中的一个重要的实现类，也是最常用的，给予哈希表实现
HashMap中的Entry对象是无序排列的
Key值和Value值都可以为Null，但是一个HashMap只能有一个key值为Null的映射（key值不可重复）student.get(ID)是采用Map的get（）方法，检测是否存在值为ID的学生，如果没有，则返回null.
keySet()方法，返回所有键的Set集合。
取得Map的容量可用size()方法。keyset()返回Map中所有的key以集合的形式可用Set集合接收，HashMap当中的映射是无序的。
students.get(ID)是采用Map的get()方法
List：类似数组，有从0开始int类型的标记，可存储任意对象，存储对象可重复Set：可存储任意对象，存储对象不可重复
Map：存储的单位对象是一组键值对entry，其中key不可重复，value可以重复，key和value都可以是任意对象
1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
如果作用于引用类型的变量，则比较的是所指向的对象的地址
2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量
如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
http://www.cnblogs.com/dolphin0520/p/3592500.html
list 与 set 中contain()方法调用机制：
list 中的contain()方法是拿到list中的每个对象来调用Object类中的equals()方法
Set 中的contain()方法是拿到list中的每个元素来先调用hashcode()方法来返回哈希码值，当哈希码的值相等时，再调用equals()方法，当比较的元素此时也相同时，才会返回true。因此调用Set中的contain()方法时，需要对hashcode()方法及equals()方法进行重写。
indexOf()方法与lastIndexOf()方法实现原理：
1、遍历调用每个元素的equals()方法，如果返回true则将次元素的索引返回；
2、如果有多个相同元素，则只返回第一个元素的索引；
3、lastIndexOf()方法则从最后一个元素开始遍历；
Collection集合中的公用方法
①.cointains方法--------返回值为boolean，测试集合中是否存在某个元素
②.indexof方法----------测试集合中某个元素第一次出现的的位置。如果元素不存在返回-1
③.lastIndexof方法------测试集合中某个元素最后一次出现的位置。如果元素不存在返回-1
⑤.size方法-------------测试集合的容量大小
⑥.在Map中，用containsKey()方法来判断是否包含某个key值。返回值为true，则包含。
⑦.在Map中，用containsValue()方法来判断是否包含某个value值。
集合的indexof方法去找元素的位置，数组可以直接转成集合，修改也有直接修改的方法。
Map映射表
一、判断是否包含某个Key值：containsKey()
二、判断是否包含某个Value值：containsValue()
1、同样是以每一个元素的value值的equals方法进行比较，所以需要重写value类的equals()方法来进行属性（某个）比较
关于Student的hashCode和equals 方法重写：
没有重写之前是比较的新建对象所在的内存空间 而重写之后则是比较两个类对象是否相同
/**
* 通过调用sort方法对String类型的元素进行排序
*/
public void testSort2(){
List<String> StringList=new ArrayList<String>();
//定义存储随机字符的字符串
String str="1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
//创建Random的实例，用于生成随机数
Random random=new Random();
//循环10次，生成10个随机长度的字符串
for(int i=0;i<10;i++){
//创建一个StringBuilder类的字符串，方便随意的追加、修改
//注意要放在for循环内，才能每生成一个字符串并输出后，归零
StringBuilder sb=new StringBuilder();
//规定字符串的长度为10以内的随机数
int length=random.nextInt(10);
for(int j=0;j<length;j++){
//获取字符串str中的任意一个字符，然后追加进sb字符串
int number=random.nextInt(str.length());
sb.append(str.charAt(number));
}
//生成一个字符串后存储进集合中，并输出
StringList.add(sb.toString());
System.out.println("生成随机字符串："+sb.toString());
}
System.out.println("---------排序前--------");
for (String string : StringList) {
System.out.println("元素："+string);
}
Collections.sort(StringList);
System.out.println("--------排序后---------");
for (String string : StringList) {
System.out.println("元素："+string);
}
}
一、compareable 是默认比较规则， comparator是临时比较规则
1.Comparable接口------可比较的
实现该接口表示：这个类的实例可以比较大小，可以进行自然排序
定义了默认的比较规则
其实现类需实现compareTo()方法
comparaTo()方法返回正数表示大，负数表示小，0表示相等
2.Comparator接口-----比较工具接口
用于定义临时比较规则，而不是默认比较规则
其实现类需要实现compare()方法
Comparator和Comparable都是Java集合框架的成员
compareable 需要实现compare to方法， comparator需要实现 compare方法
三、Java集合框架：
Collection接口，Map接口，Collections工具类，Comparable接口，Comparator接口
Java集合框架的主要成员
主类第四段：
Collections.sort(array);
//判断1玩家的最大手牌
ArrayList<String> array1=new ArrayList<String>();
array1.add(al.get(0));
array1.add(al.get(2));
Collections.sort(array1);
//判断1玩家的最大手牌
ArrayList<String> array2=new ArrayList<String>();
array2.add(al.get(1));
array2.add(al.get(3));
Collections.sort(array2);
//输出玩家1的最大手牌
for(int i=0;i<ch.length;i++){
if(array1.get(1).equals(ch[i])){
System.out.println("玩家："+alwj.get(0).name+"的最大手牌为:"+str[i]);
}
}
//输出玩家2的最大手牌
for(int i=0;i<ch.length;i++){
if(array2.get(1).equals(ch[i])){
System.out.println("玩家："+alwj.get(1).name+"的最大手牌为:"+str[i]);
}
}
//判断玩家谁获胜
if(array.get(3).equals(al.get(0))||array.get(3).equals(al.get(2))){
System.out.println("*********玩家："+alwj.get(0).name+"获胜!**********");
}else{
System.out.println("*********玩家："+alwj.get(1).name+"获胜!**********");
}
扫一扫
5859
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
