一个File¾cȝš„对象åQŒè¡¨½CÞZº†¼‚ç›˜ä¸Šçš„æ–‡äšg或目录ã€?br /> File¾cÀLä¾›äº†ä¸Žåã^台无关的æ–ÒŽ³•æ¥å¯¹¼‚ç›˜ä¸Šçš„æ–‡äšg或目录进行操作ã€?/p>

import java.io.*;
class FileTest
{
 public static void main(String[] args) throws Exception
 {
  //File f = new File("1.txt");
  //f.createNewFile();   创徏文äšg
  //f.mkdir(); 创徏文äšgå¤?br />  //File f = new File("F:\\Java Develop\\1.txt");//使用¾lå¯¹è·¯å¾„
  //f.createNewFile();
  /*
  *WINDOWSòq›_°ä¸‹æœ‰ç›˜ç¬¦åQŒLINUX下是没有çš?br />  *考虑到JAVA语言的åã^台性，所有用分隔½W¦seperator/seperatorChar
  */
  /*
  File fDir = new File(File.separator);//创徏了当前的根目�br />  String strFile = "Java Develop"+File.separator+"1.txt";
  File f = new File(fDir,strFile);
  f.createNewFile();
  //f.delete();
  f.deleteOnExit();
  Thread.sleep(3000);
  */
  /*
  for(int i=0;i<5;i++)
  {
   File.createTempFile("linshi",".tmp");
   f.deleteOnExit();
  }
  Thread.sleep(3000);
  */
 
  File fDir = new File(File.separator);
  String strFile ="Java Develop"+File.separator;
  File f = new File(fDir,strFile);
  //æ–‡äšg˜q‡æ×oå™?br />  String[] names = f.list(new FilenameFilter()
  {
   public boolean accept(File dir,String name)
   {
    return name.indexOf(".java")!=-1;
   }
  });
  for(int i=0;i<names.length;i++)
  {
   System.out.println(names[i]);
  }
 }
}

            ‹¹å¼I/0

 ‹¹?Stream)是字节的源或目的ã€?br /> 两种基本的流æ˜? 输入‹¹?Input Stream)和输出流(Output Stream)。从从中è¯Õd‡ºä¸€¾pÕdˆ—字节çš?br /> 对象¿UîCؓ输入‹¹ã€‚而能向其中写入一¾pÕdˆ—字节的对象称ä¸ø™¾“出流ã€?/p>

           ‹¹çš„分类
 
 节点‹¹? 从特定的地方è¯Õd†™çš„流¾c»ï¼Œä¾‹å¦‚åQšç£ç›˜æˆ–一块内存区域ã€?br /> ˜q‡æ×o‹¹? 使用节点作äؓ输入或输出。过滤流使用的是一个已¾lå­˜åœ¨çš„输入‹¹æˆ–输出‹¹è¿žæŽ¥åˆ›å»ºçš„ã€?br /> (如下å›?

 InputStream(一个抽象的基类)
 .三个基本的读写方æ³?br />  abstract int read(): è¯Õd–一个字节数据，òq¶è¿”回到数据åQŒå¦‚果返å›?1åQŒè¡¨½Cø™¯»åˆîCº†è¾“å…¥‹¹çš„
                       末尾ã€?br />  int read(byte[] b):  ž®†æ•°æ®è¯»å…¥ä¸€ä¸ªå­—节数¾l„，同时˜q”回实际è¯Õd–的字节数。如果返å›?1åQ?br />                       表示è¯Õdˆ°äº†è¾“入流的末ž®¾ã€?br />  int read(byte[] b,int off,int len): ž®†æ•°æ®è¯»å…¥ä¸€ä¸ªå­—节数¾l„，同时˜q”回是实际读取的å­?br />                       节数。如果返å›?1åQŒè¡¨½Cø™¯»åˆîCº†è¾“å…¥‹¹çš„末尾。off指定在数¾l„b中存æ”?br />                       数据的è“v始偏¿UÖM½¾|®ï¼›len指定è¯Õd–的最大字节数ã€?br /> 其他的方æ³?br />  long-skip(long n): 在输入流中蟩˜q‡n个字节，òq¶è¿”回实际蟩˜q‡çš„字节数ã€?br />  int available():   ˜q”回在不发生é˜Õd¡žçš„情况下åQŒå¯è¯Õd–的字节数ã€?br />  void close():      关闭输入‹¹ï¼Œé‡Šæ”¾å’Œè¿™ä¸ªæµç›¸å…³çš„ç³»¾lŸèµ„源ã€?br />  void mark(int reqdlimit): 在输入流的当前位¾|®æ”¾¾|®ä¸€ä¸ªæ ‡è®ŽÍ¼Œå¦‚æžœè¯Õd–的字节数多余
                     readlimit讄¡½®çš„å€û|¼Œåˆ™æµå¿½ç•¥˜q™ä¸ªæ ‡è®°ã€?br />  void reset():      ˜q”回åˆîC¸Šä¸€ä¸ªæ ‡è®°ã€?br />  boolean markSupported(): ‹¹‹è¯•å½“前是否支持markå’Œresetæ–ÒŽ³•ã€‚如果支持返回trueåQŒåä¹‹falseã€?/p>

         java.io包中的InputStream的类层次 (下图)

OutputStream

 三个基本的写æ–ÒŽ³•
 abstract void write(int b): 往输出‹¹ä¸­å†™å…¥ä¸€ä¸ªå­—èŠ?br /> void write(byte[] b):       往输出‹¹ä¸­å†™å…¥æ•°ç»„b中的所有字èŠ?br /> void writte(byte[] b,int off,int len): 往输出‹¹ä¸­å†™å…¥æ•°ç»„b中从偏移量off开始的lenä¸?br />                             字节的数æ?br /> 其它æ–ÒŽ³•
 void flush(): åˆäh–°è¾“出‹¹ï¼Œå¼ºåˆ¶¾~“冲åŒÞZ¸­çš„输出字节被写出
 void close(): 关闭输出‹¹ï¼Œé‡Šæ”¾å’Œè¿™ä¸ªæµç›¸å…³çš„ç³»¾lŸèµ„æº?/p>

        java.io包中OutputStream的类层次(如下�

基本的流¾c?/p>

 FileInputStream和FileOutputStream
 节点‹¹ï¼Œç”¨äºŽä»Žæ–‡ä»¶ä¸­è¯Õd–或往文äšg中写入字节流。如果在构造FileOutputStreamæ—Óž¼Œæ–‡äšg已经
 存在åQŒåˆ™è¦†ç›–˜q™ä¸ªæ–‡äšgã€?br /> 
 BufferedInputStream和BufferedOutputStream
 ˜q‡æ×o‹¹ï¼Œéœ€è¦ä‹É用已¾lå­˜åœ¨çš„节点‹¹æ¥æž„造，提供带缓冲的è¯Õd†™åQŒæé«˜äº†è¯Õd†™çš„效率ã€?/p>

 DataInputStream和DataOutputStream
 ˜q‡æ×o‹¹ï¼Œéœ€è¦ä‹É用已¾lå­˜åœ¨çš„节点‹¹æ¥æž„é€?提供了读写Java中的基本数据¾cÕdž‹çš„功能ã€?/p>

 PipedInputStream和PipedOutputStream
 ½Ž¡é“‹¹ï¼Œç”¨äºŽ¾U¿ç¨‹é—´çš„通信。一个线½E‹çš„PipedInputStream对象从另一个线½E‹çš„PipedOutputStream
 对象è¯Õd–输入。要使管道流有用åQŒå¿…™åÕdŒæ—¶æž„造管道输入流和管道输出流ã€?/p>

code:
import java.io.*;
class StreamTest
{
 public static void main(String[] args)throws Exception
 {
  /*
  int data;
  while((data=System.in.read())!=-1)  //从标准设备读取数�br />  {
   System.out.write(data);//从标准设备输出数�br />  }
  */
  //输出‹¹å†™æ•°æ®,只需要关闭尾端的‹¹å°±å¯ä»¥äº†ï¼Œå› äØ“fos˜qžæŽ¥åˆîCº†bos
  FileOutputStream fos = new FileOutputStream("1.txt");
  //fos.write("());
  //fos.close();
  BufferedOutputStream bos = new BufferedOutputStream(fos);
  //bos.write("http//www.baidu.com".getBytes());
  //bos.flush();
  //bos.close();
  DataOutputStream dos=new DataOutputStream(bos); //˜qžæŽ¥åˆîCº†boså’Œfis
  byte b=3;
  int i=78;
  char ch='a';
  float f=4.5f;
  dos.writeByte(b);
  dos.writeInt(i);
  dos.writeChar(ch);
  dos.writeFloat(f);
  dos.close(); //必须调用flush()或者close()不然不会写入¼‹¬ç›˜
 
  //输入‹¹è¯»æ•°æ®
  FileInputStream fis=new FileInputStream("1.txt");
  BufferedInputStream bis = new BufferedInputStream(fis);
  //byte[] buf=new byte[100];
  //int len=fis.read(buf);
  //int len=bis.read(buf);
  //System.out.println(new String(buf,0,len));
  //fis.close();
  //bis.close();
  //注意è¯Õd–的顺序要和写的顺序一æ ?br />  DataInputStream dis = new DataInputStream(bis);
  System.out.println(dis.readByte());
  System.out.println(dis.readInt());
  System.out.println(dis.readChar());
  System.out.println(dis.readFloat());
  dis.close(); 
 
 }
}

 java.io包中Reader的类层次(如下�

 java.io包中Writer的类层次(如下�


 code:
import java.io.*;
class StreamTest
{
 public static void main(String[] args)throws Exception
 {
  /*
  FileOutputStream fos = new FileOutputStream("1.txt");
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  BufferedWriter bw = new BufferedWriter(osw);
 
  bw.write("  bw.close();
 
  FileInputStream fis = new FileInputStream("1.txt");
  InputStreamReader isr = new InputStreamReader(fis);
  BufferedReader br = new BufferedReader(isr);
  System.out.println(br.readLine());
  br.close();
  */
  //InputStreamReader/OutputStreamWriter是一个中间过度类,˜qžæŽ¥å­—符和字½W¦ä¸²
  InputStreamReader isr = new InputStreamReader(System.in);
  BufferedReader br = new BufferedReader(isr);
  String strLine;
  while((strLine=br.readLine())!=null)
  {
   System.out.println(strLine);
  }
  br.close();
 }
}

            字符集的¾~–码

 ASCII(American Standard Code for Information Interchange,¾ŸŽå›½ä¿¡æ¯äº’换标准代码),是基
 于常用的英文字符的一套电脑编码系¾lŸã€‚我们知道英文中¾lå¸¸ä½¿ç”¨çš„å­—½W¦ï¼Œæ•°å­—½W¦å·è¢«è®¡½Ž—机
 处理旉™ƒ½æ˜¯ä»¥äºŒè¿›åˆ¶ç¼–码的形式出现(bit)二进制数对应。其最高位æ˜?åQŒç›¸åº”的十进制数æ˜?-127
 如，数字1åQŒæœ‰ä¸€äº›åˆ¶è¡¨ç¬¦å’Œå…¶ä»–符åïL»„成。ASCII是现金最通用的单字节¾~–码¾pȝ»Ÿã€?/p>

 GB2312åQ?GB2312码是中华人民共和国国家汉字信息交换用¾~–码åQŒå…¨¿U°ã€Šä¿¡æ¯äº¤æ¢ç”¨æ±‰å­—¾~–码å­?br /> ½W¦é›†-基本集》。主要用于给每一个中文字½W¦æŒ‡å®šç›¸åº”çš„æ•°å­—åQŒä¹Ÿž®±æ˜¯˜q›è¡Œ¾~–码。一个中文字½W?br /> 用两个字节的数字来表½Cºï¼Œä¸ÞZº†å’ŒASCII码有所区别åQŒå°†ä¸­æ–‡å­—符每一个字节的最高位¾|®éƒ½ç”?
 来表½Cºã€?/p>

 GBKåQšäؓ了对更多的字½W¦è¿›è¡Œç¼–码，国家又发布了新的¾~–码¾pȝ»ŸGBKåQˆGBKçš„K是“扩展”的汉语
 拼音的第一个字母）。在新的¾~–码¾pȝ»Ÿé‡Œï¼Œé™¤äº†å®Œå…¨å…¼å®¹GB2312外，˜q˜å¯¹¾Jä½“中文åQŒä¸€äº›ä¸å¸¸ç”¨
 的汉字和许多½W¦å·˜q›è¡Œäº†ç¼–码ã€?/p>

 ISO-8859-1åQšæ˜¯è¥¿æ–¹å›½å®¶æ‰€ä½¿ç”¨çš„å­—½W¦ç¼–码集åQŒæ˜¯ä¸€¿Uå•å­—节的字½W¦é›†åQŒè€Œè‹±æ–‡å®žé™…上只用了其
 中数字小�28的部分�/p>

 Unicode: ˜q™æ˜¯ä¸€¿Ué€šç”¨çš„å­—½W¦é›†åQŒå¯¹æ‰€æœ‰è¯­­a€çš„文字进行统一¾~–码åQŒå¯¹æ¯ä¸€ä¸ªå­—½W¦éƒ½é‡‡ç”¨2个字èŠ?br /> 来表½Cºï¼Œå¯¹äºŽè‹±æ–‡å­—符采取前面加â€?”字节的½{–略实现½{‰é•¿å…¼å®¹ã€‚如"a"çš„ASCII码äØ“0x61,
 UNICODEž®×ƒØ“0x00,0x61ã€?/p>

 UTF-8: Elight-bit UCS Transformation Format,(UCS,Universal Character Set,通用字符�
 UCS是所有其他字½W¦é›†æ ‡å‡†çš„一个超é›?。一ä¸?位的ASCII码å€û|¼Œå¯¹åº”çš„UTF码是一个字节，如果
 字符æ˜?x0000åQŒæˆ–åœ?x0080ä¸?x007f之间åQŒå¯¹åº”çš„UTF码是两个字节åQŒå¦‚果字½W¦åœ¨0x0800ä¸?xffff
 之间åQŒå¯¹åº”çš„UTF码是三个字节ã€?br /> ¾~–码åQšå°†ä¸€ä¸ªUnicode码è{换äؓ本地字符表示的过½E‹äØ“¾~–码ã€?br />  解码åQšå°†ä¸€ä¸ªå­—节è{换äؓ一个字½W¦ï¼ˆç”¨Unicode表示åQ‰ï¼Œ˜q™ä¸ª˜q‡ç¨‹å«è§£ç ã€?br />        [½Ž€å•çš„说去获取一个Unicode码就是解码]
 code:

import java.util.*;
import java.nio.charset.*;
class CharsetTest
{
 public static void main(String[] args)throws Exception
 {
  /*
  Map m=Charset.availableCharsets();
  Set names=m.keySet();
  Iterator it =names.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  Properties pps=System.getProperties();
  //pps.list(System.out);
  pps.put("file.encoding","ISO-8859-1");
  int data;
  byte[] buf=new byte[100];
  int i=0;
  while((data=System.in.read())!='q')
  {
   buf[i]=(byte)data;
   i++;
  }
  String str=new String(buf,0,i);
  //String strGBK=new String(str.getBytes("ISO-8859-1"),"GBK");
  //System.out.println(strGBK);
  System.out.println(str);
 }
}

 

     RandomAccessFile

  RandomAccessFile¾cÕdŒæ—¶å®žçŽîCº†DataInputå’ŒDataOutput接口åQŒæä¾›äº†å¯ÒŽ–‡ä»‰™šæœºå­˜å–的功能åQ?br />  利用˜q™ä¸ª¾cÕd¯ä»¥åœ¨æ–‡äšgçš„ä“Q何位¾|®è¯»å–或写入数据ã€?br />  RandomAccessFile¾cÀLä¾›äº†ä¸€ä¸ªæ–‡ä»¶æŒ‡é’ˆï¼Œç”¨æ¥æ ‡å¿—要进行读写操作的下一位数据的位置ã€?

 
 code:
import java.io.*;
class RandomFileTest
{
 public static void main(String[] args)throws Exception
 {
  Student s1 = new Student(1,"zhangsan",98.5);
  Student s2 = new Student(2,"lisi",90.5);
  Student s3 = new Student(3,"wangwu",78.5);
 
  RandomAccessFile rsf=new RandomAccessFile("student.txt","rw");  //存取模式rw
  s1.WriteStudent(rsf);
  s2.WriteStudent(rsf);
  s3.WriteStudent(rsf);
 
  Student s =new Student();
  rsf.seek(0); //把文件指针移到文仉™¦–
  for(long i=0;i<rsf.length();i=rsf.getFilePointer())
  {
   s.ReadStudent(rsf);
   System.out.println(s.num+":"+s.name+":"+s.score);
  }
  rsf.close();
 }
}

class Student
{
 int num;
 String name;
 double score;
 Student()
 {
 
 }
 Student(int num,String name,double score)
 {
  this.num=num;
  this.name=name;
  this.score=score;
 }
 public void WriteStudent(RandomAccessFile raf)throws Exception
 {
  raf.writeInt(num);
  raf.writeUTF(name);
  raf.writeDouble(score);
 }
 public void ReadStudent(RandomAccessFile raf)throws Exception
 {
  raf.readInt();
  raf.readUTF();
  raf.readDouble(); 
 }
}

           对象序列�/p>

 .ž®†å¯¹è±¡è{换äؓ字节‹¹ä¿å­˜è“v来，òq¶åœ¨æ—¥åŽ˜q˜åŽŸ˜q™ä¸ªå¯¹è±¡åQŒè¿™¿Uæœºåˆ¶å«åšå¯¹è±¡åºåˆ—化ã€?br /> .ž®†ä¸€ä¸ªå¯¹è±¡ä¿å­˜åˆ°æ°æ€¹…存储讑֤‡ä¸Šç§°ä¸ºæŒ¾l­æ€§ã€?br /> .一个对象要惌™ƒ½å¤Ÿå®žçŽ°åºåˆ—化åQŒå¿…™åÕd®žçŽ°Serializable接口或Externalizable接口ã€?br /> .当一个对象被序列化时åQŒåªä¿å­˜å¯¹è±¡çš„非静态成员变量，不能保存ä»ÖM½•çš„成员变量和静态的
  成员变量ã€?br /> .如果一个对象的成员变量是一个对象，那么˜q™ä¸ªå¯¹è±¡çš„数据成员也会被保存ã€?br /> .如果一个可序列化的对象包含å¯ÒŽŸä¸ªä¸å¯åºåˆ—化的对象的引用åQŒé‚£ä¹ˆæ•´ä¸ªåºåˆ—化操作ž®†ä¼šå¤ÞpÓ|åQ?br />  òq¶ä¸”会抛å‡ÞZ¸€ä¸ªNotSerializableException。我们可以将˜q™ä¸ªå¼•ç”¨æ ‡è®°ä¸ºtransient,那么对象
  仍然可以序列化�/p>

 code:
import java.io.*;
class ObjectSerialTest
{
 public static void main(String[] args)throws Exception
 {
  Employee e1 = new Employee("zhangsan",20,2800.50);
  Employee e2 = new Employee("lisi",22,25000.50);
  Employee e3 = new Employee("wangwu",23,12800.50);
  Employee e4 = new Employee("blovesaga",22,3800.50);
 
  FileOutputStream fos=new FileOutputStream("employee.txt");
  ObjectOutputStream oos=new ObjectOutputStream(fos);
  oos.writeObject(e1);
  oos.writeObject(e2);
  oos.writeObject(e3);
  oos.writeObject(e4);
  oos.close();
 
  FileInputStream fis = new FileInputStream("employee.txt");
  ObjectInputStream ois =new ObjectInputStream(fis);
  Employee e;
  for(int i=0;i<4;i++)
  {
   e=(Employee)ois.readObject();
   System.out.println(e.name+":"+e.age+":"+e.salary);
  }
  ois.close();
 }
}

class Employee implements Serializable
{
 String name;
 int age;
 double salary;
 transient Thread t1 =new Thread();
 Employee(String name,int age,double salary)
 {
  this.name=name;
  this.age=age;
  this.salary=salary;
 }
 //可以写private void readObject()æ–ÒŽ³•æ¥æŽ§åˆ¶æˆ‘们自己想要实现的
 private void writeObject(java.io.ObjectOutputStream oos)throws Exception
 {
  //例如我们自己写想要显½Cºçš„™åºåºå’Œé‚£äº›éœ€è¦æ˜¾½C?br />  oos.writeInt(age);
  oos.writeUTF(name);
  System.out.println("Write Object");
 }
 private void readObject(java.io.ObjectInputStream ois)throws Exception
 {
  //按照写入的顺序来è¯Õd–
  age=ois.readInt();
  name=ois.readUTF();
  System.out.println("Read Object");
 }
}

所谓框架就是一个类库的集合。集合框架就是一个用来表½Cºå’Œæ“ä½œé›†åˆçš„统一框架åQŒåŒ…含了实现
集合的接口和¾c…R€?br /> 
 集合框架中的接口

 .Collection: 集合层次中的æ ÒŽŽ¥å£ï¼ŒJDK没有提供˜q™ä¸ªæŽ¥å£ç›´æŽ¥çš„实现类ã€?br /> .Set: 不能包含重复的元素。SortedSet是一个按照升序排列元素的Setã€?br /> .List: 是一个有序的集合åQŒå¯ä»¥åŒ…含重复的元素。提供了按照索引讉K—®çš„方式ã€?br /> .Map: 包含了key-value寏V€‚Map不能包含重复的key。SortedMap是一个按照升序排列keyçš„Mapã€?br /> 
 集合框架中的实现¾c?br /> 
 实线表示¾l§æ‰¿¾c»ï¼Œè™šçº¿è¡¨ç¤ºå®žçŽ°¾c…R€?br /> (囑֦‚ä¸?

.ArrayList: 我们可以ž®†å…¶çœ‹åšæ˜¯èƒ½å¤Ÿè‡ªåŠ¨å¢žé•¿å®¹é‡çš„数组ã€?br /> .利用ArrayListçš„toArray()˜q”回一个数¾l„ã€?br /> .Arrays.asList()˜q”回一个列表ã€?br /> .˜q­ä»£å™?Iterator)¾l™æˆ‘们提供了一¿Ué€šç”¨çš„方式来讉K—®é›†åˆä¸­çš„元素ã€?/p>

 注意: 从集合类中获取一个数¾l?toArray(),从数¾l„获取列表利用Arrays.asList()
 例子:
import java.util.*;
class ArrayListTest
{
 public static void printElement(Collection c)
 {
  Iterator it = c.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
 }
 public static void main(String[] args)
 {
  ArrayList a = new ArrayList();
  /*
  a.add("abc");
  a.add("def");
  a.add("hjk");
  */
 
  a.add(new Point(1,1));
  a.add(new Point(2,2));
  a.add(new Point(3,3));
  /*
  Object[] o;
  o=a.toArray();  //ž®†é›†åˆç±»è½¬æ¢ä¸ºæ•°¾l?br />  for(int i=0;i<o.length;i++)
  {
   System.out.println(o[i]);
  }
 
  List b = new ArrayList();
  b=Arrays.asList(o);
  System.out.println(b);
 
  for(int i=0;i<a.size();i++)
  {
   System.out.println(a.get(i));
  }
 
  System.out.println(a);
  System.out.println(a);
  */
 
  /*
  Iterator it = a.iterator();
   如果要删除元素，必须先调用nextæ–ÒŽ³•
  it.next();
  it.remove();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  //˜q­ä»£å™¨çš„作用: 提供一¾l„通用的访问方å¼?br />  printElement(a);
 }
}

class Point
{
 int x, y;
 Point(int x, int y)
 {
  this.x=x;
  this.y=y;
 }
 public String toString()
 {
  return "x="+x+","+"y="+y;
 }
}

 Collections¾c?/p>

 .排序: Collections.sort(); [区别与Arrays.sort()]
  (1) 自然排序(natural ordering);
  (2) 实现比较å™?Comparator)接口ã€?br /> .取最大和最ž®çš„元素: Collections.max(),Collections.min();
 .在已排序的List中搜索指定的元素: Collections.binarySearch()�/p>

 代码½CÞZ¾‹:
import java.util.*;
class ArrayListTest
{
 public static void printElement(Collection c)
 {
  Iterator it = c.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
 }
 public static void main(String[] args)
 {
  /*
  ArrayList a = new ArrayList();
 
  a.add("abc");
  a.add("def");
  a.add("hjk");
 
 
  a.add(new Point(1,1));
  a.add(new Point(2,2));
  a.add(new Point(3,3));
 
  Object[] o;
  o=a.toArray();  //ž®†é›†åˆç±»è½¬æ¢ä¸ºæ•°¾l?br />  for(int i=0;i<o.length;i++)
  {
   System.out.println(o[i]);
  }
 
  List b = new ArrayList();
  b=Arrays.asList(o);
  System.out.println(b);
 
  for(int i=0;i<a.size();i++)
  {
   System.out.println(a.get(i));
  }
 
  System.out.println(a);
  System.out.println(a);
  */
 
  /*
  Iterator it = a.iterator();
   如果要删除元素，必须先调用nextæ–ÒŽ³•
  it.next();
  it.remove();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  //˜q­ä»£å™¨çš„作用: 提供一¾l„通用的访问方å¼?br />  //printElement(a);
 
  Student s1 = new Student(1,"zhangsan");
  Student s2 = new Student(2,"lisi");
  Student s3 = new Student(3,"wangwu");
  Student s4 = new Student(3,"blovesaga");
 
  ArrayList a = new ArrayList();
  a.add(s1);
  a.add(s2);
  a.add(s3);
  a.add(s4);
 
  //Collections.sort(a);
  Collections.sort(a,new Student.StudentComparator());
  printElement(a);
 }
}

class Point
{
 int x, y;
 Point(int x, int y)
 {
  this.x=x;
  this.y=y;
 }
 public String toString()
 {
  return "x="+x+","+"y="+y;
 }
}

class Student implements Comparable
{
 int num;
 String name;
 //实现比较器，它æ€ÀL˜¯å’Œæˆ‘们的一个类相关,用内部类
 static class StudentComparator implements Comparator  //ä¸ÞZº†è°ƒç”¨æ–¹ä¾¿å£°æ˜Žä¸ºé™æ€çš„
 {
  public int compare(Object o1,Object o2)
  {
   Student s1 = (Student)o1;
   Student s2 = (Student)o2;
   int result=s1.num > s2.num ? 1: (s1.num==s2.num ? 0 : -1);
   if(result==0)
   {
    return s1.name.compareTo(s2.name);
   }
   return result;
  }
 }
 Student(int num,String name)
 {
  this.num=num;
  this.name=name;
 }
 public int compareTo(Object o)
 {
  Student s=(Student)o;
  return num > s.num ? 1 :( (num==s.num) ? 0 : -1);
 }
 
 public String toString()
 {
  return +num+":"+name;
 }
}

class Test
{
 public static void main(String[] args)
 {
  int i=3;
  Integer in=new Integer(i);
  int j=in.intValue();
  System.out.println(j);
  String str=in.toString();  //把Integer对象转换为String¾cÕdž‹
  System.out.println("str="+str);
 
  String str1="123";
  System.out.println(Integer.valueOf(str1));  //把String¾cÕdž‹è½¬æ¢ä¸ºInteger¾cÕdž‹
 
  boolean b1=false;
  Boolean b=new Boolean(b1);
  String s1=b.toString();
  System.out.println(s1);
 
  String s2="NO";
  System.out.println(Boolean.valueOf(s2));
 }
}

*****************Class*********************
1> 在Java中，每个class都有一个相应的Class对象。也ž®±æ˜¯è¯ß_¼Œå½“我们编写一个类åQŒç¼–译完成后,在生æˆ?br />   çš?classæ–‡äšgä¸?ž®×ƒ¼šäº§ç”Ÿä¸€ä¸ªClass对象åQŒç”¨äºŽè¡¨½Cø™¿™ä¸ªç±»çš„类型信息ã€?br />2> 获取Class实例的方法有三种:
   <1>利用对象调用getClass()æ–ÒŽ³•èŽ·å¾—该对象的Class实例ã€?br />   <2>使用Class¾cȝš„静态方法forName(),用类的名字获取一个Class的是实例ã€?br />   <3>˜qç”¨.class的方式来获取Class实例åQŒå¯¹äºŽåŸºæœ¬æ•°æ®ç±»åž‹çš„ž®è£…¾c»ï¼Œ˜q˜å¯ä»¥ç”¨.TYPE来获取相应的
      基本数据¾cÕdž‹çš„Class实例ã€?br />   <4>在运行期é—ß_¼Œå¦‚果我们要äñ”生某个类的对象，JAVA虚拟æœ?JVM)会检查该¾cÕdž‹çš„Class对象是否è¢?br />      加蝲åQŒå¦‚果没有加è½?JVM会根据类的名¿U°æ‰¾åˆ?classæ–‡äšgòq¶åŠ è½½å®ƒã€‚一旦某个类型的Class对象å·?br />      ¾lè¢«åŠ è²åˆ°å†…存，ž®±å¯ä»¥ç”¨å®ƒæ¥äº§ç”Ÿè¯¥ç±»åž‹æ‰€æœ‰çš„对象ã€?br />   <5>newInstance()调用¾cÖM¸­¾~ºçœçš„构造方法ã€?好处是我们在不知道类的名字的情况下去创造一个实例）
import java.lang.reflect.*;       //子包必须手动导入
class ClassTest
{
 public static void main(String[] args)//throws Exception
 {
  /*
  Point pt=new Point();             
  Class c1=pt.getClass();//利用对象调用getClass()æ–ÒŽ³•èŽ·å¾—该对象的Class实例
  System.out.println(c1.getName());
 
  Class c2=Class.forName("Point");//使用Class¾cȝš„静态方法forName(),用类的名字获取一个Class的是实例
  System.out.println(c2.getName());
 
  Class c3=Point.class;//˜qç”¨.class的方式来获取Class实例
  System.out.println(c3.getName());
 
  Class c4=Integer.TYPE;//ž®è£…¾cȝ”¨.TYPE来获取相应的基本数据¾cÕdž‹çš„Class实例ã€?br />  System.out.println(c4.getName());
  */
  /*
  System.out.println("before new Point()");
  new Point();
  System.out.println("after new Point()");
  Class.forName("Line");
  */
  /*
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Point pt=(Point)c.newInstance();
   pt.output();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  */
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Constructor[] cons=c.getDeclaredConstructors();
   /*
   for(int i=0;i<cons.length;i++)
   {
    System.out.println(cons[i]);
   }
   Method[] ms=c.getDeclaredMethods();
   for(int i=0;i<ms.length;i++)
   {
    System.out.println(ms[i]);
   }*/
   Class[] params=cons[0].getParameterTypes();
   Object[] paramValues=new Object[params.length];
   for(int i=0;i<params.length;i++)
   {
    if(params[i].isPrimitive())
    {
     paramValues[i]=new Integer(i+3);
    }
   }
   Object o=cons[0].newInstance(paramValues);
   Method[] ms=c.getDeclaredMethods();
   ms[0].invoke(o,null);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
 
 }
}

class Point
{
 static
 {
  System.out.println("Loading Point");
 }
 int x,y;
 void output()
 {
  System.out.println("x="+x+","+"y="+y);
 }
 Point(int x,int y)
 {
  this.x=x;
  this.y=y;
 }
}

class Line
{
 static
 {
  System.out.println("Loading Line");
 }
}

class Student implements Cloneable
{
 Professor p;
 String name;
 int age;
 Student(String name, int age,Professor p)
 {
  this.name=name;
  this.age=age;
  this.p=p;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
 }
}
改变学生s2的教授信息，打印s1教授信息,¾l“æžœä¸?name=feifei,age=30.产生˜q™ä¸ª¾l“果是因为String是一个常量类åž?
 
深克�br />code:
class DeeplyClone
{
 public static void main(String[] args)
 {
   Professor p=new Professor("feiyang",23);
   Student s1=new Student("zhangshan",18,p);
   Student s2=(Student)s1.clone();
   s2.p.name="Bill.Gates";
   s2.p.age=30;
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
 }
}
class Professor implements Cloneable
{
 String name;
 int age;
 Professor(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
 }
}

class Student implements Cloneable
{
 Professor p;
 String name;
 int age;
 Student(String name, int age,Professor p)
 {
  this.name=name;
  this.age=age;
  this.p=p;
 }
 public Object clone()
 {
  //Object o=null;
  Student o=null;
  try
  {
   o=(Student)super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  o.p=(Professor)p.clone();
  return o;
 }
}
打印¾l“æžœä¸?name=Bill.Gates,age=30,˜q™å°±æ˜¯æ·±å…‹éš†.

1> 在Java中所有的数组都有一个缺省的属性lengthåQŒç”¨äºŽèŽ·å–æ•°¾l„元素的个数ã€?br />2> 数组的复åˆ? System.arraycopy()ã€?br />3> 数组的排åº? Arrays.sort()ã€?br />4> 在已排序的数¾l„中查找某个元素åQšArrays.binarySearch()ã€?br />具体的看看下面的2个例å­?
code1:
class ArrayTest
{
 public static void main(String[] args)
 {
  /*数组的copy
  int[] num1=new int[]{1,2,3};
  int[] num2=new int[3];
  System.arraycopy(num1,0,num2,0,num1.length);
  for(int i=0;i<num2.length;i++)
  {
   System.out.println(num2[i]);
  }
  */
  //引用¾cÕdž‹çš„æ•°¾l„copy
  Point[] pts1=new Point[]{new Point(1,1),new Point(2,2),new Point(3,3)};
  Point[] pts2=new Point[3];
  System.arraycopy(pts1,0,pts2,0,pts1.length);
  for(int i=0;i<pts2.length;i++)
  {
   System.out.println("x="+pts2[i].x+","+"y="+pts2[i].y);
  }
  /*
  *å› äؓ引用¾cÕdž‹ä¼ é€’的是引用的拯‚´åQŒæ‰€ä»¥æˆ‘们修改pts2数组的第二个点的坐标åQ?br />  *当我们打印pts1数组的第一个点的坐标时åQŒå®ƒçš„坐标点已经被修改äØ“(5,5)äº?br />  pts2[1].x=5;
  pts2[1].y=5;
  System.out.println("x="+pts1[1].x+","+"y="+pts1[1].y);
  */
 }
}

class Point
{
 int x, y;
 Point(int x,int y)
 {
  this.x=x;
  this.y=y;
 }
}

code2:
import java.util.*;
class TestArray
{
 public static void main(String[] args)
 {
  /*
  int[] num=new int[]{3,2,1};
  Arrays.sort(num);
  for(int i=0;i<num.length;i++)
  {
   System.out.println(num[i]);
  }
  int index=Arrays.binarySearch(num,3);
  System.out.println("index="+index);
  System.out.println("Element="+num[index]);
  */
  Student[] ss=new Student[]{new Student("zhangshan",1),
                            new Student("lisi",2),
                            new Student("wangwu",3),
                            new Student("mybole",3)};
   Arrays.sort(ss);
   for(int i=0;i<ss.length;i++)
   {
    System.out.println(ss[i]);
   }
   int index=Arrays.binarySearch(ss,new Student("lisi",2));
   System.out.println("name="+ss[index].name+","+"index="+index);
 }
}

class Student implements Comparable
{
 String name;
 int num;
 Student(String name,int num)
 {
  this.name=name;
  this.num=num;
 }
 public String toString()
 {
  return "name="+name+","+"number="+num;
 }
 public int compareTo(Object o)  //对于Object[]排序要求实现Comparable接口
 {
  Student s=(Student)o;
  //return num>s.num ? 1 :(num==s.num ? 0 : -1);
  int result=num>s.num ? 1 :(num==s.num ? 0 : -1);//按名字排�br />  if(0==result)
  {
   result=name.compareTo(s.name);
  }
  return result;
 }
}

       blovesage写下˜q™æ®µä»£ç æˆ‘们期望得到应该扑֛žçš„零é’?.90,但是当运行后他发现数据不兑，˜qè¡Œ¾l“æžœä¸?0.8999999999999999,与预期的0.90不一栗÷€‚äؓ什么呢?搞了半天原因在于1.1˜q™ä¸ªæ•îC¸èƒ½è¢«¾_„¡¡®çš„表½CÞZؓ一个double,因此被表½CÞZؓ最接近它的doubleå€?该程序从2中减去这个值得.遗憾的是,˜q™ä¸ª¾l“果打印出来òq¶ä¸æ˜¯æŽ¥˜q?.9çš„doubleå€?˜q™è¯´æ˜? òq¶ä¸æ˜¯æ‰€æœ‰çš„ž®æ•°éƒ½å¯ä»¥ç”¨äºŒè¿›åˆ¶æÕQç‚ÒŽ•°¾_„¡¡®è¡¨ç¤º.二进制æÕQ点对于货币计½Ž—是非常不适合çš?
      要解册™¿™ä¸ªé—®é¢˜æœ‰ä¸¤ä¸ªåŠžæ³•:一是ä‹É用某¿Uæ•´æ•°ç±»åž?例如int或long,òq¶ä¸”分单位来计算.如下:
System.out.println((200-110)+"fen");
¾l“æžœä¸?0åˆ?二是使用执行ž®æ•°˜qç®—çš„BigDecimal.它还可以通过JDBC与SQL DECIMAL¾cÕdž‹˜q›è¡Œäº’操ä½?˜q™é‡Œéœ€è¦æ³¨æ„çš„æ˜? 一定要用BigDecimal(String)构造器,而千万不要用BigDecimal(double).后一个构造器ž®†ç”¨å®ƒçš„参数值来创徏一个实ä¾?例如new BigDecimal(.1),它将˜q”回一个BigDecimal,也即0.10000000000000000555111512312578270211815834041015625.正确使用我们ž®±å¯ä»¥å¾—到期望的¾l“æžœ0.90:
code:
import java.math.BigDecimal;
class Change
{
 public static void main(String[] args)
 {
  System.out.println(new BigDecimal("2.00").
                     subtract(new BigDecimal("1.10")));
 }
}
Print:
F:\Java Develop>java Change
0.90

class Indecisive
{
 public static void main(String[] args)
 {
  System.out.println(decisive());
 }
 static boolean decisive()
 {
  try
  {
   return true;
  }
  finally
  {
   return false;
  }
 }
}
   你可能认ä¸ø™¿™ä¸ªç¨‹åºä¸åˆæ³•ã€‚毕竟，decisiveæ–ÒŽ³•ä¸èƒ½åŒæ—¶˜q”回trueå’Œfalse。如果你ž®è¯•ä¸€ä¸‹ï¼Œž®×ƒ¼šå‘现å®?br />¾~–译时没有ä“Q何错误，òq¶ä¸”它打印的是false。äؓ什么呢?
    原因在于ž®±æ˜¯åœ¨ï¼šåœ¨ä¸€ä¸ªtry-finally语句中，finally语句块æ€ÀL˜¯åœ¨æŽ§åˆ¶æƒ¼›Õd¼€try语句块时执行。无论try
语句块是正常¾l“束的，˜q˜æ˜¯æ„å¤–¾l“束åQŒæƒ…况都是如此。在一条语句或一个语句块抛出一个异常，或者对某个ž®é—­¾cÕdž‹è¯­å¥æ‰§è¡Œäº†ä¸€ä¸ªbreak或continueåQŒæˆ–是像˜q™ä¸ª½E‹åºä¸€æ äh‰§è¡Œäº†ä¸€ä¸ªreturnæ—Óž¼Œž®†å‘生意外结束。之所以称为意外结束，是因为它们阻止程序按™åºåºæ‰§è¡Œä¸‹é¢çš„语句ã€?br />    当try语句块和finally语句块都意外¾l“束æ—Óž¼Œåœ¨try语句块中引发意外¾l“束的原因将被丢弃，而整个try-finally
语句意外¾l“束的原因将与finally语句块意外结束的原因相同。在˜q™ä¸ª½E‹åºä¸­ï¼Œåœ¨try语句块中的return语句所
引发的意外结束将被丢弃，而try-finally语句意外¾l“束是由finally语句块中的return造成的。简单的è®ÔŒ¼Œ½E‹åº
ž®è¯•ç€(try)˜q”回(return)true,但是它最¾l?finally)˜q”回(return)的是falseã€?br />    æ€ÖM¹‹åQŒæ¯ä¸€ä¸ªfinally语句块都应该正常¾l“束åQŒé™¤éžæŠ›å‡ÞZ¸å—检查的异常。千万不要用return,break,continue或throw来退出finally语句块，òq¶ä¸”千万不要允许让受‹‚€æŸ¥çš„异常传播到finally语句块之外ã€?/p>