j2se回想

執行Java程序．
Java程序有兩種方式一種是jar包。一種是class. 執行jar,Java -jar XXX.jar執行的時候，Java.exe調用GetMainClassName函數，該函數先得到JNIEnv實例而後調用Java類Java.util.jar.JarFileJNIEnv中方法getManifest()並從返回的Manifest對象中取getAttributes("Main-Class")的值即jar包中文件：META-INF/MANIFEST.MF指定的Main-Class的主類名做爲執行的主類。以後main函數會調用Java.c中LoadClass方法裝載該主類（使用JNIEnv實例的FindClass）。main函數直接調用Java.c中LoadClass方法裝載該類。假設是執行class方法。main函數直接調用Java.c中LoadClass方法裝載該類。

而後main函數調用JNIEnv實例的GetStaticMethodID方法查找裝載的class主類中

「public static void main(String[] args)」方法，並推斷該方法是否爲public方法，而後調用JNIEnv實例的

CallStaticVoidMethod方法調用該Java類的main方法。 
----------------------------------------------------
堆和棧是分別管理 對象和地址值的。非靜態在獲取實例的時候需要一個引用，（因此需要new一個對象） 而靜態則不需要
native 是java用來和c/c++ 打交到的，早期java剛剛出生是c/c++橫行的時候，java爲了適應當時的格局。因此在jvm中開闢了一塊空間特意來處理c/c++的程序。

這塊區域他叫作native。

而native是用來處理程序和硬件打交到的區域。
棧裏面是存放地址引用，堆裏面的存放的是實體對象。棧的速度快。堆比較慢。

----------------------------------------------------
JAVA_HOME
D:\Java\bin
PATH
%JAVA_HOME%;%System%.....
----------------------------------------------------
設置暫時的環境變量
set path="u盤上的jre文件bin文件的路徑"，這樣path的路徑就變爲了暫時的了。他的生命週期就在當前窗體。關閉就沒有了。
javac xxx.java

class 文件不在當前目錄下
-->set classpath f:\xxx\xx\   這樣子過去，可以爲當前類文件設置一個暫時的路徑。

----------------------------------------------------
& 過程當中僅僅要有一邊爲假，就爲假
| 過程當中僅僅要有一邊爲真，就爲真

&&左邊爲false時不參與運算
||左邊爲true時不參與運算

位運算。計算機專用，用於操做2進制的運算。
----------------------------------------------------
if(){}else if(){}else if(){} else  //這個儘管由多個代碼塊組成。但是僅僅有一個會運行。

if 和 switch  建議僅僅使用 switch  switch會把選擇答案載入進內存，選擇效率會高點。 int byte short char enum string
while(){}
do while(){}無論條件是否知足，循環體都要運行一次。
（\r \n回車） （\t製表符） （\轉義字符）
標識符：

wai:for(int i;i<10;i++){
 nei:for(int j;j<10;j++){
  break wai;  //跳出外循環
 }
}
----------------------------------------------------
重載：方法名一樣。參數個數不一樣，返回值類型不一樣。
數組：同一類型，固定個數的容器。

選擇排序：1 第一個和後面的每一個比較，小的放前面。內圈和外圈作比較。2 內圈的起始變量是外圈的第二個。3 來個暫時變量，爲2個角標的引用作交換。

冒泡排序：1 相鄰的2個數作比較。大的放後面。

2 內圈變量是外圈長度減一。3 來個暫時變量。爲2個角標的引用作交換。

Arrays.sort(arr);//開發專用 ,寧外希爾排序，效率很是高。

二分法查找：1 必須是有序的。
>>>右移動4位，<<<左移動4位 ， 在10進制中一個數&15 至關於找到自身。

Integer.toBinatyString(-6); 十--->二進制
Integer.toOctalString(-6); 十--->八進制
Integer.toHexString(-6); 十--->十六進制
----------------------------------------------------
二維數組
引用數據類型，在堆裏面，默認初始化值是null。在沒有不論什麼指向以前他就是null。
int arr[][]={{1,2,3},{4,5,6},{7,8,9}};
int sum=0;
for(int i;i<arr.length;i++){
 for(int j;j<arr[i].length;j++){
  sum+=arr[i][j];
 }
}
----------------------------------------------------
面向對象：
1 面向對象思想是一種符合現實社會中人們對問題思考習慣的思想。
2 把現實社會中複雜的事情簡單化（eg:買電腦）
3 把運行者，變爲指揮者（eg:買電腦）
--------------------
3 種引用類型的變量。

 1 數組。

 2 類。
 3 接口。
--------------------
局部變量和成員變量的差異
1 在類中定義的位置不一樣
2 在內存中的生命週期不一樣（堆和棧）
3 生命週期不一樣
4 初始化值不同。

--------------------
匿名對象的使用場景：當對象方法或屬性僅僅有一次調用的時候就用匿名對象。
--------------------
五片內存區域：
1 寄存器。
2 本地方法區[和jni一塊兒用]。
3 棧內存。

4 堆內存。
5 方法區[數據共享區]。

---------------------------------------------------------
面向對象：
1 封裝：隱藏對象的屬性和實現細節，僅對提供公共的訪問和操做方式。
 構造函數：將對象初始化。每一個類都有一個默認的構造函數。
 this：表示當前對象，字節碼。

誰調用這個類。this就表明誰。

 {} 構造代碼塊。每次建立一個對象都會運行一次。而構造函數僅僅運行一次。
  --------------------
  static: 和方法同樣。存在方法區中，而方法是在被調用的時候才進棧，被static修飾的就是一直存在方法區中。

  ---1 被static修飾的，優先於對象存在。
  ---2 隨着類的載入而載入，消失而消失。
  ---3 被所有成員共享。
  ---4 靜態僅僅能調用靜態。非靜態可以調用靜態。

  --------------------
  static（類變量(在方法區中)）object（實例變量(在堆中)）
  方法默認存儲在方法區中，而當執行的時候纔在棧中。
  ---------------
  static 代碼塊（那他和jni有什麼差異呢）
  1 隨着類的載入而載入，而且僅僅運行一次。
  2 優先於主函數運行。

  3 給類初始化。
  ---------------
  單例模式：爲了保證一個project僅僅有一個對象。
  eg: 對象也可以用來封裝數據。

  1 懶漢式。
  2 餓漢式。
  因爲static 是隨着類的載入而載入的，浪費內存。

因此爲了不必定的空間浪費，開發中推薦懶漢式，特別是android
  單例中出現的方法。是爲了[可控]
--------------------------------------------------------
2 繼承：（單繼承[調用的不肯定性],多實現）
 1 讓類與類之間產生了關係。
 2 對共性進行了抽取(屬性和方法)。
 3 子類可以調用父類的屬性和方法。前提是僅僅能訪問父類中public的。

而且子類中使用的時候不會本身主動提示，但是咱們手動寫。

 4 在子類的所有構造函數的第一行，默認有一句 super(),他會去調用父類的構造方法。
 5 【凡是】子類繼承父類。父類和子類的屬性，都在子類的堆內存區其中。因此父類有的，子類就可以不用寫了。寫了就是內存浪費。
    特殊狀況[android 本身定義控件]例如如下：
 6 當子類重寫父類了的方法以後。就會將父類的方法進行屏蔽。之後調用這種方法，都是去運行子類的邏輯，在android本身定義控件中用的比較多。

 7 結論：父類的構造函數，既可以給本類對象初始化，也可以給子類對象初始化。
------------------
 繼承就是不斷的向上抽取。僅僅有在其子類纔有特有的功能，何時繼承得看狀況。
 this可以表明當前對象。super 表明父類空間。

 被private 修飾的不能被子類繼承訪問。

但是子類的堆內存中有。

 當子父類中出現一摸同樣的方法時。子類會覆蓋（重寫）父類的方法。

並且子類的權限要>=父類。

 重載是函數名一樣，參數不一樣。和覆蓋不同。

 static僅僅能覆蓋static
 在一個類中：當有參構造的出現，默認的無參構造會消失。

 繼承會把父類中的全部public的功能全部拿過來。

------------------
final
被final 修飾的屬性不能改動、類不能繼承、方法不能重寫。
在開發中常量就可以用final 來修飾，但是名稱得大寫。

而且在繼承中，假設子類中有，默認是調用子類的，子類沒有才調用父類的。

構造代碼塊：在super()和本身的代碼之間，會調用構造代碼塊。
------------------
一個對象在內存中產生的過程：
1 將該對象所需的類文件載入進內存。
2 在內存中進行空間的方法區的空間分配。
3 經過new 在堆中開闢空間。

4 對象中的屬性進行默認初始化。
5 調用與之對象的構造函數進行初始化。
6 經過構造函數的super調用父類中的構造函數初始化。
7 對象中的屬性進行顯示初始化。
8 構造代碼塊初始化。
9 該構造函數內部本身定義內容進行初始化。

------------------
 抽象：is a  [是]（多個子類繼承同一個父類）
 當你描寫敘述一個事物的時候，沒有足夠的信息對該事物進行描寫敘述，那麼這個事物相應的類就是一個抽象類。

 抽象類不能實例化。

 抽象類中的方法必須全部重寫。
 抽象類中能有本身的特有方法。（接口不能）
 抽象類必須要被繼承。
 子類能繼承一切非 private 的方法。
 繼承的本意在於抽象，而非代碼的重用。
 
 -----------------
 接口：like a  [像]（多個接口能被同一個類實現）
 接口裏面的方法都是抽象方法。
 接口裏面的常量都是靜態不可被改動的。
 接口僅僅能實現不能被new。
 接口能多實現。

（攻克了java的單實現的問題）
 接口能繼承接口。而且接口可以【多繼承】。
 接口的出現是爲了定義額外的功能。
 
------------------
接口回調：
1 在Fragment類 中定義一個Test接口。
2 在Fragment類 中定義一個接口對象常量。

3 在Fragment類 中定義一個方法。爲接口的引用賦值，參數是實現類的子類。
4 在MainActivity類 中實現Test接口。重寫接口裏面的方法。在方法裏面寫上本身的邏輯。
5 在TestCallBack類 中new Fragment這個對象。

調用實例化接口的那個方法。參數是new　MainActivity();（假設執行null，就傳this吧）
-----------------
3 多態：
父類或接口的引用指向子類的實例對象。

優勢:提升了代碼的拓展性。
壞處:不能使用子類的特有內容。
假設想使用子類的特有功能，就得向下轉型。
instanceof:向下轉型的keyword，僅僅能用於引用類型的推斷。

多態-成員變量：編譯執行都看左邊。

多態-成員函數：編譯看左邊，執行看右邊。

-----------------------------------------------
多線程：
進程：正在運行的任務程序。

線程：程序運行的程序。
本身定義線程執行的任務都執行在run方法中。
當調用。start()方法後，線程內部。會本身主動運行run() 方法;
有2種方式建立線程。

1 實現Runnable接口。（這個比較好能夠起拓展用的）
2 繼承 Thread 類。

（這個比較硬編碼）
同步鎖：
僅僅要保證鎖是同一個鎖就不會出現線程安全的問題。

JDK 1.5 以後。Lock替代了同步，Condition替代了Object中的監視器方法。
private final Lock lock=new ReentrantLock();//建立鎖對象
private Condition xiaofei=lock.newCondition();//子鎖1
private Condition shencan=lock.newCondition();//子鎖2
lock.lock();//加鎖
xiaofei.await(); //等待
shencan.signal(); //喚醒
lock.unlock();//解鎖
----------------------------------------------
eclipse 模板
方法中去掉無用的凝視 java->code style ->code templates
本身定義快捷鍵 java->Editor-> Templates
----------------------------------------------
StringBuffer(線程安全，在多線程的時候使用) StringBuilder(線程不安全，沒有線程的時候。開發中建議使用這個)
字符串比較。實現 Comparable 接口，調用 Comparto()方法,會依照字典大小排序。他的返回值是0或1。

----------------------------------------------
基本數據類型，字符串轉爲對象 Character
toLowerCase(char ch);【指定字符串：變小寫】
toUpperCase(cher ch);【指定字符串：變大寫】
------------
toBinatyString 二進制
toHexString 十六進制
toOctalString 八進制
==================================================集合  記住 Collection 下的集合都能被迭代 Iterator
集合長度可變。數組長度不可變。
集合可以存儲多種類型對象，數組僅僅能存儲單一類型的對象。
Iterator是Collection所有子集合共性抽取的迭代接口;

    Collection[接口]   (集合都有：增，刪。改，查。的方法)                                 
     List: 鏈表結構：可以模仿堆棧。

   注意問題：在迭代集合的時候，/*假設需要對集合進行併發操做，會出現併發改動異常*/，咱們得把Iterator 換爲ListIterator。
   他的功能比 Iterator不少其它。（詳情查看api）
    非線程安全：
    ArrayList 查詢快。增刪慢。
    LinkedList 增刪快。查詢慢。 【可以用來模仿堆棧 addLast(),removeFlast()】
    
    /*線程安全*/。在多線程的時候使用：
    Vector 底層是數組結構。他迭代的時候可以用枚舉接口， Enumeration 來迭代。因爲枚舉在的時候尚未集合框架。
  Set:  集合結構：可以用來去重。

   HashSet 無序的。

存儲時速度巨快，因爲底層是依據哈希算法來實現的。

但是不關心順序，並且惟一。

需要查詢hashCode() 和equers()
    本身定義對象(往哈希表中存儲數據的時候)要重寫 equals()，HashCode()  方法。

才幹作比較。
    本身定義對象(假設想讓對象具有比較大小的功能，依照天然順序排序，必須要實現 Comparable接口 )
    eg：/*牛逼的equers()方法
     public boolean equers(Object obj){
      if(this==obj){//比較地址
       return true;
      }
      if(!(obj instanceof Student)){
       throws new ClassCastException("類型不匹配，沒法比較");
      }
      Student stu=(Student) obj;
      return this.name.equals(stu.name) && this.age==stu.age;
     }
     */
   TreeSet:
    排序方式1：
     使用元素的天然順序進行排序。他保證數據的惟一性,是在本身定義對象中實現 Comparable接口 重寫compareTo()看返回值是否爲0，爲0就是反覆的元素。

    排序方式2：
     定義一個比較器，讓對象一初始化就具有比較功能。實現 Comparator 接口。

重寫 compare()方法,相等返回0;
     假設需要先依照字典排序又要依照長度排序，那麼就得在compare()裏面繼續調用 compareTo() 方法了。
     實現原理是二叉樹比較法。就像二分查找法同樣。
     person p=(person)o;
     int temp =this.age-p.age;
     return temp==0?this.name.compareTo(p.name):temp;
   LinkedHashSet:
    有序且去反覆的列表：
  
  範型:
   上邊界: ?

extends person (傳遞進來的參數僅僅能爲 person的自己或者子類型)
   下邊界: person super ? ()
  泛型類：
  省去了之前的強轉和類型轉換異常的麻煩。（將泛型定義在類上。使用者僅僅需要在使用這個類的時候傳入泛型就可以了）
  詳細什麼類型由使用者肯定。

  eg： public Util<T>{   //使用方僅僅需要   這樣使用    Util<Person> u=new Util<Person>
    private T t;//        u.setT(new Person());
    public void setT(T t){//     u.getT();
     this.t=t;
    }
    public T getT(){
     return t;
    }
   }
  
  泛型方法：在不肯定方法的參數的時候，需要什麼類型本身傳遞 (基本數據類型。或者對象類型，都可以)
  eg: public <W> void show(W w){
    System.out.println("w:"+w);
   }
  
  泛型接口：也是傳入的參數不肯定的時候使用的。
  eg：public interfrace inner<V>{
    public abstract void show(V v);
   }
   class innerImpl<C> implements inner<C>{
    public void show(C c){
     System.out.println("c:"+c);
    }
   }
   
   main(String[] args){
    new innerImpl<Integer>().show(new Integer(3));
    new innerImpl<String>().show(new String("ok"));
   }
  fore() 循環。不操做角標，能操做數組和 Connection集合;
   
 Map(Key,Value):
  key不能反覆;
  取值有2種方式：
   1 map.keySet 獲得所有key的集合
   2 map.entrySet 獲得所有key和value的集合  (entry 實體對象)
   
  
  1.0 Hashtable 線程安全,key value不一樣意爲空（和Vector一個時代的）
  1.2 HashMap   線程不安全,key value贊成爲空【假設是本身定義對象，在迭代的時候要去除反覆的key,可以參閱 250行牛逼的equers()方法】
   TreeMap   底層是二叉樹實現的，假設想讓本身定義對象也具備比較性，必須實現 Comparable接口,查詢 compareTo();
   LinkedHashMap 有序結構的鏈表集合（內部模擬了堆棧的實現）
   //Properties 他也是鍵值對的屬性集。重要的是他能持久化這個集合，用於IO流讀取。他的父類是HashTable
  
 專門操做集合的工具類:
 Collections   eg:詳情查看api;  工具類中有，synchronizedCollection(),List,Map可以將非同步的集合轉爲同步的集合。
 Arrays    eg:詳情查看api; asList(int[] i)數組轉集合。

但是有些方法是不能用的。

因爲集合是固定的。不能作增刪操做。

          toArray()集合轉數組。

定義類型必須一致。
    
  可變參數： ... 可以替代很是多個數的數組，前提是必須放在參數列表的最後面。

 
其它api：
 System： 有一個很是有意思的api。 System.getProperties()他能返回這個整個環境和工具的信息的集合。
 還可以經過集合裏面特定的key值，可以在不一樣平臺下都能使用的特殊功能符號。
 
 Runtime：這是一個底層由單例模式完畢的執行時類。 經過Runtime.getRuntime()可以獲得他的對象。詳情查看 api
 eg：啓動qq  Runtime.getRuntime().extc("qq.exe");{這裏面，寫的的是Dos命令}
 
 Math: abs()絕對值 , ceil 天花板 floor地板 round四捨五入 Max最大 Min最小 pow冪運算，... 正旋餘弦 不少其它查看api

 
IO流：用來處理設備間的傳輸數據。分輸出流和輸入流。

{僅僅要對象一建立就有文件。

假設已經存在會被覆蓋}
 使用完以後必定要記得關閉流對象。而且得放在finally中，而且這個流對象還得作非空推斷，防止對象沒有建立成功，報null異常。

由於操做系統不一樣。有的時候\r\n 很差使，因此咱們使用 System.getProperty("line.separator");
字節流：
 InputStream OutputStream: （看頂層，用底層）
 FileInputStream
 FileOutputStream
 字節流可以直接將內容寫到目的地，不需要暫時存儲就能操做文件，比字符流少了走緩衝區這一步。

他是直接操做字節的。
 裝飾模式：
 BufferedInputStream 對已有的對象提供了額外的功能，還不用對源對象進行改動，避免了繼承的臃腫。
 BufferedOutputStream
 轉換流：（事實上我想說：他也是代理模式麼？）
 InputStreamReader(new InputStream()):字節轉字符，將內存看不懂的字節轉爲可以看懂的文字。
 OutputStreamWriter(new OutputStream()):字符轉字節。將看的懂的文字轉爲內存爲看不懂的字節。
 

字符流：（字節流+編碼表）
 Reader Writer:
 
 FileWriter FileReader
 文件操做流。
 對文件進行續寫 new FileWriter("demo.txt",true);
 在內存中定義高效的緩衝區:(通常獲取內存中的速度遠比直接獲取目的地的數據快高效)
 BufferedReader(new FileReader());  BufferedWriter(new FileWriter());
 裝飾模式：
 [事實上BufferedReader 這樣的方式是典型的裝飾模式的應用：對已有的對象提供了額外的功能，還不用對源對象進行改動，避免是繼承的臃腫]
 BufferedReader(new FileReader());
 LineNumberReader(new FileReader());
 
IO流4步曲
 1 明白源和目的 I  O
 2 是否純文本 FileReader
 3 明白設備
 4 是否需要高效 BufferReader
 
 轉行流：
 InputStreamReader(),指定編碼表 InputStreamReader(is,"UTF-8");
 OutputStreamWriter(),指定編碼表 OutputStreamWriter(os,"UTF-8");
 
File 類:
 File.separator 名稱分隔符,在不論什麼環境下都能使用。linux和windows下都能識別。他會本身主動轉換
 File.getTotalSpace() 總大小
 File.getFreeSpace() 剩餘空間
 File.deleteOnExit();退出系統的時候會本身主動刪除文件(因此在咱們建立文件以後可以馬上寫這句話)
 File.isFile() 是否爲文件
 File.isDirectory() 是否爲目錄
 file.list(new filter());文件過濾器
 file.listFilse(new filter());目錄過濾器
 
SequenceInputStream 合併流：
public static void main(String[] args) throws IOException {
  將多個流進行邏輯串聯(進行合併,變成一個流，操做起來很是方便，因爲多個源變成了一個源)
  FileInputStream fis1 = new FileInputStream("tempfile\\seq_1.txt");
  FileInputStream fis2 = new FileInputStream("tempfile\\seq_2.txt");
  FileInputStream fis3 = new FileInputStream("tempfile\\seq_3.txt");
  
  ArrayList<FileInputStream> v = new ArrayList<FileInputStream>();
  v.add(fis1);
  v.add(fis2);
  v.add(fis3);
  Enumeration<FileInputStream> en = Collections.enumeration(v);
  SequenceInputStream sis = new SequenceInputStream(en);
  //建立目的。
  FileOutputStream fos = new FileOutputStream("tempfile\\seq_4.txt");
  byte[] buf = new byte[1024];
  int len = 0;
  while((len=sis.read(buf))!=-1){
   fos.write(buf,0,len);
  }
  fos.close();
  sis.close();
 }
 RandomAccessFile:多線程下載專用流。
 seek(8); 能隨機操做指針的方法，可以開啓多個線程同一時候操做這個對象。達到多線程下載。
 
 從看不懂到看得懂解碼，從看的懂到看不懂，編碼。

文件加密：
 public static void main(String[] args) throws IOException {
  BufferedInputStream bis = new BufferedInputStream(new FileInputStream("copy4.mp3")); // 建立流對象,並給流對象加上緩衝區
  BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy5.mp3"));

//  byte[] buf=new byte[1024]; 操做字節的時候，本身定義的緩存數組就不要了，會致使垃圾產生
  int b=0;
  while ((b = bis.read(/*buf*/)) != -1) {
   bos.write(b ^ 111);//這個11 就是密鑰
  }
  bis.close();
  bos.close();
 }

網絡編程：
UDP：
不需要創建鏈接速度快。數據限制大小在64k以內，無鏈接，不可靠協議。

TCP：
需要創建鏈接。通過3次握手。可以進行大傳輸數據，是可靠協議，但效率會稍低。

TCP協議，多線程上傳文件，源代碼
public class UploadPicClient {
 public static void main(String[] args) throws UnknownHostException, IOException {
  if(args.length!=1){
   System.out.println("請指定文件");
   return;
  }
  File file = new File(args[0]);
  if(!(file.exists() && file.isFile())){
   System.out.println("該文件不存在，或不是正確的文件,又一次指定");
   return;
  }
  if(!(file.getName().endsWith(".jpg") || file.getName().endsWith(".gif"))){
   System.out.println("文件擴展名必須是jpg。或者而是 gif。");
   return;
  }
  if(file.length()>=1024*1024*2){
   System.out.println("文件過大，又一次選擇，");
   return;
  }
  Socket s = new Socket("192.168.1.100",10006);
  FileInputStream fis = new FileInputStream(file);
  OutputStream out = s.getOutputStream();
  byte[] buf = new byte[1024];
  int len = 0;
  while((len=fis.read(buf))!=-1){
   out.write(buf,0,len);
  }
  //告訴server端，發送數據完成，發送一個結束標記。
  s.shutdownOutput();
  InputStream in = s.getInputStream();
  byte[] bufIn = new byte[1024];
  int lenIn = in.read(bufIn);
  String info = new String(bufIn,0,lenIn);
  System.out.println(info);
  fis.close();
  s.close();
 }
}

public class UploadPicServer {
 public static void main(String[] args) throws IOException {
  //服務端，接收client發送過來的圖片數據。 進行存儲後，回饋一個 上傳成功字樣。 多用戶的併發訪問。

  ServerSocket  ss = new ServerSocket(10006);
  while(true){    
   Socket s  = ss.accept();
   
   new Thread(new UploadThread(s)).start();
  }
//  ss.close(); 
 }
}

public class UploadThread implements Runnable {  private Socket s;  public UploadThread(Socket s) {   super();   this.s = s;  }  @Override  public void run() {   String ip = s.getInetAddress().getHostAddress();   System.out.println(ip+"......connected");   try{   //讀取數據。網絡。   InputStream in = s.getInputStream();   File dir = new File("c:\\mypic");   if(!dir.exists())    dir.mkdir();   int count = 1;   File file = new File(dir,ip+".jpg");   while(file.exists()){    file = new File(dir,ip+"("+(count++)+").jpg");   }   //目的:文件   FileOutputStream fos = new FileOutputStream(file);   byte[] buf = new byte[1024];   int len = 0;   while((len=in.read(buf))!=-1){    fos.write(buf,0,len);   }   OutputStream out = s.getOutputStream();   out.write("上傳成功".getBytes());   fos.close();   s.close();   }   catch(IOException e){   }  } }