一.Java 中的集合框架(上)
1.Java中的集合框架概述
JAVA集合框架体系结构:Collection与Map是两个根接口。
Collection接口:内部存储的是一个个独立的对象。包含:
1、List接口:序列,存储元素排列有序且可重复。实现类:ArrayList,数组序列。实现类:LinkedList,链表。
2、Queue接口:队列,存储元素排列有序且可重复。实现类:LinkedList,链表。
3、Set接口:集,存储元素无序且不可重复。实现类:HashSet,哈希集。
Map接口:内部以<Key,Value>两个对象(任意类型)为一个映射去存储数据,这一个映射就是Entry类(Map的内部类)的实例。包括:实现类:HashMap,哈希表。
2.Collection接口&接口简介
Collection接口是List、Set、Queue接口的父接口
Collection接口定义了可用于操作List、Set和Queue的方法--增删改查
List接口及其实现类--ArrayList
List是元素有序并且可以重复的集合,被称为序列。
List可以精确的控制每个元素的插入位置,或删除某个位置元素
List有add()插入方法和get()获取方法
ArrayList--数组序列,是List的一个重要实现类
ArrayList底层是由数组实现的,这也是其名字的由来
3.学生选课——创建学生类和课程类
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();
}
}
学生的可选择的课程信息 存放在Set类型的属性courses中
在构造器中 将courses进行初始化(实例化)this.courses=new HashSet();因为Set是一个接口,所以不能直接实例化,通过HashSet这个实现类来进行实例化 ,需要导入包
在实际开发中,应该把所有的属性都私有化,然后通过get 和 set 来访问属性。
学生的可选择的课程信息 存放在Set类型的属性courses中
在构造器中 将courses进行初始化(实例化)this.courses=new HashSet();因为Set是一个接口,所以不能直接实例化,通过HashSet这个实现类来进行实例化 ,需要导入包
在实际开发中,应该把所有的属性都私有化,然后通过getter 和 setter 来访问属性。
实际开发中,类的属性应该私有化
4.学生选课——添加课程Ⅰ
(1)
对象被存入集合都变成object类型了 取出时需要类型强转
例:Course temp = (Course)coursesToSelect.get(0);
(2)
添加进list中的位置(index)介于【0,length】之间;0代表插到队头,length代表插到队尾。
(3)
List是接口,所以在构造方法中不能直接实例化,而通过ArrayList()实例化!!!
例:public List coursesToSelect = new ArrayList();
(4)
List、Set、Map都是接口 不可以直接对他实例化 要借助相应的实例化类 ArrayList(), HashSet(),HashMap();
(5)
调用Add()方法添加到List中。有两种方法:
1. 直接添加,例:CoursesToSelect.add(cr1);
2. 可以指定添加的位置,例:CoursesToSelect.add(0,cr1);
(6)
如果添加到List中的长度大于他目前的长度,则系统会出现异常,即数组下表越界异常
5.学生选课——添加课程Ⅱ
list中还有addAll(List list)
就是将一个List里面的元素一股脑的全都加进去,
一般定义一个数组,如何把一个数组转换成List? 调用方法Arrays.asList(Object[] obs);
//可以将一个数组转换为一个List,然后可以将这个元素传进addAll()里面
当然还有addAll(index,List list)方法
removeAll直接传入一个list,同理
记得取出东西之后,要类型强转哦!!!因为取出来都是Object的。
向List中添加元素的几种方法:
新建List类
public List courseToSelect;
初始化List类
public ListTest()
{
this.courseToSelect=new ArrayList();
}
向List中添加数据
method_1
courseToSelect.add(对象1);
method_2
courseToSelect.add(位置,对象2);
method_3
courseToSelect.addAll(Arrays.asList(数组_对象3));
method_4
courseToSelect.addAll(位置,Arrays.asList(数组_对象4));
获取
Course temp=(Course)courseToSelect.get(位置);
6.学生选课——课程查询
以下三种方法都是用来取出List中元素的方法:
-----for循环-----
public void testGet(){
int size=coursesToSelect.size();
for(int i=0;i<size;i++){
Course cr=(Course) coursesToSelect.get(i);
System.out.println("取出的课程:"+cr.getId()+":"+cr.getName());
}
}
-----迭代器-----
Iterator是一个接口,依赖于集合存在的
Iterator it=courseToSelect.iterator();
while(it.hasNext()){
Course cr=(Course) it.next();
System.out.println("课程:" + cr.id + ":" + cr.name);
}
-----for each(增强for循环)-----
凡是继承了Iterable接口的类所生成的对象都可以用for/each循环
for(Object obj:coursesToSelect){//遍历集合中的每一个元素,作为每一个Object变量
Course cr=(Course) obj;
System.out.println("课程:" + cr.id + ":" + cr.name);
}
7.学生选课——课程修改
使用set(index,Object element)修改元素,index表示索引位置,element表示新对象。
修改List的元素
public void testModify(){
coursesToSelect.set(4,new Course("7","毛概"));
}
public List a = new ArrayList(); //创建List
a.add(index,object); //j将元素添加到List的第index+1位置
a.get(index); //获取List的第index+1位置的元素
a.set(index,object) //更新List的第index+1位置的元素
a.remove(index,object) //删除List的第index+1位置的元素
8.学生选课——课程删除
(删除元素)List中有remove(index),remove(对象值)和removeAll(Arrays.asList(对象数组名))方法来删除容器中元素的值(用法和add类似).
Course是信息课程类,有id和name属性。courseToSelect是list的序列容器对象。
1.remove(index);删除位置要大于0并且小于List(序列容器)的长度。如果要删除全部可以用for循环嵌套此方法。
2.remove(object);先要获得删除的值,用法是先定义一个信息变量通过get()来存放要删除的值,然后用remove(删除的对象值);
public void textdelect{
Course cr=(Course)(courseToSelect.get(4));
courseToSelect.remove(cr);//通过remove(对象值);
或者 courseToSelect.remove(4);//通过remove(删除位置); }
3.removeAll(Arrays.asList());要删除指定的多个位置 Arrays.asLIst(对象数组名);作用是把数组转换为集合
用法是先创建信息对象数组存放删除元素的值,然后再用removeAll(Arrays.asList(对象数组名))方法,删除集合数组的元素。
public void textdelext2{
Course []course={(Course)(courseToSelect.get(4)),(Course)(courseToSelect.get(5))}; // 定义数组存放要删除的值
courseToSelect.removeAll(Arrays.asList(course)); // 删除4和5位置的值 }
9.学生选课——应用泛型管理课程Ⅰ
泛型<>;规定List定义的容器只能存储某种类型的元素。不用泛型的话是什么类型的元素都可以插入,因为插入集合是忽略其类型,把它看成为Object类型,取出时需要强行转换对应的类型。
编写带有泛型的集合
List<Course> courseToSelect;
在构造方法中(实例化的时候也可以不在构造方法,直接实例就可以)
this.courseToSelect=new ArrayList<Course>(); //带有泛型-Course的List类型属性就创建了
泛型集合中,不能添加泛型规定的类型以及其子类型以外的对象,否则会报错。
运用了泛型的话,用foreach语句时 存储变量应该为泛型的类型。for(Course a:courseToSelect),不必再用Object取出再强转,因为已经规定容器里装的都是Course类型。
10.学生选课——应用泛型管理课程Ⅱ
子类要调用父类的隐式构造器,但父类如果有含参构造器,则不会自动生成一个无参构造器,需要手动添加无参构造器。
总结关于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等)的对象,如果要添加,需要使用其包装类
11.学生选课——通过Set集合管理课程
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;无序演示(如图)
二. Java 中的集合框架(中)
1.Map&HashMap简介
1. Map接口提供了一中映射关系,其中的元素是键值对(key-value)的形式存储的,能够实现根据Key快速查找value。Key-value可以是任何对象,是以Entry类型的对象实例存在的。
2.Key是不可以重复的,Value是可以重复的。Key-value都可以为null,不过只能有一个key是null。
3.map支持泛型,Map<K,V>
4.每个键最多只能映射到一个值
5.Map接口提供了分别返回key值集合、value值集合以及Entry(键值对)集合的方法
6.通过put<K key,V value>,remove<Object key>操作数据
7.HashMap中的Entry对象是无序排列的,HashMap是Map的一个重要实现类,也是最常用的
2.学生选课——使用Map添加学生
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()方法
import java.util.Map;
public class MapTest{
//用来承装学生类型对象
public Map<String,Student> students;
//构造器中初始化students;
public MapTest(){
this.students=new HashMap<String,Student>();}
/**测试添加:输入学生ID,判断是否被占用
若有被占用,则输入姓名,创建心学生对象,并且
添加到student中*/
public void tsetPut(){
//创建一个Scanner对象,用来获取输入的学生ID和姓名
Scanner console=new Scanner(System.in);
int i=0;
while(i<3){
System.out.println("请输入学生ID");
String ID=console.next();
//判断该ID是否被占用
Student st=student.get(ID);
if(st==null){
//提示输入学生姓名
System.out.println("请输入学生姓名");
String name=console.next();
//创建新的学生对象
Student newStudent=new Student(ID,name);
//通过调用students的put方法,添加ID-学生映射
student.put(ID,newStudent);
System.out.println("成功添加学生:"+students.get(ID).name);
i++;
else{
System.out.println("该学生ID已被占用!");
continue;}}}}
//测试Map的keySet方法
public void testKeySet(){
//通过keySet方法,返回Map中的所有“键”的Set集合
Set <String> keySet=students.keySet();
//取得students的容量
System.out.pritnln("总共有:"+students.size()+"个体学生");
//遍历keySet,取得每一个键,再调用get()方法取得每个键对应的value
for(String stuId:keySet){
Student st=students.get(stuId);
if(st!=null)
System.out.println("学生:"+st.name);
}
}
public static void main(String args){
MapTest mt=new MapTest();
mt.testPut();
mt.testKeySet();
}}
3.学生选课——删除Map中的学生
Map增删改查:
增:map的put(key,value)方法添加。
查:1.利用keyset()方法获得Map中key的集合,再遍历key的集合,利用Map的get(key)方法得到key对应的value值。
2.利用EntrySet方法获取May中Entry对象集:然后用foreach遍历集,再用Entry集的getkay()和getvalue()方法得到每一个key值和value值。
删:remove(object key)
改:put(原有的key,新的value)
通过entrySet可以返回Map中的所有键值对
Set<Entry<String,Student>>entrySet = students.entrySet();
//测试删除Map中的映射
public void testRemove(){
//获取从键盘输入的待删除学生ID字符串
Scanner console=new Scanner(System.in);
while(true){
//提示输入待删除的学生ID
System.out.println("请输入要删除的学生ID!");
String ID=console.next();
//判断该ID是否有对应的学生对象
Student st=students.get(ID);
if(st==null){
//提示输入的ID并不存在
System.out.println("该ID不存在!");
continue;}
students.remove(ID);
System.out.println("成功删除学生:"+st.name);
break;}}
//通过entrySet方法遍历Map
public void testEntrySet(){
//通过entrySet方法,返回Map中的所有键值对
Set <Entry<String,Student>>entrySet=students.entrySet();
for(Entry<String,Student>entry:entrySet){
System.out.println("取得键:"+entry.getKey());
System.out.println("对应的值为:"+entry.getValue().name);}
}
//main方法中调用
mt.testRemove();
mt.testEntrySet();
4.学生选课——修改Map中的学生
关于Map:
1.初始化变量
Map<String,Student>students = new HashMap<String,Student>()
//初始化key值为String,存放的数据类型为student的students集合
2.put()增加对象
Student newStu = new Student(ID,name);
students.put(ID,newStudent);//以ID作为key值
3.查找对象
(1)Set<String>keySet = students.keySet();
for(String stuId:keySet){
Student st =students.get(stuId);
}//先用keySet()获取所有的key,再遍历获取每一个对象
(2)Set<Entry<String,Student>>entrySet = students.entrySet();//由于每个键值对都以entry类型存放,yongentrySet()方法获取所有键值对
for(Entry<String,Student>entry:entrySet) {//遍历获取键值对
entry.getKey();//获取key
entry.getValue();//获取value
}
4.删除
students.remove(ID);//根据key的值删除
5.修改
Student stu = students.get(ID);
Student newStudent =new Student(ID,newname);
students.put(ID,newStudent);
/*Map中没有直接修改的方法,所以采用先找出对象,然后不修改key值,只修改value的方法进行修改*/
//利用put方法修改Map中的已有映射
public void testModify(){
//提示要输入要修改的学生ID
System.out.println("请输入要修改的学生ID:");
//创建一个Scanner对象,去获取从键盘上输入的学生ID字符串
Scanner console=new Scanner(System.in);
三.Java中的集合框架(下)
1.学生选课——判断list中课程是否存在
"=="和equals()的区别:
1)对于==,如果作用于基本数据类型的变量,则直接比较其存储的 “值”是否相等;
如果作用于引用类型的变量,则比较的是所指向的对象的地址
2)对于equals方法,注意:equals方法不能作用于基本数据类型的变量
如果没有对equals方法进行重写,则比较的是引用类型的变量所指向的对象的地址;
诸如String、Date等类对equals方法进行了重写的话,比较的是所指向的对象的内容。
@Override
public boolean equals(Object obj){
//如果obj与比较对象的位置相同,说明obj是从集合中取出再与该位置的元素比较,所以肯定相同
if(this==obj)
return true;
if(obj==null){//若字符串为空,则不能进行字符串比较,所以返回false
return false;
if(!(obj instanceof Course)){//若果obj当前类型不是Course,则当前两个对象肯定不相同
//instanceof 它的作用是判断其左边对象是否为其右边类的实例
return false;
//若上述均通过,则说明obj为Course对象,且当前对象不为空
Course course=(Course)obj;
if(this.name==null){
if(course.name==null)
return true;
else
return false;
}else{
if(this.name.equals(course.name))
return true;
else
return false;
}
}
2.学生选课——判断Set中课程是否存在
使用set中的contains方法,set中调用contains(obj)方法,contains方法的实现机制:先调用object中的hashcode方法,再调用object中的equals方法。所以要对对象的hashcode()方法和equals方法重写,可以使用eclipse中的source>GENARATE hashcode(),在对象的类中,实现方法的重写。
@Override
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;
}
public void testsetcontains(){
System.out.println("请输入课程名称:");
Scanner nnew = new Scanner(System.in);
String name = nnew.next();
Course course2 = new Course();
course2.name = name;(此时只定义了name属性,id属性没有定义!!所以重写hashCode()时候不能把id选住)
System.out.println("创建新课程:"+ course2.name);
System.out.println("备选课程中是否包括上面的课程" + course2.name+","+ student.courses
.contains(course2));
}
3.学生选课——获取List中课程的位置
indexOf()方法与lastIndexOf()方法实现原理:
1、遍历调用每个元素的equals()方法,如果返回true则将次元素的索引返回;
2、如果有多个相同元素,则只返回第一个元素的索引;
3、lastIndexOf()方法则从最后一个元素开始遍历;
4.学生选课——判断Map中是否包含指定的key和value
Map中通过containsKey()方法和containsValue()方法来判断键和值是否存在
Map 中对对象进行了 Key 标记,通过 get(Key)可以取得对应的对象
Map 的containsValue()方法的参数是 Object 对象,因为Map 的 Value 值是对象元素
Map 的containsKey()方法取得 Map 映射的 Key 值
List中的contains()方法借Map中的containsValue()方法调用equals()方法来进行比较。所以要重写Hashcode和equals方法
跟 List 的 contains()方法一样,Map 中的 containsValue()方法也会调用每个 Value 值的 equals()方法去和参数对象比较
id 是string类型 contains方法使用equals方法 来比较,所以值相等就返回ture
Value 是Student类型,自己定义的,默认的contains方法中的equals方法,比较的是两个引用是否一样,所以要重写equals方法
由于是比较两student类型是否相同,所以要做Student类中重写equals方法
public static void main(String[] args){
MapTest mt = new MapTest();
mt.testPut();
mt.testKeySet();
mt.testModify();
mt.testEntrySet();
}
public void testContainsKeyOrValue(){
System.out.println("请输入要查询的学生ID");
Scanner console = new Scanner(System.in);
String id = console.next();
System.out.println("您输入的学生ID为:"+id+",在学生映射表中是否存在:"+students.containsKey(id));
if(students.containsKey(id))
System.out.println("对应的学生为:"+students.get(id).name);
}
5.应用Collections.sort()实现List排序
public String testRandomString(){
StringBuilder stringBuilder = new StringBuilder();
//存放所包含字符62位
String container = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
Random random = new Random();
int num = 0;
while(num == 0){
num = random.nextInt(10);
}
for(int i = 0; i < num; i++){
int index = random.nextInt(61);
stringBuilder.append(container.charAt(index));
}
return stringBuilder.toString();
}
6.学生选课——尝试对学生序列排序
collection.sort()方法对元素进行排序,列表中的元素都必需实现 Comparable 接口,否则不能使用 sort()方法排序
package com.imooc_b;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class CollectionsTset {
public void Sort() {
List<String> listTset = new ArrayList<String>();
Random random = new Random();
// 生成十条不重复的字符串(由数字和字母组成)
for (int i = 0; i < 10; i++) {
StringBuffer buffer = new StringBuffer();
do {
// 字符串长度为10以内的整数,nextInt()范围为(0,9),字符串长度不想设置为空就加1
int k = random.nextInt(9) + 1;
// 随机生成字符串
for (int j = 0; j < k; j++) {
int b;
do {
// 随机生成0到122的数字,0到9表示数字字符,65到90表示'A'到'Z'
// 97到122表示'a'到'z'
b = (int) (Math.random() * 123);
}
// 当生成的字符为'0'到'9'或'a'到'z'或'A'到'Z'时跳出
while (!((b >= 0 && b <= 9) || (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')));
if (b >= 0 && b <= 9) {
String in = Integer.toString(b);
buffer.append(in);
} else {
char ch = (char) b;
String in = String.valueOf(ch);
buffer.append(in);
}
}
} while (listTset.contains(buffer.toString()));
// 如果list没有该字符串就加入
listTset.add(buffer.toString());
}
System.out.println("-------排序前----------");
for (String string : listTset) {
System.out.println("元素:" + string);
}
Collections.sort(listTset);
System.out.println("---------排序后---------");
for (String string : listTset) {
System.out.println("元素:" + string);
}
}
public static void main(String[] args) {
CollectionsTset ct = new CollectionsTset();
ct.Sort();
}
}
7.Comparable&Comparator简介
一、compareable 是默认比较规则, comparator是临时比较规则
1.Comparable接口------可比较的
实现该接口表示:这个类的实例可以比较大小,可以进行自然排序
定义了默认的比较规则
其实现类需实现compareTo()方法
comparaTo()方法返回正数表示大,负数表示小,0表示相等
2.Comparator接口-----比较工具接口
用于定义临时比较规则,而不是默认比较规则
其实现类需要实现compare()方法
Comparator和Comparable都是Java集合框架的成员
compareable 需要实现compare to方法, comparator需要实现 compare方法
三、Java集合框架:
Collection接口,Map接口,Collections工具类,Comparable接口,Comparator接口
8.学生选课——实现学生序列排序
让没有默认比较规则的类进行比较的方法
一、让该类实现Comparable接口:
1、在该类中加上implements Comparable<类名>。
2、实现.compareTo(类名 对象名)方法,若this较大则返回正值,若相等则返回0,若this较小则返回负值。(各种类都包含.compareTo()方法)
3、调用Collections.sort(对象名)进行排序。
二、让该类实现Comparator接口:
1、新建一个类加上implements Comparator<类名>
2、实现.compare(类名 对象名1,类名,对象名2)方法,若this较大则返回正值,若相等则返回0,若this较小则返回负值。
3、调用Collections.sort(对象名,实现Comparator<类名>接口的对象名)方法。(因此要重建一个类来实现Comparator接口!!)
字符串大小比较方式:分别将每一个字符串的每一位进行比较,0-9>A-Z>a-z