锘??xml version="1.0" encoding="utf-8" standalone="yes"?>
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
)
;
聽聽聽聽
}
聽聽
}
}聽聽
]]>
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
)
;
聽聽聽聽
}
聽聽
}
}
]]>
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"
)
;
聽聽聽聽
}
}
]]>
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
)
;
聽聽聽聽
}
聽聽
}
}
]]>
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
)
;
聽聽聽聽
}
聽聽
}
}
]]>
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聽+聽
"聽"
)
;
聽聽聽聽
}
聽聽
}
}
]]>
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"
))
;
聽聽聽聽
}
}
]]>
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."
)
;
聽聽
}
}
]]>
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"
))
;
聽聽
}
}
]]>
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
())
;
聽聽聽聽
}
聽聽
}
}
]]>
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
)
;
聽聽
}
}
]]>
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
))
;聽聽聽聽聽聽聽聽聽聽
聽聽
}聽聽
}