实验11泛型与集合
泛型与集合框架
中泛型列表中的具体类型
.
例12-2
▪ interface Listen<E> {
▪
void listen(E x);
▪}
▪ class Student implements Listen<Piano> {
向这个链表依次添加节点。由于任何类都是 Object类的子类,因此可以把任何一个对象作为 链表节点中的对象
.
使用集合框架注意事项(没有使用泛型)
任何对象加入集合类后,自动转变为Object类型;取出 时,需要进行强制类型转换,恢复为特定的类型
Rabbit
Car
Student
加入集合
从集合中取出
Object
例12-3
▪ List<String> list=new LinkedList<String>();
▪ list.add("大家好");
▪ list.add("国庆60周年");
▪ list.add("十一快乐");
▪ Iterator<String> iter=list.iterator();
▪ while(iter.hasNext()){
.
12.2.3 遍历链表
▪ 当用户需要遍历集合中的对象时,应当使用该集 合提供的迭代器,而不是让集合本身来遍历其中 的对象。由于迭代器遍历集合的方法在找到集合 中的一个对象的同时,也得到待遍历的后继对象 的引用,因此迭代器可以快速地遍历集合。
如何使用泛型与泛型集合
students.Remove("周杰杰"); 通过key删除元素 …
演示示例5:MySchool
哈希表的遍历
如何遍历一个哈希表?
不能遍历整个对象,而 是遍历Values
foreach (Object stuo in students.Values) {
Student stu = (Student)stuo; Console.WriteLine(); }
给哈希表添加元素
使用哈希表
students.Add( , scofield);
添加元素
Key
获取哈希表的元素
Value
…
Student stu2 = (Student)students["周杰杰"];
stu2.SayHi();
…
需要类型转换
通过key获取元素
删除哈希表的元素
int Add(Object value) //添加一个对象到集合的末尾 返回索引
建立班级学员的集合
ArrayList students = new ArrayList();
Student scofield = new Student("Scofield", Genders.Male, 28, "越狱狱");
集合与泛型
12-1 集合與陣列的比較 12-2 Collection介面與Collections類別 12-3 泛型 12-4 各種集合的特色
12-5 Map的功能與架構
第12章 集合與泛型 - 2
12-1 集合與陣列的比較
集合 空間 大小 不必指定集合大小。無論 將元素存入或移除,集合 都會動態調整空間以符合 需求。 陣列 必須指定陣列大小,之後無 法改變。元素存取時,不可 超過索引上限。
第12章 集合與泛型 - 10
泛型的進階設定 泛型的設定也可以使用「?」搭配「extends」或 「super」來增加設定上的彈性。
第12章 集合與泛型 - 11
輸出結果 書籍定價為:580 範例說明 • 第3行:T的類型可以是Number或其子類別。 • 第10行:指定T的類型是Integer。 • 第12行:book物件其泛型T的設定是Integer,符合第3行規定,所以可以呼 叫第3行的show()方法。
資料 類型
可存放物件,放入的物件 可存放物件或基本類型,但 會自動轉型成Object類型, 必須符合陣列的資料類型。 搭配泛型功能就可限制元 素的資料類型。
要將元素取出,可使用: 1.for-each。 2.Iterator物件功能。 要將元素取出,可使用: 1.for迴圈並搭配索引。 2.for-each。
第12章 集合與泛型 - 21
Comparable介面
要讓物件加入至SortedSet集合內之後有排序性,該物件所屬類別
必頇實作Comparable介面的compareTo()方法。假設SortedSet集 合內已有1個物件o1,並準備新增另一個物件o2,
會自動執行「pareTo(o2);」,有3種回傳值:
集合、泛型
HandsOn
3
Collection 接口 1-1
Collection对象是将多个元素组成一个单元的 对象
集合用于存储、检索和操纵数据
集合框架是用于表示和操纵集合的统一体系结 构
HandsOn
4
Collection 接口 1-2
集合框架包含三个组件
接口
是表示集合的 抽象数据类型
实现
是接口的实际实现
HandsOn
12
Vector 类 3-1
Vector 类
它具有类似数组的数据 结构,而且是动态的
可以存放一定 数量的元素
容量可以递增
HandsOn
13
Vector 类 3-2
构造方法
Vector()
创建一个空 Vector
说明
创建一个空 Vector ,其初始大小由 initialCap 指 定,容量增量 为 0
HandsOn
25Leabharlann HandsOn23
泛型接口和类的定义(绪)
定义泛型接口或类时,其中的参数化类型可以带 有限制条件:
class MyList<E extends Number>{ ...... }
HandsOn
24
泛型方法的定义
泛型方法是指带有参数化类型的方法:
public static<T> void fromArrayToCollection( T[] a,Collection<T> c) { for() { c.add(o); } }
集合、泛型
HandsOn
教学目标
了解集合框架的接口以及实现类。 掌握ArrayList、Vector以及HashMap等 常见集合实现类的用法。 了解如何利用泛型存取数据。
泛型在集合中的作用
泛型在集合中的作用泛型是Java中一种重要的特性,它在集合中起着重要的作用。
本文将探讨泛型在集合中的作用和优势,并介绍一些常见的泛型用法。
一、泛型的作用泛型的作用是为了在编译时期提供类型安全检查,并减少类型转换的错误。
在集合中,泛型可以帮助我们在编译时期捕获一些类型错误,避免在运行时期出现ClassCastException等异常。
二、泛型的优势使用泛型的主要优势是增加了代码的可读性和可维护性。
通过指定集合中元素的类型,我们可以清晰地知道集合中存储的是什么类型的对象,从而更好地理解代码的含义。
此外,泛型还能提供编译时期的类型检查,避免了一些潜在的错误。
三、泛型用法1. 声明泛型集合在声明集合变量时,可以使用泛型来指定集合中元素的类型。
例如,可以声明一个ArrayList来存储整数类型的元素:```javaArrayList<Integer> list = new ArrayList<>();```这样,我们就可以确保list集合中只能存储整数类型的对象,如果尝试存储其他类型的对象,编译器会报错。
2. 使用通配符通配符是一种特殊的泛型类型,用来表示未知的类型。
在一些情况下,我们可能需要操作集合中的元素,但对其类型并不关心,这时可以使用通配符来表示未知类型。
例如,我们可以定义一个方法,接受任意类型的集合作为参数:```javapublic void printList(List<?> list) {for (Object obj : list) {System.out.println(obj);}}```在这个方法中,我们使用了通配符"?"来表示未知类型,这样就可以接受任意类型的集合作为参数。
在方法内部,我们可以通过Object 类来操作集合中的元素。
3. 泛型类和泛型方法除了在集合中使用泛型,我们还可以定义泛型类和泛型方法。
泛型类是指具有泛型类型参数的类,可以在类中使用这个类型参数。
第11章泛型与集合
Map接口操作
➢ Map接口基本操作: 6.1.1 public V put(K key, V value) public V get(Object key) public V remove(Object key) public void clear() public Set<K> keySet() public Collection<V> values()
用Set对象实现集合操作
➢ 使用Set对象的批量操作方法,可以实现标准集合代数运算。 6.1.1
➢ 假设s1和s2是Set对象,下面的操作可实现相关的集合运算。
s1.addAll(s2):实现集合s1与s2的并运算。 s1.retainAll(s2):实现集合s1与s2的交运算。 s1.removeAll(s2):实现集合s1与s2的差运算。 s1.containAll(s2):如果s2是s1的子集,该方法返回true。
➢ 常用方法如下:
E get(int index)
6.1.1
E set(int index, E element)
void add(int index, E element)
E remove(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
HashSet类
➢ HashSet类用散列方法存储元素,具有最好的存取性能, 6.1.1 但元素没有顺序。
➢ HashSet类的构造方法有: HashSet() 初始容量是16,默认装填因子是0.75。 HashSet(Collection c) HashSet(int initialCapacity)
面向对象程序设计 ——泛型与集合
C#中的泛型和泛型集合
C#中的泛型和泛型集合⼀、什么是泛型?泛型是C#语⾔和公共语⾔运⾏库(CLR)中的⼀个新功能,它将类型参数的概念引⼊.NET Framework。
类型参数使得设计某些类和⽅法成为可能,例如,通过使⽤泛型类型参数T,可以⼤⼤简化类型之间的强制转换或装箱操作的过程(下⼀篇将说明如何解决装箱、拆箱问题)。
说⽩了,泛型就是通过参数化类型来实现在同⼀份代码上操作多种数据类型,利⽤“参数化类型”将类型抽象化,从⽽实现灵活的复⽤。
使⽤泛型给代码带来的5点好处:1、可以做⼤限度的重⽤代码、保护类型的安全以及提⾼性能。
2、可以创建集合类。
3、可以创建⾃⼰的泛型接⼝、泛型⽅法、泛型类、泛型事件和泛型委托。
4、可以对泛型类进⾏约束,以访问特定数据类型的⽅法。
5、关于泛型数据类型中使⽤的类型的信息,可在运⾏时通过反射获取。
例⼦:using System;namespace ConsoleApp{class Program{class Test<T>{public T obj;public Test(T obj){this.obj = obj;}}static void Main(string[] args){int obj1 = 2;var test = new Test<int>(obj1);Console.WriteLine("int:" + test.obj);string obj2 = "hello world";var test1 = new Test<string>(obj2);Console.WriteLine("String:" + test1.obj);Console.ReadKey();}}} 输出结果是: int:2 String:hello world 分析: 1、 Test是⼀个泛型类。
集合与泛型
第一个问题:怎么才能了解JAVA集合类?集合类是什么?数组是集合的一种,是集合的一个子集,你理解了数组就理解了集合.理解集合类集合类存放于java.util包中。
集合类存放的都是对象的引用,而非对象本身,出于表达上的便利,我们称集合中的对象就是指集合中对象的引用(reference)。
集合类型主要有3种:set(集)、list(列表)和map(映射)。
(1)集集(set)是最简单的一种集合,它的对象不按特定方式排序,只是简单的把对象加入集合中,就像往口袋里放东西。
对集中成员的访问和操作是通过集中对象的引用进行的,所以集中不能有重复对象。
集也有多种变体,可以实现排序等功能,如TreeSet,它把对象添加到集中的操作将变为按照某种比较规则将其插入到有序的对象序列中。
它实现的是SortedSet接口,也就是加入了对象比较的方法。
通过对集中的对象迭代,我们可以得到一个升序的对象集合。
(2)列表列表的主要特征是其对象以线性方式存储,没有特定顺序,只有一个开头和一个结尾,当然,它与根本没有顺序的集是不同的。
列表在数据结构中分别表现为:数组和向量、链表、堆栈、队列。
关于实现列表的集合类,是我们日常工作中经常用到的,将在后边的笔记详细介绍。
(3)映射映射与集或列表有明显区别,映射中每个项都是成对的。
映射中存储的每个对象都有一个相关的关键字(Key)对象,关键字决定了对象在映射中的存储位置,检索对象时必须提供相应的关键字,就像在字典中查单词一样。
关键字应该是唯一的。
关键字本身并不能决定对象的存储位置,它需要对过一种散列(hashing)技术来处理,产生一个被称作散列码(hash code)的整数值,散列码通常用作一个偏置量,该偏置量是相对于分配给映射的内存区域起始位置的,由此确定关键字/对象对的存储位置。
理想情况下,散列处理应该产生给定范围内均匀分布的值,而且每个关键字应得到不同的散列码。
集合类简介java.util中共有13个类可用于管理集合对象,它们支持集、列表或映射等集合,以下是这些类的简单介绍集:1. HashSet:使用HashMap的一个集的实现。
泛型与集合的注意事项
泛型与集合的注意事项⼀.List,List<Object>,List<?>三者区别1.List(1)List可以接受任意泛型赋值List list = new ArrayList();List list1 = new ArrayList<Object>();List list2 = new ArrayList<Integer>();(2)List可以赋值给任意类型注意遍历时可能会出现类型转换异常,这是由于list中可能存放不同类型数据导致转换不了List list = new ArrayList();list.add(111);list.add(222);List<Integer> list1 = list;list1.forEach(System.out::println);将 list.add(222) 改为 list.add("222") 再执⾏就会出错Exception in thread "main" ng.ClassCastException: ng.String cannot be cast to ng.Integerat java.util.ArrayList.forEach(ArrayList.java:1249)at code.TestDemo.main(TestDemo.java:16)2.List<Object>(1)List<Object>可以接受List赋值List list = new ArrayList();List<Object> list2 = list;(2)确定类型的集合是不可以相互赋值的List<Object>不可以赋值给List<Integer>,同时List<Integer>也不可以赋值给List<Object> 3.List<?>List<?>在接受了其他泛型赋值之后,可以删除和清除元素 list2.remove(0); , list2.clear();List<?>在接受了其他泛型赋值之后,不可以添加元素 list2.add(1); 但可以添加null元素 list2.add(null);List<?>可以获取元素但必须使⽤Object来接收,需要修改内部数据需判断之后强制类型转换再修改List<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);List<?> list2 = list;list2.remove(0);list2.clear();1 List<?> list2 = new ArrayList<T>() {2 {3 add(new T(1));4 add(new T(2));5 add(new T(3));6 }7 };89 list2.add(null); //可以添加null元素10 Object obj = list2.get(1);1112if (obj instanceof T) { //强制类型装换后可以改变内部数据13 T t = (T) obj;14 System.out.println(t.i);15 t.i = 3;16 }1718 obj = list2.get(1);19if (obj instanceof T) {20 System.out.println(((T) obj).i);21 }⼆.<? extends T>和<? super T>1.<? extends T>(1)只允许接受T类型或T类型的⼦类赋值List<Integer> list1 = new ArrayList<>();List<Number> list2 = new ArrayList<>();List<? extends Number> list = list1;list = list2;(2)不能使⽤add⽅法添加新元素,只能添加null不能 list.add(1);List<Integer> list1 = new ArrayList<>();list1.add(1);list1.add(2);List<? extends Number> list = list1;list.add(null);(3)取出元素只能使⽤T类型以及T类型的⽗类接收List<Integer> list1 = new ArrayList<>();list1.add(1);list1.add(2);List<? extends Number> list = list1;Number number = list.get(0);Object number1 = list.get(0);2.<? super T>(1)只允许接受T类型或T类型的⽗类赋值List<Integer> list1 = new ArrayList<>();List<Number> list2 = new ArrayList<>();List<? super Integer> list = list1;list = list2;(2)只能使⽤add⽅法添加T类型元素或T类型的⼦类型元素List<Integer> list1 = new ArrayList<>();List<? super Integer> list = list1;list.add(new Integer(1));(3)取出类型只能使⽤Object类型接收List<Object> list1 = new ArrayList<>();list1.add(new Animal());list1.add(new Person());list1.add(new Man());List<? super Man> list = list1;Object obj = list1.get(1);三.注意事项1.List<Parent> 与 List<Child>没有⽗⼦关系也不是同⼀个关系1 List<Number> list = new ArrayList<Integer>(); //报错1public static class MyList<T> {2 List<T> list = new ArrayList<>();34// 把输⼊参数塞给⾃⼰,类似于⽣产操作5public void pushList(List<T> t) {6 list.addAll(t);7 }89// 把⾃⼰的内容塞给输⼊参数,类似于让输⼊参数做消费。
实验11泛型与集合
}
}
} System.out.println(integer);
}
}
}
package ex113;
import java.util.HashMap;
import java.util.Map;
public class Test {
public static void main(String[] args) {
import java.util.Set;
public class Student {
private String name;
private int score;
public Student(){
}
public Student(String name,int score) {
=name;
package ex113;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
return "";
}
}
(2)输入10个数字保存到List中,并按倒序显示出来。
package ex112;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
训练师脚本:如何使用集合和泛型集合
脚本_ 如何使用集合和泛型集合第1页PPT(训练师站在演讲台正中央,精神饱满,声音洪亮)大家好,今天我们来学习ArrayList和Hashtable 。
(切换PPT)第2页PPT数组有哪些局限呢,数组是固定大小的,不能伸缩。
虽然System.Array.Resize这个泛型方法可以重置数组大小,但是该方法是重新创建新设置大小的数组,用的是旧数组的元素初始化。
随后以前的数组就废弃!而集合却是可变长的。
数组要声明元素的类型,集合类的元素类型却是object。
数组可读可写不能声明只读数组。
集合类可以提供ReadOnly方法以只读方式使用集合。
数组要有整数下标才能访问特定的元素,然而很多时候这样的下标并不是很有用。
集合也是数据列表却不使用下标访问。
很多时候集合有定制的下标类型,对于队列和栈根本就不支持下标访问!(切换PPT)第3页PPT能否维护一个动态维护长度的集合呢?我们今天学习新的对象ArrayListList,在新增元素操作时,ArrayList的容量可以根据需要自动扩充,它的索引会根据你的扩展而重新进行分配和调整。
所有我们说ArrayList是动态的数组,可以动态的增加数组的长度,对应保存未知个数的一系列数据使用ArrayList非常方便。
(切换PPT)第4页PPTArrayList非常类似于数组,常有人称之为数组列表,其类来自于System.Collections 命名空间。
由于数组的容量是固定的,这样当我们想添加新的元素时,需要对数组重新进行定义。
为了避免这样的麻烦,我们提出了ArrayList。
(切换PPT)如何在ArrayList中添加元素呢,首先实例化对象,然后使用Add方法添加元素。
具体添加的方法ArrayList对象。
在调用对应的Add方法。
代码演示MySchool,讲解添加元素的方法。
(切换PPT)第6页PPT如何访问ArrayList的元素呢,通过指定索引下标,来取得对象,ArrayList第一个对象的索引是0,但是取到ArrayList里存放的数据后,不能直接赋值给Student对象,需要牵制进行类型转换。
泛型 集合 方法
泛型集合方法
嘿,朋友们!今天咱来聊聊“泛型”“集合”还有“方法”这些超厉害的东西!
就比如说泛型吧,你可以把它想象成一个超级灵活的盒子!哇塞,啥都能往里装!比如说,你要创建一个可以放各种不同类型东西的容器,这时候泛型就派上大用场啦!“为啥不直接指定类型呢?”你可能会问。
嘿嘿,那可不一样哦!就好比你有个盒子,今天你可能想装苹果,明天也许就想装橙子啦,泛型就让你的代码变得像孙悟空一样神通广大,能应对各种不同的情况!
再来说说集合。
集合就像是一个大部队,里面有好多好多成员呢!想象一下,你有一堆玩具,把它们放在一个箱子里,这箱子就是集合呀!可以轻松地对这些成员进行各种操作,增删改查,易如反掌!比如你有一群朋友的名单,你就可以用集合来管理他们,多方便!
还有方法呢,方法就像是一个个小魔法!当你需要做一件事情的时候,就调用对应的方法。
好比你饿了,就调用“做饭”这个方法,嘿,马上就能有吃的啦!
有一次,我和小伙伴在写代码的时候,就为了用泛型还是不用泛型争论起来。
我就觉得泛型简直太棒了,那么灵活,以后修改也方便呀!他还不太理解,我就给他详细解释,最后他恍然大悟!“原来泛型这么好啊!”他惊叹道。
总之,泛型、集合和方法,它们就像是代码世界里的黄金搭档,相互配合,让我们的编程之路变得更加精彩!它们能让我们的代码更简洁、更强大、更高效!这难道还不让人兴奋吗?所以呀,大家一定要好好掌握它们,让它们为我们的代码增光添彩!。
集合类和泛型
集合类和泛型⼀、集合类集合类和数组同是容器,有何不同?1.数组的长度是固定的,集合类的长度不固定2.数组存储基本类型,集合类存储对象,集合中不能存基本数据类型。
集合容器因为内部数据结构不同,有多种具体容器。
不断向上抽取,就形成了集合框架。
框架的顶层为Collection接⼝。
(⼀)LIst有序的Collection,此处有序是指数据存⼊的顺序。
特点:1.有序,存⼊和取出的顺序⼀致2.所有元素有⾓标(素引)LIst常见的特有⽅法有⼀个共同的特点,就是可以操作⾓标。
List list=new ArrayList();list.add("a1");list.add("a2");Iterator it=list.Iterator();while(it.hasNext()){Object obj=it.Next();if (obj.equals("a2")){list.add("a3");}}上述代码在执⾏时是错误的,因为List类的迭代器在使⽤时容器长度是固定的,不能在迭代时修改容器的长度。
要修改上述错误,我们不能在迭代时修改容器的长度,但是我们可以修改迭代器的长度。
可以使⽤Iterator接⼝的⼦接⼝ListIterator来实现。
代码如下:List list=new ArrayList();list.add("a1");list.add("a2");Iterator it=list.listIterator(); //使⽤列表迭代器while(it.hasNext()){Object obj=it.Next();if (obj.equals("a2")){it.add("a3"); //使⽤迭代器的插⼊⽅法}}List接⼝的有三种:(⼀般除了Vector外,都是不同步的。
如何使用泛型与泛型集合
如何使用泛型与泛型集合泛型是一种在编程中广泛应用的概念,它使得代码更灵活,可重用,并提高了代码的类型安全性。
在这篇文章中,我们将详细介绍什么是泛型以及如何使用泛型和泛型集合。
一、什么是泛型泛型是一种参数化类型的概念,它可以在类、接口、方法中使用。
它允许我们在编译时指定类型参数的具体类型,从而实现代码的重用和灵活性。
泛型的主要优点是:1.类型安全:使用泛型可以在编译时进行类型检查,避免运行时出现类型错误。
2.代码重用:泛型允许我们编写通用的算法和数据结构,在不同的类型上重用。
3.程序可读性提高:泛型代码可以提高程序的可读性和可维护性,因为代码中的类型信息更明确。
二、使用泛型1.声明泛型类在 Java 中,我们可以通过在类名后面使用尖括号插入类型参数来声明泛型类。
例如:```public class GenericClass<T>private T value;public T getValureturn value;}public void setValue(T value)this.value = value;}```上面的代码中,`GenericClass` 是一个泛型类,`<T>` 表示类型参数,可以在类的其他成员中使用这个类型参数。
2.使用泛型类使用泛型类时,需要通过实际类型替换类型参数。
例如:```GenericClass<Integer> genericClass = new GenericClass<>(;genericClass.setValue(10);System.out.println(genericClass.getValue(); // 输出 10```在上面的代码中,`GenericClass<Integer>` 表示实际的类型参数是`Integer`,所以 `setValue` 方法只接受 `Integer` 类型的参数。
.NET集合与泛型实验报告
实验报告课程名称.NET程序设计实验项目.NET集合与泛型专业计科班级 1 姓名学号指导教师实验成绩年月日一、实验目的(介绍本次实验的预期目标,完成的功能)1.初步掌握常用集合的创建和操作方法。
2.初步掌握索引器的定义与使用。
3.初步掌握泛型接口、泛型类、泛型属性和泛型方法的使用。
4.初步理解C#程序的特点。
二、实验过程(介绍实验中涉及的关键过程,如核心算法、数据结构等)1.编写一个电脑信息类:包括电脑的型号、价格和出厂日期。
程序应根据用户输入的型号来显示相应的电脑信息。
要求使用Hashtable对象存储电脑信息,并且按照型号排列输出,可以输入一个型号,程序检查判断集合中是否存在该型号的电脑,如果存在则显示具体信息。
并可以通过输入型号,删除某型号的电脑。
选择“文件”→“新建”→“项目”菜单命令,弹出“新建项目”对话框,在“模板”列表框中选择“控制台应用程序”。
首先创建一个Computer类,属性有电脑型号、价格、出厂日期,构造函数里赋值。
代码如图1-1所示:图1-1 Computer类源代码然后写一个静态方法,将电脑的详细信息再作为一个元素存在Hashtable 集合中。
代码如图1-2所示:图1-2 “输入电脑信息”方法源代码编写一个按型号排序电脑信息的静态方法,借助ArrayList的排序功能来实现,并且在屏幕打印出排序后的电脑信息。
如图1-3所示:图1-3 “按电脑型号排序”方法源代码编写一个查询电脑信息的静态方法,用户需要输入电脑型号,如果存在该型号的电脑就在屏幕打印该电脑的详细信息,如果不存在就提示用户“您所输入的型号不存在!”。
如图1-4所示:图1-4 “查询电脑信息”方法源代码编写一个删除电脑信息的静态方法,用户需要输入电脑型号,如果存在该型号的电脑就删除对应的电脑信息,并提示“该型号电脑信息已删除!”。
如果不存在就提示用户“您所输入的型号不存在!”。
如图1-5所示:图1-5 “删除电脑信息”方法源代码最后编写了一个菜单方法,用户可以在屏幕输入选项来执行相应功能。
集合及泛型的使用实验
集合及泛型的使用实验1、在main方法中运用ArrayList实现三人斗地主游戏中的发牌功能,具体如下:(1) 创建两个String类型数组,其中一个用于存储牌的花色("黑桃", "红桃", "梅花", "方块"四种花色),一个用于存储牌的数字("A", "2", "3", "4",..."K"十三种数字);(2) 创建一个ArrayList集合作为牌盒,先将不同花色不同数字的牌循环添加到集合中,最后别忘了将”大王”,”小王”也添加到ArrayList集合中;(3) 用Collections工具类的shuffle()方法洗牌。
如:Collections.shuffle(al) //al为一集合对象,该方法用于打乱al中元素的顺序(4) 创建三个ArrayList集合作为三个人的牌的集合,并循环发牌,共发51张牌,留三张底牌;(5) 打印出三个人的牌和集合中留的三张底牌。
mport java.util.ArrayList;import java.util.Collections;import java.util.List;public class PokerTest{public static void main(String[] args){ArrayList<String> box = new ArrayList<String>();String[] arr = {"黑桃","红桃","梅花","方块"};String[] arr2 = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};for (int i = 0; i < arr.length; i++){for (int j = 0; j < arr2.length; j++){box.add(arr[i]+arr2[j]);}box.add("大王");box.add("小王");}Collections.shuffle(box);ArrayList<String> zhangsan = new ArrayList<String>();ArrayList<String> lisi = new ArrayList<String>();ArrayList<String> me = new ArrayList<String>();for (int i = 0; i < box.size()-3; i++) {if(i%3 == 0) {zhangsan.add(box.get(i));}else if(i%3 == 1) {lisi.add(box.get(i));}else if(i%3 == 2) {me.add(box.get(i));}}System.out.println("zhangsan:"+zhangsan);System.out.println("lisi:"+lisi);System.out.println("me:"+me);System.out.println("底牌:");System.out.println(box.get(box.size()-1));System.out.println(box.get(box.size()-2));System.out.println(box.get(box.size()-3));}}2、按要求完成功能:(1) 设计Employee类,该类有成员变量(属性)工号—eno(String类型)、姓名—name(String类型)、年龄—age(int类型)、工资—salary(double类型)等,且为私有的,该类有对成员变量(属性)初始化的构造方法、设置成员变量(属性)的set方法以及获得成员变量(属性)的get方法;(2) 创建3个Employee对象,基本信息如下:工号姓名年龄工资001 张三 25 3000002 李四 27 4000003 王五 28 5500(3) 创建泛型的Map集合,保存以上三个Employee对象,其中Key为工号,value为Employee对象,对该Map进行遍历,输出所有职工信息。
Java程序设计课件:泛型与集合
List的常用方法
方法名 add(int index, E element) addAll(int index, Collection<?
extends E> c) get(int index)
indexOf(Object o)
lastIndexOf(Object o)
程序员使用集合框架提供的接口和类,在具体应 用时,不必考虑这些数据结构算法的实现细节, 只需用这些类创建对象并直接应用即可,这大大 提高了编程效率。
2023/12/28
8/35
6.2.1集合框架
核心接口主要有Collection、List、Set、 Queue、Deque和Map。
Collection
方法名 add(E e) clear() equals(Object o) isEmpty() size() iterator() hashCode() toArray() removeAll(Collection<?> c) retainAll(Collection<?> c) contains(Object o) remove(Object o) containsAll(Collection<?> c)
将集合 c中的所有元素添加到当前集合中,添加成功 返回true。
11/35 2023/12/28
Set 接口
Set接口用来描述数据结构中的集合。它具有 与 Collection 完全一样的接口,只是Set 不 保存重复的元素,向Set添加元素时,不保证 元素添加后与添加的顺序一致。实现它的常 用子类有TreeSet类和HashSet类。
remove(int index) set(int index, E element) listIterator()
如何使用泛型与泛型集合
//遍历
通过对象遍历
foreach (Object stuo in students)
{ Student stuForeach = (Student)stuo;
类型转换
} Console.WriteLine(); 打印对象的Name属性
演示示例2:MySchool
为什么使用HashTable
可以使用和数组类似的方式
输出结果
for (int i = 0; i < students.Count; i++) {
Student stuFor = (Student)students[i]; Console.WriteLine(); }
Scofield 张靓靓 周杰杰
foreach 方式
int Add(Object value) //添加一个对象到集合的末尾 返回索引
建立班级学员的集合
ArrayList students = new ArrayList();
Student scofield = new Student("Scofield", Genders.Male, 28, "越狱狱");
ArrayList是一个可动态维护长度的集合
新增元素 可删除元素 可访问单个元素
自动调整 索引
通过索引 访问
0
object
01
object
12
object
23
object
34
object
索引(下标)
ArrayList
ArrayList的初始化
引入System.Collections命名空间 实例化ArrayList对象
集合与泛型
Comparable接口 接口
parable接口中定义的compareTo()方法 用于提供对其实现类的对象进行整体排序所需的比 较逻辑。 实现类基于compareTo()方法的排序被称为自然排序。 而compareTo()方法被称为它的自然比较方法,具体 的排序原则可由实现类根据需要而定。 用户在重写compareTo()方法以制定比较逻辑时,需 要确保其与等价性判断方法equals()保 集合相关
HashSet Set Collection List TreeSet ArrayList Vector LinkedList HashMap Map Hashtable TreeMap java.util.Collections Enumeration StringTokenizer Properties java.util.Arrays Stack
java.util.Enumeration接口的作用与Iterator接口类似,但只提供 了遍历Vector和Hashtable(及其子类Properties)类型集合的功 能,且不支持集合元素的移除操作。
import java.util.*; public class TestEnumeration{ public static void main(String[] args){ Vector v = new Vector(); v.addElement(“Lisa”); v.addElement(“Billy”); v.addElement(“Mr. Brown”); Enumeration e = v.elements(); while(e.hasMoreElements()){ String value = (String)e.nextElement(); System.out.println(value); } } }
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验内容:
(1)定义一个泛型类Instrument<E >,其中包括一个泛型方法void play(E x)。
定义两种乐器类:Cello、Violin 可以进行演奏。
定义一个测试类进行测试。
package ex111;
public class Violin {
public String toString()
{
System.out.println("violin.........");
return "";
}
}
package ex111;
public class Test_Main {
public static void main(String[] args) {
instrument<Cello>model = new instrument<Cello>();
instrument<Violin>model1 = new instrument<Violin>();
Cello cello = new Cello();
Violin violin = new Violin();
model.play(cello);
model1.play(violin);
}
}
package ex111;
class instrument<E> {//泛型类
void play(E x)
{
x.toString();
}
}
package ex111;
public class Cello {
public String toString(){
System.out.println("cello.........");
return "";
}
}
(2)输入10 个数字保存到List 中,并按倒序显示出来。
package ex112;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Test{
public static void main(final String[] args) {
final List<Integer> integers = new ArrayList<Integer>();
final Scanner scanner = new Scanner(System.in);
for (int i = 1; i <= 3; i++) {
try {
System.out.println("输入第" + i + "个数吧");
final int input = Integer.parseInt(scanner.next());
integers.add(input);
}
catch (final Throwable e) {
System.err.println("这不是个数字,我可是超级程序");
i--;
continue;
}
}
//Collections.sort(integers);// 自然排
Collections.reverse(integers);// 倒排
for (final Integer integer : integers) {
System.out.println(integer);
}
}
} System.out.println(integer);
}
}
}
package ex113;
import java.util.HashMap;
import java.util.Map;
public class Test {
public static void main(String[] args) {
Map<String,Integer> map=new HashMap<String,Integer>();
Sort s=new Sort();
s.creatMap(map);
s.Sort(map);
}
}
(3)编写一个程序,把学生名和考试分数录入到Map 中,并按分数显示前三名学生的名字。
要求定义Student 类,封装学生名和考试分数 2 个属性及方法。
、TreeMap、TreeSet;
package ex113;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Student {
private String name;
private int score;
public Student(){
}
public Student(String name,int score) { =name;
this.score=score;
}
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
}
package ex113;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class Sort {
public void creatMap(Map<String,Integer> map){
Scanner input=new Scanner(System.in);
System.out.println("请输入学生人数");
int number=input.nextInt();
System.out.println("请输入学生姓名和分数:");
for(int i=0;i<number;i++){
Student stu=new Student(input.next(),input.nextInt());
map.put(stu.getName(),stu.getScore());
}
}
public void Sort(Map<String,Integer> map){
Collection<Integer> score = map.values();
Set<Integer> set=new HashSet<Integer>();
for(Integer s:score)
set.add(s);
List<Integer>list=new ArrayList(set);
Collections.sort(list);
Collections.reverse(list);
Set<String> name = map.keySet();
System.out.println("前三名学生的姓名是:");
int m=0;
for(Integer i:list){
m++;
if(m<=3){
for(String s:name)
{
if(i==map.get(s))
System.out.println("第"+m+"名:"+s);
}
}
}
}
}。