您的位置:首页 > 编程语言 > Java开发

imooc java入门第三季 第4章第5章第6章 集合框架 Set List Map Collections Commparator Comparable 全部知识点

2016-12-18 13:25 471 查看
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/a6145055/article/details/53726886 第6章作业
package com.imooc.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
* 利用Collections.sort()方法对泛型为String的List进行排序</br>
* 1.创建完List<String>之后,往其中添加十条随机字符串</br>
* 2.每条字符串的长度为10以内的随机整数</br>
* 3.每条字符串的每个字符都为随机生成的字符,字符可以重复</br>
* 4.每条随机字符串不可重复</br>
* org.apache.commons.lang包下有一个RandomStringUtils类,</br>
* 其中有一个randomAlphanumeric(int length)函数,可以随机生成一个长度为length的字符串。</br>
*String filename=RandomStringUtils.randomAlphanumeric(10);</br>
*/
public class 作业 {

/**
* 测试集合复数类 的排序方法  排序List类型的String泛型
*/
public void testCollectionsListStringSort(){

/**
* 创建List类型的 String泛型的 属性stringSort
* List类型需要导入 java.util.List包
* ArrayList需要导入 java.util.ArrayList包
*/
List<String> stringSort=new ArrayList<String>();
String randomString;
for(int i=0;i<10;i++){
do{
Random random=new Random();
randomString=getRandomString(random.nextInt(10));//调用随机生成随机字符串的方法   长度10以内随机
}while(stringSort.contains(randomString));//判断stringSort里面是否包含这个字符串  包含则再循环一次生成新字符串
stringSort.add(randomString);//把值添加到List中去
System.out.println((i+1)+"成功添加字符串:"+randomString);//输出生成的随机字符串
}
System.out.println("-------排序前-------");
for(String zifu : stringSort){
System.out.println("元素顺序"+zifu);
}
Collections.sort(stringSort);//通过 集合复数类的 排序方法 升序 排列 List类String型的 stringSort属性
System.out.println("-------排序后-------");
for(Object zifu : stringSort){
System.out.println("元素顺序"+zifu);
}
}

/**
* 生成的字符串每个位置都有可能是str中的一个字母或数字,需要导入的包是importjava.util.Random;
* length用户要求产生字符串的长度
* @param length
* @return
*/

public  String getRandomString(int length){
String str="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
Random random=new Random();
StringBuffer sb=new StringBuffer();
for(int i=0;i<length;i++){
int number=random.nextInt(62);
sb.append(str.charAt(number));
}
return sb.toString();
}

public static void main(String[] args) {
// TODO Auto-generated method stub
作业 zy=new 作业();
zy.testCollectionsListStringSort();
}

}



ChildCourse 类

package com.imooc.collection;

public class ChildCourse extends Course {

}

CollectionsTest类

package com.imooc.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;//随机类

/**
* 测试集合的工具类 Collections
* @author Administrator
*
*/
public class CollectionsTest {

/**1.</br>
* 通过Collections.sort()方法,对Integer泛型的List进行排序,</br>
* 创建一个Integer泛型的List,插入十个100以内的不重复随机整数</br>
* 调用Collection.sort()对其进行排序
*/
public void testSort1(){

/**
* integerList List类型用来存储有序集合数据</br>
* 集合类型里面的泛型不能使用基本类型作为泛型,要使用包装类型才行</br>
* List类型需要导入java.util.List包</br>
* List类型初始化需要ArrayList 需要导入java.util.ArrayList包
*/
List<Integer> integerList=new ArrayList<Integer>();

//插入一个100以内的不重复的随机整数
//创建对积累对象
//Random类型需要导入java.util.Random包
Random random=new Random();
Integer k; //首先定义一个变量用来存放随机数
for (int i=0;i<10;i++){ //循环10次
do{
k=random.nextInt(100);//每次循环获得一个10以内的随机数赋给k
}while(integerList.contains(k));//内部循环 这个循环是为了保证k值不重复
//条件是如果integerList中contains(包含)随机数那么就再do(做)一次
integerList.add(k);//每次for循环把k的值添加到integerList集合中去
System.out.println("成功添加整数:"+k);
}
System.out.println("排序前");
for(Integer integer:integerList){	//通过foreach遍历integerList
System.out.println("元素:"+integer); //循环不打印出来
}
Collections.sort(integerList);//通过集合工具类的排序方法 升序排列集合内部元素
System.out.println("排序后");
for(Integer integer:integerList){	//通过foreach遍历integerList
System.out.println("元素:"+integer); //循环不打印出来
}
}

/**2.</br>
* 对String泛型的List进行排序
* 创建String泛型的List,添加三个乱序的String元素
* 调用sort方法,再次输出排序后的顺序
*/
public void testSort2(){
/**
* stringList List类型用来存储有序可重复集合数据</br>
* 集合类型里面的泛型不能使用基本类型作为泛型,要使用包装类型才行</br>
* List类型需要导入java.util.List包</br>
* List类型初始化需要ArrayList 需要导入java.util.ArrayList包
*/
List<String> stringList=new ArrayList<String>();
stringList.add("microsoft");
stringList.add("google");	//通过List的Add方法往stringList集合属性中添加数据
stringList.add("lenovo");

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);
}
}

/**3.</br>
* 对其它类型泛型的List进行排序,以Student为例
*
*/
public void testSort3(){
List<Student> studentList=new ArrayList<Student>();
Random random=new Random();//创建随机类型对象random

//往studentList集合中添加一个Student类型的集合 id号为随机1000以内的数字,姓名为Mike
studentList.add(new Student(random.nextInt(1000)+"","Mike"));
studentList.add(new Student(random.nextInt(1000)+"","Angela"));
studentList.add(new Student(random.nextInt(1000)+"","Lucy"));
studentList.add(new Student(10000+"","Beyonce"));	//这个1万因为是字符串类型比大小时会1个1个字符的对比 所以会排列前面
System.out.println("排序前");
for(Student student:studentList){
System.out.println("元素:"+student.id+":"+student.name);
}

/**
* 通过Collections集合工具类的sort排序</br>
* 这个排序会报错错 要在Student类里面实现copareTo方法就不会报错了</br>
* 通过Collections集合工具类的sort排序自定义类型的属性就必须要实现</br>
* Comparable接口才行  这里需要到Student去实现Comparable接口进行改造</br>
* public class Student implements Comparable<Student> { </br>
* 实现Comparable接口这个类里就要实现comparTo方法</br>
* public int compareTo(Student o){</br>
* return this.id.compareTo(o.id);</br>
* 默认对比的就是学生的id号
*/
Collections.sort(studentList);//排序studentList
// 实现Collections接口后实现copareTo方法这里就不会报错了

System.out.println("排序后");
for(Student student:studentList){
System.out.println("元素:"+student.id+":"+student.name);
}

/**按学生姓名排序
* 这里要再定义一个按学生姓名排序 就要用到一个 临时比较规则的接口 Comparator接口
* 我们新建一个SutdentCompartor类来实现它
* public class StudentCompartor implements Comparator<Student>{
* 这个接口必须要实现compare方法
* public int compare(Student o1,Student o2){
* 	return o1.name.compareTo(o2.n
1fff7
ame); 按照姓名排序
*/
Collections.sort(studentList, new StudentComparator());////按name排序studentList
// 实现临时比较接口 Comparator接口后实现copare方法这里就不会报错了
System.out.println("按照临时比较接口  排序后");
for(Student student:studentList){
System.out.println("元素:"+student.id+":"+student.name);
}
}

public static void main(String[] args) {
CollectionsTest ct=new CollectionsTest();
ct.testSort1();
ct.testSort2();
ct.testSort3();

}
}

Course类

package com.imooc.collection;

/**
*
* @author Ding
*课程类
*/
public class Course {
/**
* 课程编号
*/
public String id;
/**
* 课程名
*/
public String name;

/**
* 课程类的含参构造方法
* @param id  课程编号   (参数)
* @param name 课程名    (参数)
*/
public Course(String id,String name){
this.id=id;
this.name=name;
}

/**
* 课程类的无参构造方法
*/
public Course(){
}

@Override//这个重写方法是通过eclipse自动生成的不需要修改
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

@Override//这个重写方法是通过eclipse自动生成的不需要修改
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Course))
return false;
Course other = (Course) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}

}

ListTest类

package com.imooc.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;   //创建List类型的属性就必须导入此包

/**
*
* @author Ding
* 备选课程类
* 是用来存放课程编号和课程的类
*/
public class ListTest {

/**
* 用于存放备选课程的List序列   属性    | 定义为List类型  需要导入java.util.List包
*/
public List coursesToSelect;

/**
* 备选课程类的构造方法
*/
public ListTest() {
this.coursesToSelect=new ArrayList(); //初始化coursesToSelect(存放备选课程的)属性    | 定义为ArrayList()  需要导入java.util.ArryList包
//因为List是一个接口,不能直接实例化要用到ArryList去实现这个接口 | ArrayList():构造一个初始容量为 10 的空列表。
}

/**
* 增
* 用于往coursesToSelect(备选课程的List序列)中添加备选课程的方法
*/
public void testAdd(){
Course cr1=new Course("1","数据结构"); //调用课程类创建对象cr1 传入数据
coursesToSelect.add(cr1);//把课程传递给coursesToSelect(存放备选课程的) 属性  添加(cr1)
Course temp=(Course)coursesToSelect.get(0);//0代表数据的下标位置  | 创建Course类对象temp 通过List的get方法获取0位置的元素
System.out.println("添加了课程:"+temp.id+":"+temp.name);//输出课程编号 和 课程名

Course cr2=new Course("2","C语言");//调用课程类创建对象cr2传入数据
coursesToSelect.add(0,cr2);//指定在0位置添加
Course temp2=(Course)coursesToSelect.get(0);//0代表数据的下标位置  | 创建Course类对象temp2 通过List的get方法获取0位置的元素
System.out.println("添加了课程:"+temp2.id+":"+temp2.name);//输出课程编号 和 课程名

coursesToSelect.add(cr1);
Course temp0=(Course)coursesToSelect.get(2);//2代表数据的下标位置 | 创建Course类对象temp0 通过List的get方法获取2位置的元素
System.out.println("添加了课程:"+temp0.id+":"+temp0.name);

//Course cr3=new Course("4","测试");
//coursesToSelect.add(3, cr3);//这里会抛出数组下标越界异常(IndexOutOfBoundsException)
//因为目前只能指定到0-2的位置  因为下标长度只有3个位置

Course[] course={new Course("3","离散数学"),//创建课程类数组 并赋值
new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));//把课程传递给coursesToSelect(存放备选课程的) 属性
//addAll方法表示添加多个(Arrays.asList表示将数组转换成列表)
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(Arrays.asList(course2));//把课程传递给coursesToSelect(存放备选课程的) 属性
//addAll方法表示添加多个(Arrays.asList表示将数组转换成列表)
Course temp5=(Course)coursesToSelect.get(5);//取出离散
Course temp6=(Course)coursesToSelect.get(6);//取出汇编
System.out.println("添加了两门课:"+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);

}

/**
* 查
* 通过for循环取得List中的元素的方法
*/
public void testGet(){//测试取得List的元素相当于遍历list中的元素
int size=coursesToSelect.size();//调用List的size方法取得长度的值
System.out.println("有如下课程选:");
for(int i=0;i<size;i++){
Course cr=(Course)coursesToSelect.get(i);//用get方法把i传递进去
System.out.println("课程"+cr.id+":"+cr.name);
}
}

/**
* 查
* 通过迭代器来遍历List
*/
public void testIterator(){
/* 在collection接口(list的父接口)中定义了一个iterator(迭代器方法)
* 通过这个方法可以返回一个当前集合对象的迭代器
* 通过迭代器去遍历集合中的每一个元素
*/
Iterator it=coursesToSelect.iterator();//创建迭代器对象it | Iterator也是一个接口 需要导入java.util.Iterator包
System.out.println("有如下课程待选(通过迭代器访问):");

//这里通过循环 迭代器接口里有个hasNext方法
//意思是他如果里面还有元素就返回一个真值
while(it.hasNext()){
Course cr=(Course)it.next();//(Course)类型强转 |通过迭代器的next方法去取得具体的某个元素
System.out.println("课程"+cr.id+":"+cr.name);
/*注意:迭代器他只能用来遍历集合中的元素,本身不具备任何存储元素的功能
* 也就是迭代器是依赖于某个集合而存在的,它本身不能独立的存在
*/
}

}

/**
* 查
* 通过for each来遍历List
* 这个方法相对来说代码量最少
*/
public void testForEach(){
System.out.println("有如下课程待选(通过for each访问):");
for(Object obj : coursesToSelect){
Course cr=(Course)obj;
System.out.println("课程"+cr.id+":"+cr.name);
}
}

/**
* 改
* 修改List中的元素
*/
public void testModify(){
//通过List的set方法来修改数据  1代表下标位置
coursesToSelect.set(1, new Course("1","毛概"));
System.out.println("修改之后↓");
testForEach(); //调用方法 来遍历coursesToSelect 查看数据
}

/**
* 删
* 删除 List中的元素
*/
public void testRemove(){
Course cr=(Course)coursesToSelect.get(2);//获取2号下标的值
System.out.println("即将删除2位置和1位置上的课程");
/*Course[] courses={(Course)coursesToSelect.get(2),  //获取1  2号下标的值
*					(Course)coursesToSelect.get(1)};
*/
//coursesToSelect.removeAll(Arrays.asList(courses));//通过List的removeAll方法删除 Arrays.asList列表的courses对象的值  相当于删除了 1 和2号下标
coursesToSelect.remove(2);  //通过List的remove方法 删除一个2号下标的值
System.out.println("成功删除了课程!");
testForEach(); //调用方法 来遍历coursesToSelect 查看数据
}

/**
* 往List中添加一些奇怪的东西

public void testType(){
System.out.println("能否往List中添加一些奇怪的东西呢?");
coursesToSelect.add("我不是课程,我只是一个无辜的字符串!");    //这个不能用 格式不对会抛出 ClassCastException 异常
}
*/
}


MapTest类

package com.imooc.collection;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

/**
* Map类</br>
* 通过Map<String,Student>进行学生信息管理</br>
* 其中key为学生ID,value为学生对象</br>
*通过键盘输入学生信息ID和姓名 保存到Map中</br>
*对集合中的学生信息进行增删改查操作
*/
public class MapTest {

/**
* MapTest 构造方法</br>
* 用来承装学生类型对象
*/
public Map<String,Student> students;
private String id;
//定义Map 类型的 Students属性
//Map类型 需要导入java.util.Map包   泛型规定 <字符型 ,学生类型>

/**
* 在构造方法中初始化students属性
*/
public MapTest() {

/*初始化属性需要  利用java.util.HashMap包中的  HashMap
*用HashMap初始化students属性 到时输出的结果是无序的
*同时 泛型规定 <字符型 ,学生类型>
*/
this.students=new HashMap<String,Student>();

}

/**
* 增  </br>
* 测试添加:ID判断是否被占用,若未被占用,则输入姓名
* 创建新学生对象,并且添加到students中
*/
public void testPut() {

//创建一个Scanner对象,用来获取输入的学生ID和姓名
//导入java.util.Scanner包
Scanner input=new Scanner(System.in);
int i=0;
while(i<3){  //因为要输入3个学生所以要循环3次
System.out.println("请输入学生ID");//每次循环提示输入
String id=input.next();//把输入的ID号赋给 ID变量

//判断该ID是够被占用
Student st=students.get(id);//把Map的students属性的ID号传给st
//Map的get方法需要报键(key)做为一个参数传递进去

/*
* 如果这个key存在,那么get方法返回的就是key所对应的value值
* 如果不存在则返回有一个空对象null值
*/
if(st==null){
//提示输入学生姓名
System.out.println("请输入学生姓名:");
String name=input.next();

//创建新的学生对象 并把ID号换个姓名传给新学生对象属性中去
Student newStudent=new Student(id,name);
//通过调用students的put方法(增方法),添加ID-学生映射
students.put(id, newStudent);
//			key		value
System.out.println("成功添加学生:"+students.get(id).name);//根据students的get方法的key值的名字打印输出
i++;
} else {
System.out.println("该学生ID已被占用!");
continue;
}
}
}

/**查 </br>
* 测试Map的KeySet()方法</br>
*用keySet方法来获取students并遍历出来
*/
public void testKeySet(){

//通过keySet方法,返回Map中的所有key(键)的Set集合
//把学生属性的key传给Set属性的keySet
//Set类 需要导入java.util.Set包  规定泛型为String型
Set<String> keySet=students.keySet();

//取得students的容量(可以理解为之前学的长度size方法就是获取students的容量的方法)
System.out.println("总共有"+students.size()+"个学生!");

//遍历keySet,取得每一个键,再调用get方法取得每个键对应的value的目的
//通过for each方法来遍历keySet
for(String stuId:keySet){

//创建student类型的对象把students的ID传递进去
Student st=students.get(stuId);
if(st!=null){//如果值不为空
System.out.println("学生:"+st.name);//则输出xuesxm
//因为HashMap在jdk1.6 中是无序的所以每次输出学生的姓名是不一样的顺序
//但是jdk1.8输出来是有序的 每次都一样

}
}
}

/**
* 删</br>
* 测试删除Map中的映射
*/
public void testRemove(){
//获取从键盘输入的删除学生ID字符串
Scanner input=new Scanner(System.in);
while(true){
//提示输入得删除的学生的ID
System.out.println("情书如要删除的学生ID:");

String ID=input.next();

//判断该ID是否有对应的学生对象
//创建新的学生对象,把Map的get方法锁返回的值,把ID对应的Students的内容传给学生类对象
Student st=students.get(ID);
if(st==null){ //如果为空
//则提示输入ID不存在
System.out.println("该ID不存在!");
continue;//并跳过本次循环
}
//如果不为空证明ID存在就用Map的remove方法删除对应ID的Students的内容
students.remove(ID);
System.out.println("成功删除学生:"+st.name);//并输出删除的学生姓名
break;//跳出循环
}
}

/**
* 查</br>
* 通过entrySet方法来遍历Map</br>
* keySet方法只是返回所有的键的集合</br>
* EntrySet是返回所有的键值对的集合
* Entry类似Map的一个内部类 需要导入java.util.Map.Entry包
*/
public void testEntrySet(){
//通过entrySet方法,返回Map中的所有键值对
Set<Entry<String,Student>> entrySet1=students.entrySet();
//这里的泛型Entry需要导入java.util.Map.Entry包
//这里需要用一个Set泛型为Entry类型的一个对象去接收entrySet的返回值
/*entrySet返回的确是一个Entry的一个集合只不过这里本身也是带有泛型的
* 他泛型跟定义Map时是一模一样的所以这里定义变量的时候,再加上一个泛型
* String类型的键值和student类型的value值.
*/

for(Entry<String,Student> entry:entrySet1){ //通过for each遍历entrySet
System.out.println("取得键"+entry.getKey());//我们可以调用entry对象的getKey方法来返回当前对象的key值
System.out.println("对应的值为:"+entry.getValue().name);//可以diaoyentry的getvalue方法来返回这个键值对应的value值
//这里getValue返回的类型跟泛型规定的value的类型是一模一样的,所以可以直接调用他的name来打印输出对应的学生对象的姓名
}
}

/**
* 改</br>
* 利用put方法修改Map中的已有映射
*/
public void testMondify(){
//提示输入
System.out.println("请输入要修改的学生ID:");
//创建Scanner对象,去获取学生ID
Scanner input=new Scanner(System.in);
while(true){
//取得从键盘输入的学生ID
String stuID=input.next();

//从students中查找该学生ID对应的学生对象
Student student=students.get(stuID);//根据用户输入的学生ID去students中获取是否有映射
if(student==null){//如果结果为空
System.out.println("改ID不存在!请重新输入!");//则输出不存在
continue;//并跳过本次循环
}
//提示学生ID和姓名
System.out.println("当前改学生ID,所对应的学生为:"+student.name);
//提示输入新学生姓名,来修改已有的映射
System.out.println("请输入新的学生姓名:");
String name=input.next();
Student newStudent=new Student(stuID,name);//重新赋值
students.put(stuID, newStudent);
System.out.println("修改成功!");
break;
}
}

/**
* 测试Map中,是否包含某个Key值或者某个Value值
* 这个方法也需要去学生类重写 hashCode()和equals()方法
* 如果不修改的话对象的对比会返回false
*/
public void testContainsKeyorValue(){
//提示输入学生id
System.out.println("请输入要查询的学生ID:");
Scanner input=new Scanner(System.in);
String id =input.next();//输入ID

//在Map中,用containsKey()方法,来判断是否包含某个key值
//判断该ID在students中是否存在
System.out.println("您输入的学生ID为:"+id+",在学生映射表中是否存在:"+
students.containsKey(id));//这个是判断是否存在布尔型存在返回true
if(students.containsKey(id))//如果存在
System.out.println("对应的学生为:"+students.get(id).name);//则输出对应id学生的姓名
//提示输入学生姓名
System.out.println("请输入要查询的学生姓名:");
String name=input.next();
//用containsValue()方法,来判断是否包含某个Value值
if(students.containsValue(new Student(null,name)))//新创建学生对象id为空 ,姓名为键盘输入的
System.out.println("在学生映射变中,确实包含学生:"+name);
else
System.out.println("在学生映射表中不存在该学生!");
}

public static void main(String[] args) {
MapTest mt=new MapTest();
mt.testPut();//增
mt.testKeySet();//查 键 key
mt.testRemove();//删
mt.testEntrySet();//查  删除后的 键值对 key,value
mt.testMondify();//改
mt.testEntrySet();//查  修改后的  键值对 key,value
mt.testContainsKeyorValue();//查询是否包含某个key键或value值
}

}


SetTest类

package com.imooc.collection;

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

/**
* Set测试类</br>
* Set元素无需并且不可以重复的集合,被称为集</br>
* Set没有Set()方法去修改某个位置的元素</br>
* 因为List是有序的  Set是无序的</br>
* 所以不可能提供一个给指定索引位置去修改相应位置上元素的方法
*/
public class SetTest {

public Student student;

public List<Course> coursesToSelect;//

/**
* SetTest的构造方法
*/
public SetTest(){
this.coursesToSelect=new ArrayList<Course>();
//初始化coursesToSelect属性 ArrayList需要导入java.util.ArrayLis
}

/**
* 用于往coursesToSelect(存放备选课程的列表)中添加备选课程
*/
public void testAdd(){
//创建一个课程对象,并通过调用add方法,添加到备选课程List中
Course cr1=new Course("1","数据结构"); //创建课程对象cr1并赋值
coursesToSelect.add(cr1);//将课程对象添加到备选课程中去
Course temp=(Course) coursesToSelect.get(0);//创建课程临时对象temp 将0位置下标课程的获取出来 传递给temp
//System.out.println("添加了课程:"+temp.id+":"+temp.name);

//创建一个课程对象,并通过调用add方法,添加到备选课程List中
Course cr2=new Course("2","C语言"); //创建课程对象cr1并赋值
coursesToSelect.add(cr2);//将课程对象添加到备选课程中去
Course temp2=(Course) coursesToSelect.get(1);//创建课程临时对象temp2 将1位置下标课程的获取出来 传递给temp2
//System.out.println("添加了课程:"+temp2.id+":"+temp2.name);

//coursesToSelect.add(cr1);//因为Set类不能重复添加课程 所以要注释掉
//Course temp0=(Course) coursesToSelect.get(2);//创建课程临时对象temp0 将2位置下标课程的获取出来 传递给temp
//System.out.println("添加了课程:"+temp0.id+":"+temp0.name);

//Course cr3=new Course("4","测试");
//coursesToSelect.add(3, cr3);//这里会抛出数组下标越界异常(IndexOutOfBoundsException)
//因为目前只能指定到0-2的位置  因为下标长度只有3个位置

Course[] course={new Course("3","离散数学"),
new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
//此处必须用Arrays类asList方法: 返回一个受指定数组支持的固定大小的列表。 添加进去
Course temp3=(Course)coursesToSelect.get(2);//用get方法获取下标2号的数据传给temp3
Course temp4=(Course)coursesToSelect.get(3);//用get方法获取下标3号的数据传给temp4
//System.out.println("添加了两门课程:"+temp3.id+":"+temp3.name+"\n"
//					+temp4.id+":"+temp4.name);

Course[] course2={new Course("5","高等数学"),
new Course("6","大学英语")};
coursesToSelect.addAll(Arrays.asList(course2));
//此处必须用Arrays类asList方法: 返回一个受指定数组支持的固定大小的列表。 添加进去
Course temp5=(Course)coursesToSelect.get(4);//用get方法获取下标4号的数据传给temp3
Course temp6=(Course)coursesToSelect.get(5);//用get方法获取下标5号的数据传给temp4
//System.out.println("添加了两门课程:"+temp4.id+":"+temp4.name+"\n"
//		+temp5.id+":"+temp5.name);
}

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

/**
* 测试List的contains方法  contains:包含
*/
public void testListContains(){

//取得备选课程序列的第0个元素
//把备选课程通过List(有序集合类)的get(获取)方法
//获取下标位置第0位置的数据传递给 Course(课程)类型的 course属性
Course course=coursesToSelect.get(0);

//打印输出coursesToSelect(List<Course(课程类泛型)>有序集合类型  备选课程集合属性) 是否包含course对象
System.out.println("取得课程:"+course.name);//课程的名称

//contains的含义包含 在备选课程中是否包含course的课程
//包含返回true否则返回false
System.out.println("备选课程中是否包含课程:"+course.name+","+
coursesToSelect.contains(course));

//提示输入课程名称
System.out.println("请输入课程名称:");
Scanner input=new Scanner(System.in);
String name=input.next();

//创建一个姓的课程对象,ID和名称与course对象完全一样
Course course2=new Course();

//判断对象相等,要在Course类里重写equals方法  跳转到Course类的equals方法
//把键盘输入的值传给course2.name
course2.name=name;
System.out.println("新创建课程"+course2.name);
//在备选课程中 是否包含 课程类2对象 的课程
System.out.println("备选课程中是否包含课程:"+course2.name+","+coursesToSelect.contains(course2));

//通过indexof方法来缺德某元素的索引位置
//如果备选课程中包含course2则输出课程2的位置
if(coursesToSelect.contains(course2))
//就是course2的课程 在备选课程中的位置 这个位置就是下标 从0开始的位置
//如果调用lastIndexOf()方法可以知道课程最后一次出现的索引位置
System.err.println("课程:"+course2.name+"的索引位置为:"+
coursesToSelect.indexOf(course2));
}

/**
* 判断Set中课程是否存在
* 创建学生和 查询课程方法
*/
public void createStudentAndSelectCours(){
/*创建一个学生对象*/
Student student=new Student("1","小明");
System.out.println("欢迎学生:"+student.name+"选课!");
Scanner input=new Scanner(System.in);
for(int i=0;i<3;i++){  //i<3代表从0开始可以选3次课
System.out.print("请输入课程ID:");
String courseId=input.next();
for(Course cr:coursesToSelect){
if(cr.id.equals(courseId)){
student.courses.add(cr);
/*Set中,添加某个对象无论添加多少次
* 最终只会保留一个该对象(的引用)
* 并且,保留的是第一次添加的哪一个*/
//student.courses.add(cr);
//student.courses.add(null);
}

}
}
}

/**
* 测试Set的contains(包含)方法
*/
public void testSetContains(){
/*我们在学生选完课值后来判断学生所选的课程中是否有某门课程,
* 而这个课程是通过我们从键盘输入的课程名称来判断的.
*/
//提示输入课程名称
System.out.println("请输入学生选的课程名称:");
Scanner input=new Scanner(System.in);
String name=input.next();//取得键盘输入的名称的字符串赋给name;

//创建一个新的课程对象ID和名称,与course对象完全一样
Course course2=new Course();
course2.name=name;
System.out.println("新创建课程:"+course2.name);
System.out.println("备选课程中是否包含课程:"+course2.name+","+
student.courses.contains(course2));
}

/**
* 主函数
*/
public static void main(String[] args) {

SetTest st=new SetTest();
st.testAdd();
st.testListContains();
st.testForEach();

st.createStudentAndSelectCours();
st.testSetContains();  //如果不修改HashCode()方法这里会显示false  要到课程课去重写HashCode()和equals()方法
//st.testForEachForSet(student);
}

/**
* 学生选择了课程  之后输出的课程   的方法
*/
public void testForEachForSet(Student student1){

System.out.println("供选择了"+student1.courses.size()+"门课程");
for(Course cr : student1.courses){//注意这里如果现实类型不匹配   需要到学生类的 courses中  添加<Course>泛型
//再到学生类的构造方法中  把初始化Set类的   new HashSet<Course>()也添加<Course>泛型
System.out.println("选择了课程:"+cr.id+":"+cr.name);
}
/*循环遍历每一个元素只能用for each或iterator(迭代器)方法 不能用get方法
* 因为Set本身是无序的所以不肯去查询指定的索引位置上的元素,要用for each或iterator(迭代器)弄出来
*/
}

}

Student类

package com.imooc.collection;

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

/**
* 学生类</br>
* 实现Comparable接口 泛型学生类型
* @author Ding
*/
public class Student implements Comparable<Student>{

/**
* 学生编号  属性
*/
public String id;

/**
* 学生姓名  属性
*/
public String name;

/**
* 存放学生课程    属性    | 定义为Set类型  需要导入java.util.Set包
*/
public Set<Course> courses;

/**
* 学生类的含参构造方法
* @param id  (参数)
* @param name (参数)
*/
public Student(String id,String name){
this.id=id;
this.name=name;
this.courses=new HashSet<Course>();//初始化courses(存放学生课程的)属性
//初始化因为不能直接实例化Set
}

public Student(){

}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((courses == null) ? 0 : courses.hashCode());
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
return false;
Student other = (Student) obj;
if (courses == null) {
if (other.courses != null)
return false;
} else if (!courses.equals(other.courses))
return false;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}

/**
* 实现Comparable接口的 默认比较规则接口的   compareTo方法
*/
public int compareTo(Student o){
return this.id.compareTo(o.id);
/*这里 默认的排序跪着是按学生的id去进行排序
* 因为id是Stirng类型的属性,而String类型他本身是实现Comparable接口的
* 这也是为什么对一个字符串类型的List可以正常的用Collection进行排序
* 只用当前的id和比较参数对象的id去进行比较,将两个对象的id的比较结果
* 做为两个对象的比较结果来返回
*
* 这个方法它会返回一个int值,它里面有一个参数
* Student类型的o参数,
* 当这个o对象和当前的对象相等的时候则返回0
* 如果比较的o对象比当前的Student对象小则返回一个正整数
* 如果比较的o对象比当前的Student对象大则返回一个负整数
*
* 看完说明请移步 CollectionsTest类的  testSort3()方法去吧
*/
}

}

StudentComparator类

package com.imooc.collection;

import java.util.Comparator;

/**
* 这个类用来实现一个临时的学生类对象的 学生姓名的比较 要实现omparator<Student泛型>接口
* @author Administrator
*
*/
public class StudentComparator implements Comparator<Student> {

@Override
public int compare(Student o1, Student o2) {
// TODO Auto-generated method stub
return  o1.name.compareTo(o2.name);
}

}

TestGeneric类

package com.imooc.collection;

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

/**
* 测试 泛型类</br>
*带main方法
* @author Administrator
*
*/
public class TestGeneric {

/**
* 带有泛型 Course的List类型属性</br>
* 定义List类型的course属性 泛型规定只能存储Course类型的属性</br>
*  定义为List类型  需要导入java.util.List包
*/
public List<Course> courses;

/**
* 构造方法
* 用来初始化courses属性
* ArraysList需要导入java.util.ArrayList包
*/
public TestGeneric() {
this.courses=new ArrayList<Course>();//小括号表示调用了构造方法
////因为List是一个接口,不能直接实例化要用到ArryList去实现这个接口 | ArrayList():构造一个初始容量为 10 的空列表。
}

/**
* 增</br>
* 测试添加的fangfa
*/
public void testAdd(){
Course cr1=new Course("1","大学语文");
courses.add(cr1);//因为courses是List类型的 所有调用List的add方法八只传递进去
//泛型集合中,不能添加(泛型规定的类型及其子类型以为的对象,否则会报错

/*courses.add("嫩否添加一个奇怪的东西呢?");
* (会显示错误)The method add(Course) in the type List<Course> is not applicable for the arguments (String)
* (翻译)在类型列表中的方法添加(课程)不适用于参数(字符串)
*/

Course cr2=new Course("2","Java基础");
courses.add(cr2);

}

/*
*泛型集合中的限定类型不能使用基本数据类型
*基本数据类型:  int   long   boolean
*可以通过使用包装类限定允许存入的基本数据类型
*包装类型:	  Integer Long Boolean
*/

/**
* 测试循环遍历</br>
* for each语句
*/
public void testForEach(){
for(Course cr:courses){ //在ListTest类中的testForEach()方法使用Obiect类写的
//这次是用Course类型写的 因为这次定义的时候已经规定了他的泛型
//他里边的每一个元素肯定是Course课程类型的
System.out.println(cr.id+":"+cr.name);
}
}

/**
* 泛型集合可以添加泛型的子类型的对象实例
*/
public void testChild(){
ChildCourse ccr=new ChildCourse();//创建ChildChourse对象实例
ccr.id="3";//设置ccr 属性id为3
ccr.name="我是子类型的课程对象实例";//设置ccr的属性name值为 字符串
courses.add(ccr);//把ccr添加到courses中去  courses是专门用来存储备选课程的 泛型属性
//这个方法可以证明泛型集合确实是可以添加泛型的子类对象的实例
}

/**
* 泛型不能使用基本类型
*/
public void testBasicType(){
List<Integer> list=new ArrayList<Integer>();//如果泛型写 int型 会显示语法错误
list.add(1);
System.out.println("基本类型必须使用包装类作为泛型!"+list.get(0));
}

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

入口类

package com.imooc.collection;

public class testType {
public static void main(String[] args) {
ListTest lt=new ListTest();
lt.testAdd();//添加数据
lt.testGet();//通过for循环来遍历
lt.testIterator();//通过迭代器来遍历
lt.testForEach();//通过for each来遍历
lt.testModify();//修改数据
lt.testRemove();//删除coursesToSelect中的2个数据
//lt.testType(); //测试一下这个不能用 格式不对会抛出 ClassCastException 异常
lt.testForEach();
}
}


内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: