锘??xml version="1.0" encoding="utf-8" standalone="yes"?>欧美激情精品久久久久久变态,日本在线三级,国产传媒在线观看http://www.aygfsteel.com/hayun/category/16892.htmlwelcome to my online log ! open java new world! Taste java charm........zh-cnThu, 01 Mar 2007 19:07:18 GMTThu, 01 Mar 2007 19:07:18 GMT60java鍩虹瀛︿範16(java.io.DataOutputStream)http://www.aygfsteel.com/hayun/articles/java16.html鑻?/dc:creator>鑻?/author>Sun, 12 Nov 2006 15:21:00 GMThttp://www.aygfsteel.com/hayun/articles/java16.html import聽 java.io.DataOutputStream;
import聽 java.io.FileOutputStream;

public聽class聽 MainClass聽 {

聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽 try聽 {

聽聽聽聽聽聽 FileOutputStream聽fos聽=聽 new聽 FileOutputStream ("fileName" ) ;

聽聽聽聽聽聽 DataOutputStream聽dos聽=聽 new聽 DataOutputStream ( fos ) ;

聽聽聽聽聽聽 dos.writeBoolean ( false ) ;
聽聽聽聽聽聽 dos.writeByte ( Byte.MAX_VALUE ) ;
聽聽聽聽聽聽 dos.writeChar ( 'A' ) ;
聽聽聽聽聽聽 dos.writeDouble ( Double.MAX_VALUE ) ;
聽聽聽聽聽聽 dos.writeFloat ( Float.MAX_VALUE ) ;
聽聽聽聽聽聽 dos.writeInt ( Integer.MAX_VALUE ) ;
聽聽聽聽聽聽 dos.writeLong ( Long.MAX_VALUE ) ;
聽聽聽聽聽聽 dos.writeShort ( Short.MAX_VALUE ) ;

聽聽聽聽聽聽 fos.close () ;
聽聽聽聽 }聽 catch聽 ( Exception聽e )聽{
聽聽聽聽聽聽 System.out.println ( "Exception:聽"聽 +聽e ) ;
聽聽聽聽 }
聽聽 }
}聽聽

]]>
java鍩虹瀛︿範15(java.io.DataInputStream)http://www.aygfsteel.com/hayun/articles/java15.html鑻?/dc:creator>鑻?/author>Sun, 12 Nov 2006 15:19:00 GMThttp://www.aygfsteel.com/hayun/articles/java15.html import聽 java.io.DataInputStream;
import聽 java.io.FileInputStream;

public聽class聽 MainClass聽 {

聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽 try聽 {

聽聽聽聽聽聽 FileInputStream聽fis聽=聽 new聽 FileInputStream ( "fileName.dat" ) ;

聽聽聽聽聽聽 //聽Create聽a聽data聽input聽stream
聽聽聽聽聽聽 DataInputStream聽dis聽=聽 new聽 DataInputStream ( fis ) ;

聽聽聽聽聽聽 //聽Read聽and聽display聽data
聽聽聽聽聽聽 System.out.println ( dis.readBoolean ()) ;
聽聽聽聽聽聽 System.out.println ( dis.readByte ()) ;
聽聽聽聽聽聽 System.out.println ( dis.readChar ()) ;
聽聽聽聽聽聽 System.out.println ( dis.readDouble ()) ;
聽聽聽聽聽聽 System.out.println ( dis.readFloat ()) ;
聽聽聽聽聽聽 System.out.println ( dis.readInt ()) ;
聽聽聽聽聽聽 System.out.println ( dis.readLong ()) ;
聽聽聽聽聽聽 System.out.println ( dis.readShort ()) ;

聽聽聽聽聽聽 //聽Close聽file聽input聽stream
聽聽聽聽聽聽 fis.close () ;
聽聽聽聽 }聽 catch聽 ( Exception聽e )聽{
聽聽聽聽聽聽 System.out.println ( "Exception:聽"聽 +聽e ) ;
聽聽聽聽 }
聽聽 }
}

]]>
java鍩虹瀛︿範14(java.io.File)http://www.aygfsteel.com/hayun/articles/java14.html鑻?/dc:creator>鑻?/author>Sun, 12 Nov 2006 15:17:00 GMThttp://www.aygfsteel.com/hayun/articles/java14.html import聽 java.io.File;

public聽class聽 MainClass聽 {
聽聽聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽 File聽f1聽=聽 new聽 File ( "MainClass.java" ) ;
聽聽 System.out.println ( "File聽Name:"聽 +聽f1.getName ()) ;
聽聽 System.out.println ( "Path:"聽 +聽f1.getPath ()) ;
聽聽 System.out.println ( "Abs聽Path:"聽 +聽f1.getAbsolutePath ()) ;
聽聽 System.out.println ( "Parent:"聽 +聽f1.getParent ()) ;
聽聽 System.out.println ( f1.exists ()聽 ?聽 "exists"聽 :聽 "does聽not聽exist" ) ;
聽聽 System.out.println ( f1.canWrite ()聽 ?聽 "is聽writeable"聽 :聽 "is聽not聽writeable" ) ;
聽聽 System.out.println ( f1.canRead ()聽 ?聽 "is聽readable"聽 :聽 "is聽not聽readable" ) ;
聽聽 System.out.println ( "is聽a聽directory"聽 +聽f1.isDirectory ()聽) ;
聽聽 System.out.println ( f1.isFile ()聽 ?聽 "is聽normal聽file"聽 :聽 "might聽be聽a聽named聽pipe" ) ;
聽聽 System.out.println ( f1.isAbsolute ()聽 ?聽 "is聽absolute"聽 :聽 "is聽not聽absolute" ) ;
聽聽 System.out.println ( "File聽last聽modified:"聽 +聽f1.lastModified ()) ;
聽聽 System.out.println ( "File聽size:"聽 +聽f1.length ()聽 +聽 "聽Bytes" ) ;
聽聽聽聽 }
}

]]>
java鍩虹瀛︿範13(java.io.BufferedOutputStream)http://www.aygfsteel.com/hayun/articles/java13.html鑻?/dc:creator>鑻?/author>Sun, 12 Nov 2006 15:14:00 GMThttp://www.aygfsteel.com/hayun/articles/java13.html import聽 java.io.BufferedOutputStream;
import聽 java.io.FileOutputStream;

public聽class聽 MainClass聽 {

聽聽 public聽static聽 void聽 main ( String聽args [])聽{

聽聽聽聽 try聽 {

聽聽聽聽聽聽 FileOutputStream聽fos聽=聽 new聽 FileOutputStream ("fileName" ) ;

聽聽聽聽聽聽 BufferedOutputStream聽bos聽=聽 new聽 BufferedOutputStream ( fos ) ;

聽聽聽聽聽聽 for聽 ( int聽 i聽=聽 0 ;聽i聽<聽 12 ;聽i++ )聽{
聽聽聽聽聽聽聽聽 bos.write ( i ) ;
聽聽聽聽聽聽 }

聽聽聽聽聽聽 bos.close () ;
聽聽聽聽 }聽 catch聽 ( Exception聽e )聽{
聽聽聽聽聽聽 System.out.println ( "Exception:聽"聽 +聽e ) ;
聽聽聽聽 }
聽聽 }
}


]]>
java鍩虹瀛︿範12(java.io.BufferedInputStream)http://www.aygfsteel.com/hayun/articles/java12.html鑻?/dc:creator>鑻?/author>Sun, 12 Nov 2006 15:11:00 GMThttp://www.aygfsteel.com/hayun/articles/java12.html import聽 java.io.BufferedInputStream;
import聽 java.io.FileInputStream;

public聽class聽 MainClass聽 {

聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽 try聽 {
聽聽聽聽聽聽 FileInputStream聽fis聽=聽 new聽 FileInputStream ("fileName" ) ;

聽聽聽聽聽聽 BufferedInputStream聽bis聽=聽 new聽 BufferedInputStream ( fis ) ;

聽聽聽聽聽聽 int聽 i;
聽聽聽聽聽聽 while聽 (( i聽=聽bis.read ())聽 !=聽- 1 )聽{
聽聽聽聽聽聽聽聽 System.out.println ( i ) ;
聽聽聽聽聽聽 }
聽聽聽聽聽聽 fis.close () ;
聽聽聽聽 }聽 catch聽 ( Exception聽e )聽{
聽聽聽聽聽聽 System.out.println ( "Exception:聽"聽 +聽e ) ;
聽聽聽聽 }
聽聽 }
}

]]>
java鍩虹瀛︿範11(java.util.Iterator)http://www.aygfsteel.com/hayun/articles/java11.html鑻?/dc:creator>鑻?/author>Sun, 12 Nov 2006 15:07:00 GMThttp://www.aygfsteel.com/hayun/articles/java11.html import聽 java.util.ArrayList;
import聽 java.util.Iterator;
import聽 java.util.ListIterator;

public聽class聽 MainClass聽 {
聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽 ArrayList<String>聽al聽=聽 new聽 ArrayList<String> () ;

聽聽聽聽 al.add ( "C" ) ;
聽聽聽聽 al.add ( "A" ) ;
聽聽聽聽 al.add ( "E" ) ;
聽聽聽聽 al.add ( "B" ) ;
聽聽聽聽 al.add ( "D" ) ;
聽聽聽聽 al.add ( "F" ) ;

聽聽聽聽 System.out.print ( "Original聽contents聽of聽al:聽" ) ;
聽聽聽聽 Iterator<String>聽itr聽=聽al.iterator () ;
聽聽聽聽 while聽 ( itr.hasNext ())聽{
聽聽聽聽聽聽 String聽element聽=聽itr.next () ;
聽聽聽聽聽聽 System.out.print ( element聽+聽 "聽" ) ;
聽聽聽聽 }
聽聽聽聽 System.out.println () ;

聽聽聽聽 ListIterator<String>聽litr聽=聽al.listIterator () ;
聽聽聽聽 while聽 ( litr.hasNext ())聽{
聽聽聽聽聽聽 String聽element聽=聽litr.next () ;
聽聽聽聽聽聽 litr.set ( element聽+聽 "+" ) ;
聽聽聽聽 }

聽聽聽聽 //聽Now,聽display聽the聽list聽backwards.
聽聽聽聽 System.out.print ( "Modified聽list聽backwards:聽" ) ;
聽聽聽聽 while聽 ( litr.hasPrevious ())聽{
聽聽聽聽聽聽 String聽element聽=聽litr.previous () ;
聽聽聽聽聽聽 System.out.print ( element聽+聽 "聽" ) ;
聽聽聽聽 }
聽聽 }
}


]]>
java鍩虹瀛︿範10(java.util.properties)http://www.aygfsteel.com/hayun/articles/java10.html鑻?/dc:creator>鑻?/author>Sun, 12 Nov 2006 15:03:00 GMThttp://www.aygfsteel.com/hayun/articles/java10.html import聽 java.util.Properties;

public聽class聽 MainClass聽 {
聽聽聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽聽聽聽聽 Properties聽prop聽=聽 new聽 Properties () ;
聽聽聽聽聽聽聽聽 prop.put ( "a" ,聽 "1" ) ;
聽聽聽聽聽聽聽聽 prop.put ( "b" ,聽 "2" ) ;
聽聽聽聽聽聽聽聽 prop.put ( "c" ,聽 "3" ) ;
聽聽聽聽聽聽聽聽 Properties聽book聽=聽 new聽 Properties ( prop ) ;
聽聽聽聽聽聽聽聽 book.put ( "A" ,聽 "4" ) ;
聽聽聽聽聽聽聽聽 book.put ( "B" ,聽 "5" ) ;
聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽 System.out.println ( "a聽"聽 +聽book.getProperty ( "a" )) ;
聽聽聽聽聽聽聽聽 System.out.println ( "A聽"聽 +聽book.getProperty ( "b" )) ;
聽聽聽聽聽聽聽聽 System.out.println ( "c:聽"聽 +聽book.getProperty ( "c" )) ;

聽聽聽聽聽聽聽聽 System.out.println ( "z:聽"聽 +聽book.getProperty ( "z" ,聽 "default" )) ;
聽聽聽聽 }
}

]]>
java鍩虹瀛︿範9(java.util.Vector)http://www.aygfsteel.com/hayun/articles/java9.html鑻?/dc:creator>鑻?/author>Sun, 12 Nov 2006 15:02:00 GMThttp://www.aygfsteel.com/hayun/articles/java9.html import聽 java.util.Vector;

public聽class聽 MainClass聽 {
聽聽 public聽static聽 void聽 main ( String聽args [])聽{

聽聽聽聽 //聽initial聽size聽is聽3,聽increment聽is聽2
聽聽聽聽 Vector<Integer>聽v聽=聽 new聽 Vector<Integer> ( 3 ,聽 2 ) ;

聽聽聽聽 System.out.println ( "Initial聽size:聽"聽 +聽v.size ()) ;
聽聽聽聽 System.out.println ( "Initial聽capacity:聽"聽 +聽v.capacity ()) ;

聽聽聽聽 v.addElement ( 1 ) ;
聽聽聽聽 v.addElement ( 2 ) ;

聽聽聽聽 System.out.println ( "First聽element:聽"聽 +聽v.firstElement ()) ;
聽聽聽聽 System.out.println ( "Last聽element:聽"聽 +聽v.lastElement ()) ;

聽聽聽聽 if聽 ( v.contains ( 3 ))
聽聽聽聽聽聽 System.out.println ( "Vector聽contains聽3." ) ;
聽聽 }
}


]]>
java鍩虹瀛︿範8(java.util.Hashtable)http://www.aygfsteel.com/hayun/articles/false8.html鑻?/dc:creator>鑻?/author>Sun, 05 Nov 2006 09:59:00 GMThttp://www.aygfsteel.com/hayun/articles/false8.html import聽 java.util.Hashtable;
import聽 java.util.Iterator;
import聽 java.util.Set;

public聽class聽 MainClass聽 {
聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽 Hashtable<String,聽Double>聽balance聽=聽 new聽 Hashtable<String,聽Double> () ;

聽聽聽聽 String聽str;
聽聽聽聽 double聽 bal;

聽聽聽聽 balance.put ( "A" ,聽 4.34 ) ;
聽聽聽聽 balance.put ( "B" ,聽 3.22 ) ;
聽聽聽聽 balance.put ( "C" ,聽 8.00 ) ;
聽聽聽聽 balance.put ( "D" ,聽 9.22 ) ;
聽聽聽聽 balance.put ( "E" ,聽- 9.08 ) ;

聽聽聽聽 Set<String>聽set聽=聽balance.keySet () ;

聽聽聽聽 Iterator<String>聽itr聽=聽set.iterator () ;
聽聽聽聽 while聽 ( itr.hasNext ())聽{
聽聽聽聽聽聽 str聽=聽itr.next () ;
聽聽聽聽聽聽 System.out.println ( str聽+聽 ":聽"聽 +聽balance.get ( str )) ;
聽聽聽聽 }

聽聽聽聽 System.out.println () ;

聽聽聽聽 bal聽=聽balance.get ( "A" ) ;
聽聽聽聽 balance.put ( "A" ,聽bal聽+聽 1000 ) ;
聽聽聽聽 System.out.println ( "A's聽new聽balance:聽"聽 +聽balance.get ( "A" )) ;
聽聽 }
}



]]>
java鍩虹瀛︿範7(java.util.Enumeration)http://www.aygfsteel.com/hayun/articles/false7.html鑻?/dc:creator>鑻?/author>Sun, 05 Nov 2006 09:57:00 GMThttp://www.aygfsteel.com/hayun/articles/false7.html import聽 java.util.Enumeration;

class聽 collection聽 implements聽 Enumeration聽 {
聽聽 private聽 int聽 count聽=聽 0 ;

聽聽 private聽 boolean聽 more聽=聽 true ;

聽聽 public聽 boolean聽 hasMoreElements ()聽{
聽聽聽聽 return聽 more;
聽聽 }

聽聽 public聽 Object聽nextElement ()聽{
聽聽聽聽 count++;
聽聽聽聽 if聽 ( count聽>聽 4 )
聽聽聽聽聽聽 more聽=聽 false ;
聽聽聽聽 return聽new聽 Integer ( count ) ;
聽聽 }
}

public聽class聽 MainClass聽 {
聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽 Enumeration聽e聽=聽 new聽 collection () ;
聽聽聽聽 while聽 ( e.hasMoreElements ())聽{
聽聽聽聽聽聽 System.out.println ( e.nextElement ()) ;
聽聽聽聽 }
聽聽 }
}


]]>
java鍩虹瀛︿範6(java.util.Date)http://www.aygfsteel.com/hayun/articles/false6.html鑻?/dc:creator>鑻?/author>Sun, 05 Nov 2006 09:56:00 GMThttp://www.aygfsteel.com/hayun/articles/false6.html import聽 java.text.DateFormat;
import聽 java.text.SimpleDateFormat;
import聽 java.util.Date;

public聽class聽 MainClass聽 {

聽聽 public聽static聽 void聽 main ( String []聽 a )聽 throws聽 Exception {

聽聽聽聽 DateFormat聽df聽=聽 new聽 SimpleDateFormat聽 ( "yyyy-MM-dd" ) ;

聽聽聽聽 Date聽d1聽=聽df.parse ( "2001-01-01" ) ;

聽聽聽聽 Date聽d2聽=聽df.parse ( "2000-01-01" ) ;

聽聽聽聽 String聽relation;
聽聽聽聽 if聽 ( d1.equals ( d2 ))
聽聽聽聽聽聽 relation聽=聽 "the聽same聽date聽as" ;
聽聽聽聽 else聽if聽 ( d1.before ( d2 ))
聽聽聽聽聽聽 relation聽=聽 "before" ;
聽聽聽聽 else聽if聽 ( d1.after ( d2 ))
聽聽聽聽聽聽 relation聽=聽 "after" ;
聽聽聽聽 System.out.println ( d1聽+聽 "聽is聽"聽 +聽relation聽+聽 '聽'聽 +聽d2 ) ;
聽聽 }
}


]]>
java鍩虹瀛︿範5(java.util.Collections)http://www.aygfsteel.com/hayun/articles/false5.html鑻?/dc:creator>鑻?/author>Sun, 05 Nov 2006 09:54:00 GMThttp://www.aygfsteel.com/hayun/articles/false5.html import聽 java.util.Collections;
import聽 java.util.Comparator;
import聽 java.util.LinkedList;
聽聽
public聽class聽 MainClass聽 {
聽聽 public聽static聽 void聽 main ( String聽args [])聽{聽聽
聽聽聽聽 LinkedList<Integer>聽ll聽=聽 new聽 LinkedList<Integer> () ;聽聽
聽聽聽聽 ll.add ( - 8 ) ;聽聽
聽聽聽聽 ll.add ( 20 ) ;聽聽
聽聽聽聽 ll.add ( - 20 ) ;聽聽
聽聽聽聽 ll.add ( 8 ) ;聽聽

聽聽聽聽 Comparator<Integer>聽r聽=聽Collections.reverseOrder () ;聽聽

聽聽聽聽 Collections.sort ( ll,聽r ) ;聽聽
聽聽
聽聽聽聽 System.out.print ( "List聽sorted聽in聽reverse:聽" ) ;聽聽聽聽聽聽
聽聽聽聽 for ( int聽 i聽:聽ll ){
聽聽聽聽聽聽 System.out.print ( i+聽 "聽" ) ;
聽聽聽聽 }聽
聽聽聽聽聽聽聽聽
聽聽聽聽 System.out.println () ;聽聽
聽聽
聽聽聽聽 Collections.shuffle ( ll ) ;聽聽
聽聽
聽聽聽聽 System.out.print ( "List聽shuffled:聽" ) ;聽聽聽聽聽聽
聽聽聽聽 for ( int聽 i聽:聽ll )聽
聽聽聽聽聽聽 System.out.print ( i聽+聽 "聽" ) ;聽聽

聽聽聽聽 System.out.println () ;聽聽
聽聽
聽聽聽聽 System.out.println ( "Minimum:聽"聽 +聽Collections.min ( ll )) ;聽聽聽聽聽聽
聽聽聽聽 System.out.println ( "Maximum:聽"聽 +聽Collections.max ( ll )) ;聽聽聽聽聽聽聽聽聽聽
聽聽 }聽聽
}



]]>
java鍩虹瀛︿範4(java.util.Calendar)http://www.aygfsteel.com/hayun/articles/false4.html鑻?/dc:creator>鑻?/author>Sun, 05 Nov 2006 09:52:00 GMThttp://www.aygfsteel.com/hayun/articles/false4.html import聽 java.util.Calendar;

public聽class聽 MainClass聽 {
聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽 String聽months []聽 =聽 {聽 "Jan" ,聽 "Feb" ,聽 "Mar" ,聽 "Apr" ,聽 "May" ,聽 "Jun" ,聽 "Jul" ,聽 "Aug" ,
聽聽聽聽聽聽聽聽 "Sep" ,聽 "Oct" ,聽 "Nov" ,聽 "Dec"聽 } ;

聽聽聽聽 Calendar聽calendar聽=聽Calendar.getInstance () ;

聽聽聽聽 System.out.print ( "Date:聽" ) ;
聽聽聽聽 System.out.print ( months [ calendar.get ( Calendar.MONTH )]) ;
聽聽聽聽 System.out.print ( "聽"聽 +聽calendar.get ( Calendar.DATE )聽 +聽 "聽" ) ;
聽聽聽聽 System.out.println ( calendar.get ( Calendar.YEAR )) ;

聽聽聽聽 System.out.print ( "Time:聽" ) ;
聽聽聽聽 System.out.print ( calendar.get ( Calendar.HOUR )聽 +聽 ":" ) ;
聽聽聽聽 System.out.print ( calendar.get ( Calendar.MINUTE )聽 +聽 ":" ) ;
聽聽聽聽 System.out.println ( calendar.get ( Calendar.SECOND )) ;

聽聽聽聽 calendar.set ( Calendar.HOUR,聽 10 ) ;
聽聽聽聽 calendar.set ( Calendar.MINUTE,聽 29 ) ;
聽聽聽聽 calendar.set ( Calendar.SECOND,聽 22 ) ;

聽聽聽聽 System.out.print ( "Updated聽time:聽" ) ;
聽聽聽聽 System.out.print ( calendar.get ( Calendar.HOUR )聽 +聽 ":" ) ;
聽聽聽聽 System.out.print ( calendar.get ( Calendar.MINUTE )聽 +聽 ":" ) ;
聽聽聽聽 System.out.println ( calendar.get ( Calendar.SECOND )) ;
聽聽 }
}


]]>
java鍩虹瀛︿範2(java.util.ArrayList)http://www.aygfsteel.com/hayun/articles/false3.html鑻?/dc:creator>鑻?/author>Sun, 05 Nov 2006 09:50:00 GMThttp://www.aygfsteel.com/hayun/articles/false3.html import聽 java.util.ArrayList;
import聽 java.util.Iterator;
import聽 java.util.ListIterator;

public聽class聽 MainClass聽 {
聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽 ArrayList<String>聽al聽=聽 new聽 ArrayList<String> () ;

聽聽聽聽 al.add ( "C" ) ;
聽聽聽聽 al.add ( "A" ) ;
聽聽聽聽 al.add ( "E" ) ;
聽聽聽聽 al.add ( "B" ) ;
聽聽聽聽 al.add ( "D" ) ;
聽聽聽聽 al.add ( "F" ) ;

聽聽聽聽 System.out.print ( "Original聽contents聽of聽al:聽" ) ;
聽聽聽聽 Iterator<String>聽itr聽=聽al.iterator () ;
聽聽聽聽 while聽 ( itr.hasNext ())聽{
聽聽聽聽聽聽 String聽element聽=聽itr.next () ;
聽聽聽聽聽聽 System.out.print ( element聽+聽 "聽" ) ;
聽聽聽聽 }
聽聽聽聽 System.out.println () ;

聽聽聽聽 ListIterator<String>聽litr聽=聽al.listIterator () ;
聽聽聽聽 while聽 ( litr.hasNext ())聽{
聽聽聽聽聽聽 String聽element聽=聽litr.next () ;
聽聽聽聽聽聽 litr.set ( element聽+聽 "+" ) ;
聽聽聽聽 }

聽聽聽聽 //聽Now,聽display聽the聽list聽backwards.
聽聽聽聽 System.out.print ( "Modified聽list聽backwards:聽" ) ;
聽聽聽聽 while聽 ( litr.hasPrevious ())聽{
聽聽聽聽聽聽 String聽element聽=聽litr.previous () ;
聽聽聽聽聽聽 System.out.print ( element聽+聽 "聽" ) ;
聽聽聽聽 }
聽聽 }


]]>
java鍩虹瀛︿範1(java.util.AbstractSet)http://www.aygfsteel.com/hayun/articles/false2.html鑻?/dc:creator>鑻?/author>Sun, 05 Nov 2006 09:47:00 GMThttp://www.aygfsteel.com/hayun/articles/false2.html import聽 java.io.Serializable;
import聽 java.util.AbstractSet;
import聽 java.util.ArrayList;
import聽 java.util.Collection;
import聽 java.util.Iterator;
import聽 java.util.Set;

public聽class聽 MainClass聽 {
聽聽 public聽static聽 void聽 main ( String聽args [])聽{
聽聽聽聽 Set聽map聽=聽 new聽 ArraySet () ;
聽聽聽聽 map.add ( "V" ) ;
聽聽聽聽 map.add ( "M" ) ;
聽聽聽聽 map.add ( "N" ) ;
聽聽聽聽 System.out.println ( map ) ;
聽聽 }
}

class聽 ArraySet聽 extends聽 AbstractSet聽 implements聽 Cloneable,聽Serializable聽 {

聽聽 private聽 ArrayList聽list;

聽聽 public聽 ArraySet ()聽{
聽聽聽聽 list聽=聽 new聽 ArrayList () ;
聽聽 }

聽聽 public聽 ArraySet ( Collection聽col )聽{
聽聽聽聽 list聽=聽 new聽 ArrayList () ;

聽聽聽聽 //聽No聽need聽to聽check聽for聽dups聽if聽col聽is聽a聽set
聽聽聽聽 Iterator聽itor聽=聽col.iterator () ;
聽聽聽聽 if聽 ( col聽 instanceof聽 Set )聽{
聽聽聽聽聽聽 while聽 ( itor.hasNext ())聽{
聽聽聽聽聽聽聽聽 list.add ( itor.next ()) ;
聽聽聽聽聽聽 }
聽聽聽聽 }聽 else聽 {
聽聽聽聽聽聽 while聽 ( itor.hasNext ())聽{
聽聽聽聽聽聽聽聽 add ( itor.next ()) ;
聽聽聽聽聽聽 }
聽聽聽聽 }
聽聽 }

聽聽 public聽 Iterator聽iterator ()聽{
聽聽聽聽 return聽 list.iterator () ;
聽聽 }

聽聽 public聽 int聽 size ()聽{
聽聽聽聽 return聽 list.size () ;
聽聽 }

聽聽 public聽 boolean聽 add ( Object聽element )聽{
聽聽聽聽 boolean聽 modified;
聽聽聽聽 if聽 ( modified聽=聽!list.contains ( element ))聽{
聽聽聽聽聽聽 list.add ( element ) ;
聽聽聽聽 }
聽聽聽聽 return聽 modified;
聽聽 }

聽聽 public聽 boolean聽 remove ( Object聽element )聽{
聽聽聽聽 return聽 list.remove ( element ) ;
聽聽 }

聽聽 public聽 boolean聽 isEmpty ()聽{
聽聽聽聽 return聽 list.isEmpty () ;
聽聽 }

聽聽 public聽 boolean聽 contains ( Object聽element )聽{
聽聽聽聽 return聽 list.contains ( element ) ;
聽聽 }

聽聽 public聽 void聽 clear ()聽{
聽聽聽聽 list.clear () ;
聽聽 }

聽聽 public聽 Object聽clone ()聽{
聽聽聽聽 try聽 {
聽聽聽聽聽聽 ArraySet聽newSet聽=聽 ( ArraySet )聽 super .clone () ;
聽聽聽聽聽聽 newSet.list聽=聽 ( ArrayList )聽 list.clone () ;
聽聽聽聽聽聽 return聽 newSet;
聽聽聽聽 }聽 catch聽 ( CloneNotSupportedException聽e )聽{
聽聽聽聽聽聽 throw聽new聽 InternalError () ;
聽聽聽聽 }
聽聽 }
}


]]>
java鍩虹瀛︿範3(java.util.Map)http://www.aygfsteel.com/hayun/articles/false1.html鑻?/dc:creator>鑻?/author>Sun, 05 Nov 2006 09:44:00 GMThttp://www.aygfsteel.com/hayun/articles/false1.html import聽 java.util.HashMap;
import聽 java.util.Iterator;
import聽 java.util.Map;

public聽class聽 MainClass聽 {

聽聽 public聽static聽 void聽 main ( String []聽 argv )聽{
聽聽聽聽 Map聽map聽=聽 new聽 HashMap () ;

聽聽聽聽 map.put ( "Adobe" ,聽 "Mountain聽View,聽CA" ) ;
聽聽聽聽 map.put ( "IBM" ,聽 "White聽Plains,聽NY" ) ;
聽聽聽聽 map.put ( "Learning聽Tree" ,聽 "Los聽Angeles,聽CA" ) ;

聽聽聽聽 Iterator聽k聽=聽map.keySet () .iterator () ;
聽聽聽聽 while聽 ( k.hasNext ())聽{
聽聽聽聽聽聽 String聽key聽=聽 ( String )聽 k.next () ;
聽聽聽聽聽聽 System.out.println ( "Key聽"聽 +聽key聽+聽 ";聽Value聽"聽 +聽 ( String )聽 map.get ( key )) ;
聽聽聽聽 }
聽聽 }
}


]]>
主站蜘蛛池模板: 洪洞县| 砀山县| 柳河县| 商丘市| 皋兰县| 鄱阳县| 韶关市| 惠东县| 瑞金市| 黄山市| 铁岭县| 永登县| 西宁市| 城口县| 秭归县| 山东| 宜州市| 丰城市| 柳林县| 安化县| 丰宁| 卢氏县| 榆中县| 大化| 奉化市| 荥经县| 二手房| 无极县| 松原市| 偃师市| 夏津县| 曲靖市| 安多县| 察雅县| 乌兰县| 贵阳市| 高台县| 留坝县| 巩留县| 雷山县| 宜都市|