1 / 85

第 5 章 Java 的工具类

第 5 章 Java 的工具类. 5.1 Java 语言基础类库 5.2 Applet 类与 Applet 小程序 5.3 Java 的数组 5.4 集合类 5.5 Java 的字符串 5.6 日期和时间类. 学习提要. 1. 掌握 Java 语言的 Object 类、 Math 类、数据类型类、 System 类； 2. 掌握 Applet 的工作原理和 Applet 类的使用； 3. 掌握 Java 语言的集合框架类、 String 类及 StringBuffer 类、 Date 类及 Calendar 类的用法；.

ariane
Download Presentation

第 5 章 Java 的工具类

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 第5章 Java的工具类 5.1 Java语言基础类库 5.2 Applet类与Applet小程序 5.3 Java的数组 5.4 集合类 5.5 Java的字符串 5.6日期和时间类

  2. 学习提要 1. 掌握Java语言的Object类、Math 类、数据类型类、System类； 2.掌握Applet的工作原理和Applet类的使用； 3. 掌握Java语言的集合框架类、String类及StringBuffer类、Date类及Calendar类的用法；

  3. 5.1 Java语言基础类库 5.1.1 Object类 Object类是Java程序中所有类的直接或间接父类，也是类库中所有类的父类。Object类包含了所有Java类的公共属性，其中的主要方法有： （1）protected Object clone（） 生成当前对象的一个拷贝，并返回这个复制对象。 （2）public boolean equals（Object obj） 比较两个对象是否相同，是则返回true。 （3）public final Class getClass（） 获取当前对象所属的类信息，返回Class对象。

  4. （4） protected void finalize（） 定义回收当前对象时所需要完成的清理工作。 （5） public String toString（） 返回当前对象本身的有关信息，按字符串对象返回。 5.1.2 数据类型类

  5. Integer类的使用 （1）最大值和最小值的限定： 通过 MAX_VALUE域 和 MIN_VALUE域来设定 （2）生成Integer对象的构造函数： public Integer（int value）：通过int数据生成 public Integer（String s）：通过字符串生成 （3）数据类型转换方法： 将当前对象所对应的int量转换成其他基本数据类型的量，并返回转换后的值。 public double doubleValue( ) public int intValue( ) public long longValue( )

  6. (4) 字符串与int量相互转化的方法 1）public String toString（）方法 将当前Integer对象对应的int量转换成字符串； 2）public static int parseInt（String s）是类的方法，直接将字符串转化成int量。 例： int i= Integer.parseInt（”345”）； 3） public static Integer valueOf（String s）也是类的方法，可以将一个字符串转化成一个Integer对象。这个对象对应的int数值与字符串表示的数值一致。 int i= Integer.valueOf(”345”).intValue（）; 对其他数据类型： float f= Float. valueOf(”345”).floatValue（）；

  7. 5.1.3 Math类 Math类用来完成一些常用的数学运算,提供了一些static方法,使用时用类名做前缀就可以直接使用。如： k=Math.max(9,6); Math类的主要属性和方法： public final static double E; //数学常数e public final static double PI; //圆周率常量π public static double abs(double a); //绝对值 public static double exp(double a); //e的a幂 public static double floor(double a); //不大于a的最大整数 public static double log(double a); //自然对数

  8. public static double sqrt(double a); //开平方 public static double random(); //产生0到1之间的随机数 public static double pow(double a, double b ); //乘方 public static double rint(double a); //四舍五入 public static double IEEEremainder(double a, double b); // 求余数 (取模运算) public static float min(float a, float b); //求最小值 public static double max(double a, double b); //求最大值

  9. 例 TestMath.java //Math类与数据类型类的使用示例 import java.awt.Graphics; import java.applet.Applet; public class TestMath extends Applet { public void paint(Graphics g) { double a=Math.sqrt(4),d=Math.rint(3.5); double p=Math.pow(a,d),r=Math.random(),r1=Math.rint(r*10); double m=Math.min(4.6,7),n=Math.max(5.5,10.3), n1=Math.min(m,n); double mod=Math.IEEEremainder(12,5); // 取余数 int b=Float.valueOf("34.5").intValue(); //字符串转化成整数 float c=Float.valueOf("34.5").floatValue(); //字符串转化成浮点数 String s1=Integer.toString(b); //整数转化成字符串 String s2=Float.toString(c); //浮点数转化成字符串 String s3=Double.toString(a); //双精度数转化成字符串 String s4=Double.toString(p); String s5=Double.toString(r); String s6=Double.toString(r1); String s7=Double.toString(n1); String s8=Double.toString(mod); g.drawString("计算结果:",10,20); g.drawString(s1,10,40); g.drawString(s2,10,60); } }

  10. 5.1.4 System类 (1) 用System类获取标准输入/输出 标准输入 public static InputStream in; System的属性 标准输出 public static PrintStream out; 标准错误 public static PrintStream err; 例: char c; try { System.out.println("input a character:"); c=(char)System.in.read(); System.out.println("you have inputed: "+c); } catch(IOException e) { System.err.println(e.toString()); }

  11. (2) 用System类的方法获取系统信息及完成系统操作 1）public static long currentTimeMillis( ) 获取自1970年1月1日零时至当前系统时刻的毫秒数,通常用来比较两事件发生的先后时间差。 2） public static void exit (int status) 在程序的用户线程执行完之前，强制java虚拟机退出运行状态，并把状态信息status返回给虚拟机的操作系统，如：System.exit（0）；//非0为不正常退出 3) public static void gc( ) 强制调用Java虚拟机的垃圾回收功能，收集内存中丢失的垃圾对象所占用的空间，使其可以被重新加以利用。

  12. 5.2 Applet类与Applet小程序 5.2.1 Applet的基本工作原理 Java Applet是通过兼容Java的Internet浏览器来解释执行的。 编译好的Java字节码文件保存在特定的WWW服务器上，当浏览器遇到网页中嵌入的<applet>标记时，就会根据该Applet的名字和位置自动把字节码从服务器上下载到本地，并利用浏览器本身拥有的Java解释器直接执行该字节码。 由于有浏览器的支持，Applet不需要建立自己的主流程框架，也不需要有专门的图形界面。Applet需要做的是接收和响应浏览器发来的消息或事件。

  13. 5.2.2 Applet类 （1）Applet类简介 它是Java类库中一个重要的系统类，存在于java.applet包中。Applet类是Java的系统类java.awt.Panel的子类。 Panel属于一种容器，作用是： • 包容和排列其他的界面元素，如按钮、对话框等 • 响应它所包容范围之内的事件，或把事件向更高层次传递。 Applet在此基础上，还具有一些与浏览器和Applet生命周期有关的专门方法。

  14. （2）Applet类的主要方法 1）init（）方法 用来完成主类实例的初始化工作。如：创建和初始化程序运行所需要的对象实例，把图形或字体加载入内存，设置各种参数，加载图形和声音并播放等。 2）start（）方法 用来启动浏览器运行Applet的主线程。浏览器在调用init（）方法初始化Applet类的实例之后，接着会自动调用start（）方法，除此之外，start（）方法在Applet被重新启动时也会被系统自动调用。 3）stop（）方法 类似于start（）方法的逆操作，当用户浏览其它页面，或切换到其他系统应用时，浏览器将自动调用stop（）方法暂停执行Applet的主线程。

  15. 4）paint（）方法 主要用来在Applet的界面中显示文字、图形和其他界面元素，也是浏览器自动调用的方法。导致浏览器调用paint（）方法的事件主要有三种： • Applet被启动后，自动调用paint（）来重新描绘自己的界面； • Applet所在的浏览器窗口改变时，要求自动调用paint（）来重画界面； • Applet的其他方法被调用时，系统也会调用此方法。 paint（）方法有一个固定的参数——Graphics类的对象g。 Graphics类是用来完成一些较低级的图形用户界面操作的类，其中包括画圆、点、线、多边形及显示简单文本。

  16. init（）初始化 start（）启动 下载并实例化Applet 启动Applet 重新激活Applet Applet转入后台 stop（）中止 退出浏览器 5）destroy（）方法 当用户退出浏览器时，浏览器自动调用Applet 实例的destroy（）方法完成释放资源、关闭连接之类的操作。 Applet的生命周期与主要方法 destroy( )消亡

  17. 例 LifeCycle.java import java.applet.*; import java.awt.*; public class LifeCycle extends Applet //定义主类是Applet的子类 { //定义各计数器 private int InitCnt; private int StartCnt; private int StopCnt; private int DestroyCnt; private int PaintCnt; public LifeCycle() //构造函数 { //各计数器初始化 InitCnt = 0; StartCnt = 0; StopCnt = 0;DestroyCnt = 0;PaintCnt = 0; } public void init() { InitCnt++; // init()方法执行次数加一 } public void destroy() { DestroyCnt++; // destroy ()方法执行次数加一 } public void start() { StartCnt++; // start()方法执行次数加一 } public void stop() { StopCnt++; // stop()方法执行次数加一 }

  18. public void paint(Graphics g) { PaintCnt++; // paint()方法执行次数加一，画出坐标轴和标尺 g.drawLine(20,200,300,200); g.drawLine(20,200,20,20); g.drawLine(20,170,15,170); g.drawLine(20,140,15,140); g.drawLine(20,110,15,110); g.drawLine(20,80,15,80); g.drawLine(20,50,15,50); g.drawString("Init()",25,213); g.drawString("Start()",75,213); g.drawString("Stop()",125,213); g.drawString("Destroy()",175,213); g.drawString("paint()",235,213); //用矩形块高度显示各种方法被调用次数 g.fillRect(25,200-InitCnt*30,40,InitCnt*30); g.fillRect(75,200-StartCnt*30,40,StartCnt*30); g.fillRect(125,200-StopCnt*30,40,StopCnt*30); g.fillRect(175,200-DestroyCnt*30,40,DestroyCnt*30); g.fillRect(235,200-PaintCnt*30,40,PaintCnt*30); } }

  19. 5.2.3 HTML文件参数传递 Applet通过标记<APPLET> </APPLET>嵌入在HTML文件中， <APPLET> 至少需要包括三个参数：code、height、width。其它可选参数如下： （1）codebase 当Applet字节码文件的保存位置与所嵌入的HTML文档不同时，需要用此参数指明字节码文件的位置，该位置用URL格式表示。 （2）alt 如果浏览器不包含Java解释器，则不能执行字节码文件，此时可用alt参数告诉用户此浏览器不支持Java。 （3）align 表示Applet界面区域在浏览器窗口中的对齐方式。

  20. HTML文件可以通过标记<PARAM>向它所嵌入的Applet传递参数，使Applet的运行更加灵活。 HTML文件可以通过标记<PARAM>向它所嵌入的Applet传递参数，使Applet的运行更加灵活。 格式为： <PARAM name=xvalue=“这是一个字符串参数”> <PARAM>标记只能传递一个字符串类型的参数。 Applet利用getParamter（）方法来获取HTML传递来的参数，方法中用name指定的参数名。 格式： getParamter（”x”）

  21. 例：MyApplet_param.java import java.applet.Applet ; import java.awt.Graphics ; public class MyApplet_param extends Applet //定义主类 { private String s = "" ; //用于接收HTML参数的程序变量 private int x ; private int y ; public void init ( ) { s = getParameter ( "vstring" ) ; //接收HMTL中传递的参数 x = Integer.parseInt ( getParameter ( "x" ) ) ; y = Integer.parseInt ( getParameter ( "y" ) ) ; } public void paint ( Graphics g ) { if(s != null) g.drawString (s,x,y); } } ************************ <HTML> <BODY> <APPLET code = "MyApplet_param.class" height=200 width = 300> <PARAM name = vstring value = "我是来自HTML的参数"> <PARAM name = x value = 50> <PARAM name = y value = 100> </APPLET> </BODY></HTML>

  22. 5.3 Java的数组 5.3.1 声明数组 作用：声明数组的名称和数组所包含的元素的数据类型。 语法： 格式1： 数组元素类型 数组名[ ]； 格式2： 数组元素类型[ ] 数组名； 方括号[ ]是数组的标志，推荐采用格式2。 如：一维数组：int[] MyArray； D200_Card[ ] ArrayOf200Card; 二维数组： int[][] MyArray=new int[4][5]；

  23. 5.3.2 创建数组空间 定义好的数组必须创建数组空间后才可以使用。Java不支持变长的数组，所以在创建数组空间时必须指明数组的长度，以确定所开辟内存空间的大小。 语法格式： 数组名= new 数组元素类型[数组元素的个数] 例：MyArray=new int[10]； ArrayOf200Card=new D200_Card[15]; • 数组声明可以和创建数组空间同时完成，如： int[ ] MyArray=new int[10]； D200_Card [ ] ArrayOf200Card=new D200_Card[15]; 如果数组元素类型是基本数据类型，可以在创建数组空间的同时赋初值，如： int[ ] MyArray={1,2,3,4,5,6,7,8,9,10 }

  24. 5.3.3 创建数组元素并初始化 若数组元素类型为基本数据类型,本步骤可以省略. 对于以某一类对象为数组元素的数组，则必须创建并利用构造函数来初始化每个数组元素，一般用循环结构来完成。 例：for ( int i=0; i<ArrayOf200Card . length;i++) { ArrayOf200Card[i]= new D200_Card(200180000+i, 1111, 50.0, ”200”, 0.10); }

  25. Java中数组使用注意事项： （1）数组元素的下标从0开始，至数组元素个数-1个为止；下标必须是整型数或是可以转化成整型的量。 （2）所有数组都有一个属性length，存储的是数组元素的个数； （3）Java系统能自动检查数组下标是否越界。利用length-1作为下标的上界可以避免越界。 （4）Java中的数组实际上是一种隐含的“数组类”的实例，每个数组名是对该实例的一个引用，而数组的每个元素是对数组元素类实例的引用，所以新建数组时要有创建数组和创建数组元素两个步骤。

  26. 例：UseArray.java //使用数组显示图片： import java.applet.Applet; import java.awt.*; public class UseArray extends Applet { Image[] m_Images; //定义元素类型为Image的数组,保存图片 int totalImages=10; int currentImage=0; Label child; public void init() { child=new Label("还记得自己天真浪漫的童年吗？"); add(child); m_Images=new Image[totalImages]; //创建数组,分配内存空间 for(int i=0;i<totalImages;i++) m_Images[i]=getImage(getDocumentBase(), “images\\baby”+(i+1)+“.jpg”); //数组元素赋值 }

  27. public void start() { currentImage=0; } public void paint(Graphics g) { g.drawImage(m_Images[currentImage],50,50,this); currentImage=++currentImage%totalImages; try{ Thread.sleep(1000); //图片显示的时间间隔 } catch(InterruptedException e) { showStatus(e.toString()); } repaint(); } }

  28. 5.4 集合(Collections)类 5.4.1 集合类概述 集合(Collections)是能够存储其它对象的对象，所以也称容器。集合中只能存储对象，不能存储基本类型的数据。集合中的对象也称为元素; • 集合都能自动扩容,而且通过其上的迭代器(Iterator)可方便地对集合中包含的元素进行遍历。 • Java的Collections API包括Set、List、Queue集合接口，并且支持泛型操作。另外，Map是一类特殊的集合，与一般的集合不同，它包含的是Key-Value对。 对象4 对象1 对象2 对象3 对象n …….. Iterator

  29. Java Collections API中的核心集合接口 《接口》 Iterator +hasNext() +next() +remove() 《接口》 Iterable +itarator() 《接口》 Map +clear() +put() +remove() +containsKey() +containsValue() +get() +keyset() ….. 《接口》 Collection +add() +remove() +clear() +isEmpty() +size() +contains() 《接口》 SortedMap +comparator() +firstKey() +lastKey() ….. 《接口》 List +get() +set() +remove() 《接口》 Set 《接口》 Queue +element() +offer() +peek() +poll() 《接口》 SortedSet +compartor() +first() +last() ……………… 注意: Map接口和Collection接口的不同之处!!

  30. 5.4.2 Collection接口 Collection接口是集合接口树的根，它定义了集合操作的通用API。对Collection接口的某些实现类允许有重复元素，而另一些不允许有重复元素；某些是有序的而另一些是无序的。JDK中没有提供这个接口的实现，而是提供了它的子接口如Set和List的实现。

  31. 5.4.3 Set接口 Set中不能包含重复的元素。它是数学中“集合”概念的抽象，可以用来表示类似于学生选修的课程集合或机器中运行的进程集合等。

  32. 5.4.4 List接口 List是一个有序的集合，称为列表或序列。 List中可以包含重复的元素,可以通过元素在List中的索引序号访问相应的元素。 List接口的实现类有： ArrayList、LinkedList、Ｖector等。 实验3的例题3-4和3-5中用LinkedList对象来保存图书信息,且使用了泛型机制,请认真理解!!

  33. 5.4.5 Ｍap接口 Map实现键（key）到值(value)的映射。Map中不能包含重复的键值，每个键值最多只能映射到一个值。 HashTable就是一种常用的Map。 5.4.6 Queue接口 Queue（队列）中的元素采用FIFO的顺序进行入队、出队操作。 5.4.7 SortedSet和SortedMap接口 SortedSet和SortedMap分别是具有排序性能的Set和Map。

  34. Set接口的实现类--Hashset HashSet类是Set接口的实现类，它不保存元素的加入顺序，不含重复元素。 import java.util.*; class HashSetDemo { public static void main(String[] args) { HashSet hs = new HashSet(); //创建HashSet对象并向其中加入对象元素 hs.add("1"); hs.add("2"); hs.add("3"); hs.add("4"); hs.add("5"); hs.add("5"); Iterator it=hs.iterator(); //在HashSet上创建迭代器 while(it.hasNext()) //利用迭代器依次访问HashSet中的各个元素 { System.out.println(it.next()); } hs.remove("5"); System.out.println(hs); } }

  35. 从运行结果可以看出，(1)HashSet添加的顺序与迭代显示的结果顺序并不一致，这也验证了HashSet不保存元素加入顺序的特征。从运行结果可以看出，(1)HashSet添加的顺序与迭代显示的结果顺序并不一致，这也验证了HashSet不保存元素加入顺序的特征。 (2)不包含重复元素 运行结果如下： 3 5 2 4 1 [3，2，4，1]

  36. List接口的实现类--ArrayList (1) ArrayList类支持可随需要而增长的动态数组，它能够动态地增加或减小其大小。 (2)ArrayList以一个原始大小被创建，当超过了它的大小，将自动增大，当其中所包含的对象被删除后，就自动缩小。 (3)ArrayList类对于使用索引取出元素有较高的效率，它可以使用索引来快速定位对象。但元素做删除或插入速度较慢。

  37. ArrayListDemo.java Iterator it=c2.iterator(); //创建迭代器 while(it.hasNext()) //遍历操作 { Object obj=it.next(); System.out.println ("Iterator遍历c2 "+obj+"\t"); } } } import java.util.*; public class ArrayListDemo { public static void main(…) { Collection c1=new ArrayList(); for(int i=0;i<5;i++) { c1.add(new Integer(i)); } System.out.println("c1:"+c1); Collection c2=new ArrayList(); c2.addAll(c1); c2.remove(new Integer(3)); c2.add("The End"); System.out.println("c2:"+c2);

  38. 运行结果如下： C1:[0，1，2，3，4] C2:[0，1，2，4，The End] Iterator遍历C2 0 Iterator遍历C2 1 Iterator遍历C2 2 Iterator遍历C2 4 Iterator遍历C2 The End

  39. List的实现类--LinkedList (1)LinkedList提供了一个链接列表数据结构，通过连接指针来关联前后两个元素。对于那些需要做频繁插入或删除元素操作的应用来说，使用LinkedList类效率较高。 (2) LinkedList类定义了一些有用的方法用于访问和操作列表。 如：调用addFirst()方法可以在表头增加元素；调用addLast()方法可以在表尾增加元素；调用getFirst()方法可以获得第一个元素；调用getLast()方法可以得到最后一个元素；调用removeFirst()方法可以删除第一个元素；调用removeLast()方法可以删除最后一个元素。

  40. LinkedListDemo.java ll.remove("F"); ll.remove(2); System.out.println ("删除操作后ll的内容:"+ll); ll.removeFirst(); ll.removeLast(); System.out.println ("删除操作后ll的内容:"+ll); Object val=ll.get(2); ll.set(2,(String)val+ " Changed"); System.out.println ("修改操作后ll的内容:"+ll); } } import java.util.*; class LinkedListDemo { public static void main(String args[]) { LinkedList ll=new LinkedList(); ll.add("F"); ll.add("B"); ll.add("D"); ll.add("E"); ll.add("C"); System.out.println ("初始化后ll的内容:"+ll); ll.addLast("Z"); ll.addFirst("A0"); ll.add(1,"A1"); System.out.println ("添加操作后ll的内容:"+ll);

  41. 运行结果为： 初始化后ll的内容：[F，B，D，E，C] 添加操作后ll的内容：[A0，A1，F，B，D，E，C，Z] 删除操作后ll的内容：[A0，A1，D，E，C，Z] 删除操作后ll的内容：[A1，D，E，C] 修改操作后ll的内容：[A1，D，E Changed，C]

  42. List的实现类--Vector (1) Vector类提供了实现可增长数组的功能，它提供的访问方法支持类似数组运算和与Vector大小相关的运算。 (2)允许向量中增加、删除和插入元素，也允许测试向量的内容和检索指定的元素。 (3)Vector的常用方法包括: addElement(Object obj); insertElementAt(Object obj,int index); setElementAt(Object obj,int index); removeElement(Object obj); removeAllElements();

  43. VectorDemo.java System.out.println ("插入元素后的向量值:"+ v.toString()); v.setElementAt("three",3); v.setElementAt("four",4); System.out.println ("修改元素后的向量值:"+ v.toString()); v.removeAllElements(); System.out.println ("全部删除后的向量值:"+ v.toString()); } } import java.util.*; class VectorDemo { @SuppressWarnings("unchecked") public static void main(String[] args) { Vector v = new Vector(); v.addElement("one"); v.addElement("two"); v.addElement("three"); System.out.println ("向量初始值:"+v.toString()); v.insertElementAt("zero",0); v.insertElementAt("oop",3);

  44. 运行结果为： 向量初始值：[one，two，three] 插入元素后的向量值:[zero，one，two，oop，three] 修改元素后的向量值:[zero，one，two，three，four] 全部删除后的向量值:[ ]

  45. Map的实现类--HashMap HashMap是基于哈希表的Map接口的实现，它是使用频率最高的一个容器，它内部对“键”用Set进行散列存放，所以根据“键”去取“值”的效率很高. 它不保证映射的顺序，特别是它不保证该顺序是恒久不变的。

  46. HashMapDemo.java //该容器有其内部的排序方式，事实上是 //依据哈希算法来排的 Set set=hashmap.keySet(); //获取全部键，它的返回类型是Set Iterator iterator=set.iterator(); while(iterator.hasNext()) { System.out.print (hashmap.get(iterator.next())+";"); } } } import java.util.*; class HashMapDemo { public static void main(String args[]) { HashMap hashmap=new HashMap(); hashmap.put("0","c"); //用put方法向HashMap中以“键- //值”对的形式加入元素 hashmap.put("1","a"); hashmap.put("2","b"); hashmap.put("3","a"); System.out.println("HashMap:"); System.out.println(hashmap); 运行结果如下: HashMap: {3=a，2=b，0=c，1=a} a;b;c;a;

  47. Map的实现类--TreeMap TreeMap容器类比较特殊，它对“键”进行排序存放，所以放入TreeMap中的“键-值”对中的“键”必须是可“排序”的。

  48. TreeMapDemo.java while(iterator.hasNext()) { System.out.print(treemap.get(iterator.next())+";"); } } } import java.util.*; public class TreeMapDemo { public static void main(String args[]) { TreeMap treemap=new TreeMap(); treemap.put("0","d"); treemap.put("2","a"); treemap.put("1","b"); treemap.put("3","c"); System.out.println("TreeMap:"); System.out.println(treemap); //可以对键排序 System.out.println(treemap.firstKey()); //返回第一个键 Set set=treemap.keySet(); Iterator iterator=set.iterator(); 运行结果如下所示。 TreeMap: {0=d，1=b，2=a，3=c} 0 d;b;a;c;

  49. List的实现类--Stack 输出结果为： [0，1，2，3，4，5，6，7，8，9] 现在依次出栈 9 8 7 6 5 4 3 2 1 0 import java.util.*; class StackDemo { public static void main(String[] args) { Stack myStack = new Stack(); for(int i = 0; i < 10 ; i ++ ) { myStack.push(String.valueOf(i)); } //查看目前堆栈中的元素 System.out.println( myStack ); //依次出栈 System.out.println("现在依次出栈"); while (!myStack.empty()) { System.out.println(myStack.pop()); } } }

  50. Java泛型初步 (1)所谓泛型，就是在对类、方法等进行定义时，指定它为通用类型，也就是数据类型是任意的类型. 如:List<T> list=null. (2)具体调用时，要将通用类型转换成指定的类型来使用。 (3)泛型为提高大型程序的类型安全和可维护性带来了很大的潜力。 (4) 泛型语言特性只在JDK5.0及以后版本中可用。

More Related