Java 基础笔记&代码 流

拓
新
教
育
   6  

一.java中常用工具类 文件 流 
//object类他 所有类父类
/**
 *   1.equals:判断相等。如果子类要进行重写 该方法要重写
 *   2. finalize():当垃圾回收器确定没有阻塞 给更多垃圾是则调用该方法
 *   3.wait:可以将将线程阻塞 并将锁释放
 *   4.notify.notifyall:将wait 阻塞对象解除阻塞的状态
 * 
 * system类：
 *   err:标准错误输出流
 *   out:标注输出流
 *   in:标准输入流
 *   exit(n)：终止虚拟机。n为0 则但单纯退出虚拟机
 *   实际上等偶同与Runtime.getRuntime.exit(0)；
 * GC：
 *   通知垃圾回收器回收垃圾 并不代表表马上执行
 *   最终会调用finalize方法
 *   arraycopy(object src,int srcPos ,object dest,int destpos,int length):
 *   用来复制数组的
 * 参数解析
 *   1.src-----源数组
 *   srcpos---原数组的起始位置
 *   dest---目标数组
 *   destpos-----目标数组起始位置
 * currentTimeMillis:返回以毫秒为单位当前时间17071天
 * String:类
 *   String 创建对象
 *   String s="ee";池中创建对象
 *   使用String的构造器创建的时候会在堆中创建
 *   String的本质：就是char的数组
 *   String类：的长度确定不能更改
 *   String对象一旦请确定不可更改
 *   String类的常用方法：
 *   (1).charAt(index):返回指定索引出的char
 *   (2).concat(String str):相当于+连接符
 *   (3).endswith(String suffix):判断 该字符串是否已xxx结尾@author Administrator
 *   (4).equals(Object obj):比较两个字符串是否相等
 *   (5).equalsIgnorecase:忽略大小写比较
 *   (6).indexof(ch):返回指定字符在该字符串中第一次出现的位置
 *   (7).indexof(ch ,int fromIndex):返回指定字符在该字符串中第一次出现的位置 并从哪个索引开始
 *   (8).length():长度  集合size
 *   (9).isEmpty():如果length为0 则返回true
 *   (10).lastIndexof(ch):制定字符串最后一次出现的位置
 *   (11).replace(char old,char new ):替换并返回
 *   (12).split(String  reg)：按照指定的规则截取并返回一个字符创数组
 *   (13).startswith(String ch):判断 开始
 *   (14).substring(int index):从某个位置开始截取到结尾
 *   (15).substring(int begin,int end):从某未开始截取到（某位 之前）
 *   (16).toCharArray():把String 转设为char 型数组
 *   (17).getBytes:返回字节数
 *   (18).toLowersCase()
 *   (19).toUpperCase()
 *   (20).trim:返回字符串副本 去除首尾空格 
 * (4)缓冲字符
 *  Stringbuffer和StringBuilder（效率高）：安全问题
 *  为什么要使用？
 *  (1)可以不创建多个对象 直接改变 对象内容
 *    append():想缓冲区增加字符
 *    insert(int a.String b):将指定在字符插入到制定的位置
 *    delete(int start , int  end):删除制定位置上的字符串
 *   (2)Stringbuffer和StringBuilder的区别
 *   (3)Stringbuffer    出现的较早 效率低 线程安全     重量级
 *   (4)StringBuilder   出现的较晚 效率高 线程不安全  轻量级
 *   (5)Data时间类
 *    获取当前时间Date d=new date(); 
 *    (6).处理date日期格式使用simpleDateFormat() *    
 * SimpleDateFormat sdf=new simpleDateFormat("yy  mm  dd")
 * String myday =sdf.format(d);
 * system.out.print(myday);
 *  Timestamp:时间戳 正常时间格式 并精确返回到毫秒
 *  (7)日历类
 *  calendar c=new calendar.getInstance();
 *  system.out.print(c.getTime);
 * 
 * eg:
 *  calendar c=new calendar.getInstance();
 *  system.out.print(c.getTime);
 *  单例模式：
 *  public class Single {
    
    //(1).提供私有构造器
        private Single(){}
    //(2)提供私有静态的对象实例
        private static Single instance=new Single();
        public static Single getInstance(){
            return instance;
            
        }
        }

 * (7)Math类：
 * 常用方法
 * (7.1)PI:属性，返回一个接近圆周率的数值
 * (7.2)abs(double a):返回double值得绝对值
 * (7.3)cbrt(double a):返回的是double的开立方根
 * (7.4)floor(double):返回值  最接近 最大的前 取整
 * (7.5)max(double a,double b):两个数取最大的
 * (7.6)min(double a,double b):两个数取最小的
 * (7.7)pow(double  a,double b):返回第一个参数的 n次幂  （ a的b次幂）
 * (7.8)sqrt(double a):开的是“正”平方根
 * (7.9)round(double a):四舍五入
 * (7.10)random():得到一个随机数
 * system.out.print(Math.random()*100);100以内随机数
 * eg:Random ran=new Random();
 * int  b=ran.nextInt(10);
 * sysout(b);  
 */
IO流：
数据的输入和输出，java中把这种形式抽象表述为“流”stream
I/O流：
Input：输入
Output：输出
流的分类
1.    方向分：
输入流：读取数据（只读）
输出流：只写 输出
2.    处理数据分：
  字节流：每次读写的时候一字节为单位
字符流：每次读写的时候一字符为单位
3.    按照功能分：
  低级流：（节点流）直接从硬盘络商都读取数据
  高级流:(处理流）直接在低级流上套一个高级流



InputStream:
read():一次读取一个字节 如果读到文档末尾则返回-1 
使用：
（1）.创建流
（2）.操作
（3）.关闭
OutputStream:
  Write():y一次只能写 一个字节
File:
高级流：只需要低级流上套一层流
缓冲流：BufferedInPutStream
BufferedOutPutStream
Reader和Writer:文本文档
序列化
就是把对象的信息保存到本地文件
反序列化
就是把本地文件中存储对象的信息变回对象
高级流
ObjectInputStream
ObjectOutputStream
(1)序列化必须实现 serializable接口(implements)
(2)版本号要一致
二.文件
//  创建文件对象 不可重复
//        File file = new File("D:/hello.txt");
//        
//        try {
//            boolean issuccess=file.createNewFile();
//             System.out.println(issuccess);
//        } catch (IOException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }
// // 创建目录 不可重复 //单级目录
//        
//        
//        File file1=new File("D:/我的目");
//        boolean isSuccess=file1.mkdir();
//        System.out.println(isSuccess);
// // 创建目录 不可重复 //多级目录    
//        
//        
//        File file2=new File("D:/我的目录1/目录1/目录2");
//        boolean isSuccess2=file2.mkdirs();
//        System.out.println(isSuccess2);
// //删除文件  回收站不可找回
//        
//        
//        boolean isSussess=file.delete();
//        System.out.println(isSussess);
//  删除文件夹  回收站不可找回
    //绝对路径
//        File file = new File("D:/我的目录");
//        //boolean isSuc=file.mkdir();
//    //非空不能删除
//        boolean isDelte=file.delete();
//        //System.out.println(isSuc);
//        System.out.println(isDelte);
    //使用相对路径创建文件 不指定盘符  相对路经就是工程文件夹
//        File file = new File("a.txt");
//        boolean isSuc=file.createNewFile();
//        System.out.println(isSuc);
//        file.delete();
//    //文件夹只能一级一级删除
//        File file1 = new File("aa/bb");
//        boolean isSuc1=file1.mkdirs();
//        System.out.println(isSuc1);
//        file1.delete();
    //package下创建文件
        File file1 = new File("src3/zz/liwanxu.mp3");
        file1.createNewFile();
        file1.delete();
    }
二．字符流
1.向一个文件写100个HELLOWORD
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;


public class iodemo1 {

    /**
     * @param args
     */
    
    public static void main(String[] args) {
        writeFile1();
        // TODO Auto-generated method stubf
    }    
    public static void writeFile1() {
        // TODO Auto-generated method stubf
        
         FileWriter fw=null;
        try {
            //创建输出流的对象
            fw=new FileWriter("b.txt");
            for(int i=0;i<100;i++){
                  //把内容 写到文件
                fw.write("hellowrite");
                if(i%10==0){
                    //字符流的特点 清空缓冲区 把内容写到文件中
                    fw.flush();
                }
            }
               //字符流的特点 清空缓冲区 把内容写到文件中
            fw.flush();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
            
            if(fw !=null){
            
                try {
                    //close关闭输出流之前清空缓冲区
                    fw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        

    }

}
 
 
2.追加
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;


public class iodemo1 {

    /**
     * @param args
     */
    
    public static void main(String[] args) {
        writeFile1();
        // TODO Auto-generated method stubf
    }    
    public static void writeFile1() {
        // TODO Auto-generated method stubf
        
         FileWriter fw=null;
        try {
            //创建输出流的对象
            //fw=new FileWriter("b.txt",true);
            fw=new FileWriter(new File("b.txt"),true);
            for(int i=0;i<10;i++){
                  //把内容 写到文件
                fw.write("我i爱你");
                if(i%10==0){
                    //字符流的特点 清空缓冲区 把内容写到文件中
                    fw.flush();
                }
            }
               //字符流的特点 清空缓冲区 把内容写到文件中
            fw.flush();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
            
            if(fw !=null){
            
                try {
                    //close关闭输出流之前清空缓冲区
                    fw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        

    }

}
 
3.输出换行
  把文本写入文件中 
代表换行
  Window:
;
在前时eclipse中隔行空格 建议使用 兼容记事本
  Linux:
;
Mc:
;


import java.io.File;
import java.io.FileWriter;
import java.io.IOException;


public class iodemo2 {

    /**
     * @param args
     */
    
    public static void main(String[] args) {
        writeFile1();
        // TODO Auto-generated method stubf
    }    
    public static void writeFile1() {
        // TODO Auto-generated method stubf
        
         FileWriter fw=null;
        try {
            //创建输出流的对象
            fw=new FileWriter("b.txt");
           
            for(int i=0;i<10;i++){
                  //把内容 写到文件
                fw.write("我i爱你"+i+"

");
                if(i%10==0){
                    //字符流的特点 清空缓冲区 把内容写到文件中
                    fw.flush();
                }
            }
               //字符流的特点 清空缓冲区 把内容写到文件中
            fw.flush();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
            
            if(fw !=null){
            
                try {
                    //close关闭输出流之前清空缓冲区
                    fw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        

    }

}
 
4.出入流
FileReader的爷爷是Reader
需求：
读取文件Hello word打印到控制台
分析：
1.    创建出入刘对象FileReader
2.    读取数据
3.    关系输入流  注意：需自己新建一个helloword.txt
package filereader;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Filereader {
    public static void main(String[] args) {
        readerFile();
        
    }
    public static void readerFile(){
        FileReader fr=null; 
        try {
            //创建文件都去对象 两种方法
            //fr=new FileReader("helloWord.txt");
            fr=new FileReader(new File("helloWord.txt") );
            try {
            //读取单个字符 返回的是字符的Ascll码 读取一个字符 之后在读取一个字符
                /*int n=fr.read();
                System.out.println((char)n);
                
                int n1=fr.read();
                System.out.println((char)n1);*/
            //若果读取完毕，最后没有字符是会返回-1
            
              int num=0;
            //通过循环读取字符  判断跳出循环的标志是num=-1;
              while((num=fr.read())  !=-1){
                System.out.println((char)num);
                    
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally{
            
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                
            }
        }
    }

}

5.读取数据以字符串数组形式读取（相对路径）
package filereader;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Filereader {
    public static void main(String[] args) {
        readerFile();
        
    }
    public static void readerFile(){
        FileReader fr=null; 
        try {
            //创建文件都去对象 两种方法
            //fr=new FileReader("helloWord.txt");
            fr=new FileReader("helloWord.txt" );
            try {
                //创建一个字符数组
            
                
                
//                char[] cha=new char[30];
//                int sum=fr.read(cha);
//                String str=new String(cha,0,sum);
//                System.out.println((char)sum);
//                System.out.println(str);
                char[] cha1=new char[1024];
                int num1=-1;
                
                     while((num1=fr.read(cha1))!=-1){
                         System.out.println(new String( cha1,0,num1));
                         
                         
                         
                         
                     }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catc h block
            e.printStackTrace();
        }
        finally{
            
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                
            }
        }
    }

}

5(1)读取数据以字符串数组形式读取（绝对路径）
package filereader;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Filereader1 {
    public static void main(String[] args) {
        readerFile();
        
    }
    public static void readerFile(){
        FileReader fr=null; 
        try {
            //创建文件都去对象 两种方法
            //fr=new FileReader("helloWord.txt");
            fr=new FileReader("D://helloWord.txt" );
            try {
                //创建一个字符数组
            
                
                
//                char[] cha=new char[30];
//                int sum=fr.read(cha);
//                String str=new String(cha,0,sum);
//                System.out.println((char)sum);
//                System.out.println(str);
                char[] cha1=new char[1024];
                int num1=-1;      
                
                     while((num1=fr.read(cha1))!=-1){
                         System.out.println(new String(cha1,0,num1));
                         
                         
                         
                         
                     }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catc h block
            e.printStackTrace();
        }
        finally{
            
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                
            }
        }
    }

}


6.使用字符流来做文件的拷贝
  范例：把一个java文件拷贝到项目根目录
分析：1.创建输入流对象
2.创建输出流对象
3.把输入的数据写入输出流中
4.关闭资源
方法一：方法是字节读取（慢）
package filereader;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class CopyFile {
    public static void main(String[] args) {
        copy1();
        System.out.println("done");
    }
    
    public static  void  copy1(){
        Reader  reader =null;
        Writer writer =null;
        try {
        //创建文件读取对象
             reader =new FileReader ("src3/filereader/Filereader.java");
        
        //创建写文件的对象
             writer =new FileWriter ("Filereader.java");

             int num=-1;
             //读取文件
             //int num=reader.read();
             //当未读取完文件时,写入文件

             while((num=reader.read())!=-1){
                 writer.write(num);
                 
             }
         
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally{
            //释放资源 
                try {
                    if(writer !=null)
                        writer.close();
                    if(reader !=null)
                        reader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            
            
        }
    }
}


方法二：数组读取（快）
package filereader;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class CopyFile {
    public static void main(String[] args) {
        copy1();
        System.out.println("done");
    }
    
    public static  void  copy1(){
        Reader  reader =null;
        Writer writer =null;
        try {
            //创建文件读取对象
    Reader=newFileReader("src3/filereader/Filereader.java");
        
            //创建写文件的对象
             writer =new FileWriter ("Filereader.java");
             //定义读取长度的对象
             int len=-1;
             //定义存储读取内容字符的数组
             char[] chs=new char[1024];
             //读取文件
             //int num=reader.read();
             //当len!=-1,就一直读取 
             while((len=reader.read(chs))!=-1){
                 //把读取的文件写到目标文件中
                 writer.write(chs, 0, len);
                 
             }
         
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally{
            //释放资源 
                try {
                    if(writer !=null)
                        writer.close();
                    if(reader !=null)
                        reader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            
            
        }
    }
}


高效缓冲区输入输出流
BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
构造方法摘要
BufferedReader(Reader in) 
          创建一个使用默认大小输入缓冲区的缓冲字符输入流。    
范例一：使用高效缓冲区来读取文件中的内容（建议使用数组读取，字符不够高效）
package buffer;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

public class bufferwriterdemo {
    public static void main(String[] args) {
        read();
        System.out.println("done");
        
    }
    //使用高效缓冲区向d.txt中写入“java太好学了，真简单”
    public static void read(){
        FileReader fr=null;
        BufferedReader br=null;
        try {
             fr=new FileReader("d.txt");
             //创建高效缓冲区的流对象
             br=new BufferedReader(fr);
             //输出数据
            int len=-1;
            char[] chs=new char[1024]; 
            
            while((len=br.read(chs))!=-1){
                
                System.out.println((new String(chs,0,len)));
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(br!=null)
            try {
                //关闭缓冲区会自动关闭FileWriter
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
    }

}



BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
构造方法摘要
BufferedWriter(Writer out) 
          创建一个使用默认大小输出缓冲区的缓冲字符输出流。    

范例二：使用高效缓冲区来向文件中写入一句话
package buffer;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class bufferwriterdemo {
    public static void main(String[] args) {
        writer();
        System.out.println("done");
        
    }
    //使用高效缓冲区向d.txt中写入“java太好学了，真简单”
    public static void writer(){
        FileWriter fe=null;
        BufferedWriter bw=null;
        try {
             fe=new FileWriter("d.txt");
             //创建高效缓冲区的流对象
             bw=new BufferedWriter(fe);
             //输出数据
             bw.write("java太好学了，真简单");
             bw.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(bw!=null)
            try {
                //关闭缓冲区会自动关闭FileWriter
                bw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
    }

}

换行的两种方法：
（1）.
   (2).bw.newLine
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;


public class iodemo {

    /**
     * @param args
     */
    
    public static void main(String[] args) {
        writeFile1();
        // TODO Auto-generated method stubf
        
    }
    public static void writeFile1() {
        // TODO Auto-generated method stubf
        
         FileWriter fw=null;
         BufferedWriter bw=null;
        try {
            //创建输出流的对象
            fw=new FileWriter("b.txt");
            bw=new BufferedWriter(fw);
            //把内容写到文件
            for(int i=0; i<10; i++){
                bw.write("hello write.");
                //字符流的特点 清空缓冲区 把内容写到文件中
                
                //相当于

                bw.newLine();
                
            }
            bw.flush();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
            
            if(fw !=null){
            
                try {
                    //close关闭输出流是清空缓冲区
                    fw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        

    }

}
 
读取一行数据readline
package filereader;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Filereader1 {
    public static void main(String[] args) {
        readerFile();
        
    }
    public static void readerFile(){
        FileReader fr=null; 
        BufferedReader br=null;
        try {
            //创建文件都去对象 两种方法
            fr=new FileReader("helloWord.txt");
             br=new BufferedReader(fr);
            //使用高效输入流可以读取一行数据
            String line=null;
            while((line=br.readLine())!=null){
                System.out.println(line);
                
            }
            
        } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        
        finally{
            
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                
            }
        }
    }

}

使用高效缓冲流进行复制

package filereader;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class CopyFile {
    public static void main(String[] args) {
        copy1();
        System.out.println("done");
    }
    
    public static  void  copy1(){
        Reader  reader =null;
        BufferedReader br=null;

        Writer writer =null;
        BufferedWriter bw=null;
        try {
            
             reader =new FileReader ("src3/filereader/Filereader.java");
             br=new BufferedReader(reader);
             
             
             writer =new FileWriter ("Filereader.java");
             bw=new BufferedWriter(writer);
             
             
             String line=null;
            
             while((line=br.readLine())!=null){
                 bw.write(line);
                 bw.newLine();
                 
             }
             bw.flush();
         
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally{
            //释放资源 
                try {
                    if(writer !=null)
                        writer.close();
                    if(reader !=null)
                        reader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            
            
        }
    }
}


加强版（绝对路径，无覆盖）
package filereader;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class CopyFile {
    public static void main(String[] args) {
        copy1();
        System.out.println("done");
    }
    
    public static  void  copy1(){
        Reader  reader =null;
        BufferedReader br=null;

        Writer writer =null;
        BufferedWriter bw=null;
        try {
            
             reader =new FileReader ("D:/helloWord.txt");
             br=new BufferedReader(reader);
             
             
             writer =new FileWriter ("D:/新建文本文档.txt",true);
             bw=new BufferedWriter(writer);
             
             
             String line=null;
            
             while((line=br.readLine())!=null){
                 bw.write(line);
                 bw.newLine();
                 
             }
             bw.flush();
         
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally{
            //释放资源 
                try {
                    if(writer !=null)
                        writer.close();
                    if(reader !=null)
                        reader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            
            
        }
    }
}




------------------------------------------------------------------------------------------------------------
以上都是字符流文本复制

三．字节流
字节输入流：InputStream:常用子类FileInputStream
字节输出流：OutputStreram:常用子类FileOutputStream
OutputStream:
构造方法摘要
FileOutputStream(File file) 
          创建一个向指定 File 对象表示的文件中写入数据的文件输出流。    
FileOutputStream(File file, boolean append) 
          创建一个向指定 File 对象表示的文件中写入数据的文件输出流。    
FileOutputStream(String name) 
          创建一个向具有指定名称的文件中写入数据的输出文件流。    
FileOutputStream(String name, boolean append) 
          创建一个向具有指定 name 的文件中写入数据的输出文件流。    
范例：使用在字节流项文件中写入helloword
package zijieliu;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class OutputStream {
    public static void main(String[] args) {
        writeFile();
    }
    
    
    public static void writeFile(){
        //使用字节流输出对象
        FileOutputStream out=null;
         try {
             out=new FileOutputStream("a.txt");
             String str="helloword";
            byte[] bs=str.getBytes();
            for(byte b:bs){
                //单个字节
                out.write(b);
            
            }
        } catch (FileNotFoundException e) {
            
            e.printStackTrace();
        } catch (IOException e) {
            
            e.printStackTrace();
        }finally{
            
            if(out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }

}

字节流输出流
package zijieliu;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class OutputStream {
    public static void main(String[] args) {
        writeFile();
    }
    
    
    public static void writeFile(){
        //使用字节流输出对象
        FileOutputStream out=null;
         try {
             //追加效果
             out=new FileOutputStream("a.txt",true);
             //效果一致
             //out=new FileOutputStream(new File("a.txt"));
            //out=new FileOutputStream(new File("a.txt"),true);
             String str="helloword";
            byte[] bs=str.getBytes();
               //
                //out.write(bs,0,5);
                out.write(bs);
            
            
        } catch (FileNotFoundException e) {
            
            e.printStackTrace();
        } catch (IOException e) {
            
            e.printStackTrace();
        }finally{
            
            if(out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }

}
package zijieliu;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class OutputStream {
    public static void main(String[] args) {
        readFile();
    }
    
    
    public static void readFile(){
        //使用字节流输出对象
        FileInputStream in=null;
         try {
             //追加效果
             in=new FileInputStream("a.txt");
             byte[] bs=new byte[1024];
             //读取文件  存储数组  从字节输入流去三个字节 从第一个索引位置开始
            int len= in.read(bs, 1, 3);
//            for(byte b:bs){
//                
//                System.out.print(b);
//            }
            System.out.println(new String(bs,1,len));
            
            
            
        } catch (FileNotFoundException e) {
            
            e.printStackTrace();
        } catch (IOException e) {
            
            e.printStackTrace();
        }finally{
            
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }

}

范例2：使用字节流来拷贝文件
package zijieliu;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class CopyFileDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        copyFile();

    }
    /*
     * 
     * 1.创建输入字节流的对象，输出字节流对象
     * 2.读取数据 并且写入数据
     * 3.关闭资源
     */
    public static void copyFile(){
        InputStream in=null;
        FileOutputStream out=null;
        try {
            
            in=new FileInputStream("src/zijieliu/OutputStream.java");
        
            out=new FileOutputStream("OutputStream.java");
            
            byte[] bs=new byte[1024];
            int len=-1;
            try {
                while((len=in.read(bs))!=-1){
                    //把字节数组中的数据写入到文件中
                    out.write(bs, 0, len);
                    
                }
            
            
        
        
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
              if(in!=null){
                  try {
                    in.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
            }
        }
        
        
        
        
        
    }

}

使用字节流来图片视频拷贝
package zijieliu;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class CopyFileDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        copyFile1();

    }
    /*
     * 
     * 1.创建输入字节流的对象，输出字节流对象
     * 2.读取数据 并且写入数据
     * 3.关闭资源
     */
    public static void copyFile(){
        InputStream in=null;
        FileOutputStream out=null;
        try {
            
            in=new FileInputStream("src/zijieliu/OutputStream.java");
        
            out=new FileOutputStream("OutputStream.java");
            
            byte[] bs=new byte[1024];
            int len=-1;
            try {
                while((len=in.read(bs))!=-1){
                    //把字节数组中的数据写入到文件中
                    out.write(bs, 0, len);
                    
                }
            
            
        
        
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
              if(in!=null){
                  try {
                    in.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
            }
        }
        
        
        
        
        
    }




public static void copyFile1(){
    InputStream in=null;
    FileOutputStream out=null;
    try {
        
        in=new FileInputStream("D:/1.mp4");
    
        out=new FileOutputStream("D:/q/1.mp4");
        
        byte[] bs=new byte[1024];
        int len=-1;
        try {
            while((len=in.read(bs))!=-1){
                //把字节数组中的数据写入到文件中
                out.write(bs, 0, len);
                
            }
        
        
    
    
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        if(out!=null){
            try {
                out.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
          if(in!=null){
              try {
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        }
    }
    
    
    
    
    
}

}

字节流的高效缓冲区（复制三种方法）
  
package zijieliu;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class CopyBufferFileDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        long startTime=System.currentTimeMillis();
        
        copyFile1();
        long endTime=System.currentTimeMillis();
        System.out.println("耗时："+(endTime-startTime)+"毫秒");

    }
    /*
     * 
     * 1.创建输入字节流的对象，输出字节流对象
     * 2.读取数据 并且写入数据
     * 3.关闭资源
     */
    public static void copyFile(){
        InputStream in=null;
        BufferedOutputStream out=null;
        try {
            //创建高效缓冲区输入流对象
            in=new BufferedInputStream(new FileInputStream("D:/1.mp4"));
        
            out=new BufferedOutputStream(new FileOutputStream("D:/q/1.mp4"));
            
        
            int len=-1;
            try {
                while((len=in.read())!=-1){
                    //把字节数组中的数据写入到文件中
                    out.write( len);
                    
                }
            
            
        
        
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
              if(in!=null){
                  try {
                    in.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
            }
        }
        
        
        
        
        
    }



//复制最快
public static void copyFile1(){
    InputStream in=null;
    FileOutputStream out=null;
    try {
        
        in=new FileInputStream("D:/1.mp4");
    
        out=new FileOutputStream("D:/q/1.mp4");
        
        byte[] bs=new byte[1024];
        int len=-1;
        try {
            while((len=in.read(bs))!=-1){
                //把字节数组中的数据写入到文件中
                out.write(bs, 0, len);
                
            }
        
        
    
    
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        if(out!=null){
            try {
                out.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
          if(in!=null){
              try {
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        }
    }
    
    
    
    
    
}

}

范例3：从键盘输入学生信息存储到文件中，学生按年龄排序。

package stu_model;

public class Student implements Comparable<Student> {
    private String name;
    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }


    private int age;
     

    @Override
    public int compareTo(Student o) {
        int num=this.age-o.getAge();
        if(num==0){
            
            num=this.name.compareTo(o.getName());
        }
        // TODO Auto-generated method stub
        return num;
    }

}


package stu_model;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
import java.util.TreeSet;

public class ScannerTest {
    public static void main(String[] args) {
        //定义学生的集合
        TreeSet<Student> ts=new TreeSet<Student>();
        //创建键盘输入对象
        Scanner sc=new Scanner (System.in);
        System.out.println("请输入你要输入几个学生:");
        int count=sc.nextInt();
        
        for(int i=0;i<count;i++){
            sc=new Scanner (System.in);
            //获得学身份姓名
            System.out.println("请输入学生姓名：");
            String name=sc.nextLine();
            //获得学生年龄
            System.out.println("请输入学生年龄：");
            Integer age=sc.nextInt();
            //创建一个学生的对象
            Student s=new Student();
            s.setAge(age);
            s.setName(name);
            //把学生加入到集合中
            ts.add(s);
            
            
        }
        BufferedWriter bw=null;
        try {
             bw=new BufferedWriter (new FileWriter("student"));
             for(Student s:ts){
                 bw.write(s.getName()+"----"+s.getAge());
                 bw.newLine();
                 
                 
             }
             bw.flush();//字节流要用flash
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(bw!=null){
                bw.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("写入文件完毕");
    }

}

设计模式之装饰者模式
装饰着模式的目的是给类的功能增强。
继承也能给类的功能增强。
Writer类是写文件的类：有三个子类TxtWriter.   Mp3Wrter.   AviWriter
在Writer 中定义了与文件的标准。三个文件分别去实现Writer 中写的方法
|------- TXTWriter.
   |----BufferedTxtWriter
|------- MP3Wrter.
   |----BufferedMP3Writer
|------- AVIWriter
   |----BufferedAVIWriter
如果想继续添加写文件的子类，如果想要对他做增强。还需要创建行营的缓冲区
装饰器的设计模式可以解决我们使用高效缓冲区，但是不需要每一个写文件的类都添加高效缓冲区
如果写文件的缓冲区是同样的原理，那么我们就可以把缓冲区抽取出来，作为装饰器
角色：
1.    抽象构件角色（定义写文件标准）：Writer

2.    具体构件角色（实现写文件标准）：三个子类TXTWriter.   MP3Wrter.   AVIWriter

3.    装饰角色（高效缓冲区）
代码示例
装饰者代码拓展
字符流和字节流的转换桥梁
范例：把从键盘输入的文本写入文件中 
代码
家
package xiejpan_wjian;
import java.util.*;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;

public class ScannerDemo {
    

    

    public static void main(String[] args) {
        
        //创建一个Scanner对象
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入数据：");
        
        BufferedWriter bw=null;
        try {
           bw=new BufferedWriter(new FileWriter("c.txt"));
           String line=null;
           while((line=sc.nextLine())!=null){
               if("exit".equals(line)){
                   break;
                  
               }
               bw.write(line);
               bw.newLine();
               bw.flush();
               
               
           }
           
           
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
            if(bw!=null){
                
                try {
                    bw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
        }
    }

    private String nextLine() {
        // TODO Auto-generated method stub
        return null;
    }

}

1.字节流转向字符流（InputStreamReader(System.in));）
package xiejpan_wjian;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;


public class converterINDemo {
    

    

    public static void main(String[] args) {
                //字符流和字节流的转换
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        //定义写入的文件夹
        
        BufferedWriter bw=null;
        try {
             bw=new BufferedWriter(new FileWriter("w.txt"));
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        
        String line=null;
        try {
            while((line=br.readLine())!=null){
                if("exit".equals(line)){
                    
                    break;
                }
                bw.write(line);
                bw.newLine();
                bw.flush();
                
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    
}
}

2.字符流转换成字节流new OutputStreamWriter(System.out));
范例：从一个文件中读取内容使用标准字节流来输出到控制台（使用字符串操作）
package xiejpan_wjian;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;


public class converterOUTDemo {
    

    

    public static void main(String[] args) {
        BufferedWriter bw=null;
        BufferedReader br=null;
        try {
           br=new BufferedReader(new FileReader("w.txt"));
           bw=new BufferedWriter(new OutputStreamWriter(System.out));
           String line=null;
           try {
            while((line=br.readLine())!=null){
                   bw.write(line);
                   bw.newLine();
                   bw.flush();
               }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
           
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
            if(bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
            if(br!=null){
                
                try {
                    br.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
        }
        
}
}

打印流（强大）
打印流只做输出 没有输入
打印流分为字节打印流和字符打印流
PrintWriter:字符打印流
特点
1.    可以打印各种数据流
2.    封装了字符输出流，还可以字符流和字节流转换
3.    可以自动使用自动刷新，只有在调用println  printf 或format时才可能完成此操作
4.    可以直接想文件中写数据
PrintWriter

package print;

import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class printDemo {
    public static void main(String[] args) {
        //System.out.println("helloword");
        PrintWriter pw=null;
        try {
         pw=new PrintWriter("b.txt");
         pw.print(true);
         pw.print('q');
         pw.print("rwn");
         pw.print(12);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
    
            
            
            if(pw!=null){
                pw.close();
                
            }
        }
        
    }
    

}
范例：从文件中读取数据并且打印在控制台
package print;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;

public class printDemo1 {
    public static void main(String[] args) {
        //定义缓冲区输入流对象
        BufferedReader br=null;
         PrintWriter pw=null;
      try {
         br=new BufferedReader(new FileReader("a.txt"));
         // pw=new PrintWriter(System.out);
         //设置自动刷新
         pw=new PrintWriter(System.out,true);
         String line=null;
     try {
        while((line=br.readLine())!=null){
              pw.print(line);
             pw.flush();
             
         }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
         
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        if(pw!=null){
            
            
            pw.close();
        }
        if(br!=null){
            
            try {
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
    }
        
    }
    

}
范例：使用打印流来复制文本文件
package print;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class printDemo1 {
    public static void main(String[] args) {
        //定义缓冲区输入流对象
        BufferedReader br=null;
         PrintWriter pw=null;
      try {
         br=new BufferedReader(new FileReader("a.txt"));
         // pw=new PrintWriter(System.out);
         //设置自动刷新
        // pw=new PrintWriter(System.out,true);
         try {
            pw=new PrintWriter(new FileWriter("a1.txt"),true);
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
         String line=null;
     try {
        while((line=br.readLine())!=null){
              pw.print(line);
                         
         }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
         
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        if(pw!=null){
            
            
            pw.close();
        }
        if(br!=null){
            
            try {
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
    }
        
    }
    

}
187over
Properties类
Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
特点： 
1.    继承与HashTable,是线程安全的键值对存储数据
2.    Properties可保存在流中或从流中加载
3.    只保存字符串的键值对，
构造器 
构造方法摘要
Properties() 
          创建一个无默认值的空属性列表。    

代码示例

List
package Properties;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

public class Properties2 {
    public static void main(String[] args) {
        
        Properties prop=new Properties();
        
        prop.setProperty("name","zhangsan ");
        prop.setProperty("gender", "male");
        prop.setProperty("age", "10");
        PrintWriter pw =null;
        try {
             pw =new PrintWriter(new FileWriter("prop1.txt"));
               prop.list(pw);
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
            if(pw!=null){
                
                pw.close();
                
            }
        }
        
        
    }

}
Load
package Properties;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

public class Properties3 {
    public static void main(String[] args) {
        
        Properties prop=new Properties();
        FileReader fr=null;
        
        
        try {
             fr=new FileReader("prop1.txt");
             prop.load(fr);
             String name=prop.getProperty("name");
             String age=prop.getProperty("age");
             String gender=prop.getProperty("gender");
             System.out.println(name);
             System.out.println(age);
             System.out.println(gender);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
            if(fr!=null){
                
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
        }
        
        
    }

}
Store
package Properties;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

public class Properties5 {
    public static void main(String[] args) {
        
     Properties prop=new Properties();
        
        prop.setProperty("name","zhangsan ");
        prop.setProperty("gender", "male");
        prop.setProperty("age", "10");
        FileWriter fw=null;
        try {
            fw=new FileWriter("prop2.txt");
            prop.store(fw,null);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            
            if(fw!=null){
                
                try {
                    fw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
        }
        
        
    }

}
四．线程
1.线程的概述
进程：计算机中特定功能的程序在数据集上的一次一年运行
线程：线程是进程的一个单元
多线程：一个进程有多个线程在同时运行，如寻来的下载 迅雷运行一次就是一个进程，那么在迅雷中可以同时下载等多个电影 ，这就是多线程（每一个下载都是一个线程）
Jvm是多线程的，在我们运行Jvm 时候后台会运行垃圾回收的线程，来清理没有被引用的对象。







2.线程的实现方法一
 创建新执行线程两种方法，（1）酱类声明为Thread的子类 该子类应重写 Thread类的run方法。接下来而可以分配并启动盖子类的实例，
线程启动的时候使用线程的start方法 而我不是run 
package Tread;

public class treaddemo {

    
    public static void main(String[] args) {
        //创建现成的实例对象
        CountThread ct=new CountThread();
        CountThread ct1=new CountThread();
        
           //并不是线程 只是调用run方法 ct.run();
        //启动线程(双启动)
        ct.start();
        ct1.start();

    }

}

package Tread;

public class CountThread extends Thread {
    //线程的执行体
    @Override
    public void run() {
        for(int i=0;i<17;i++){
            System.out.println(this.getName()+"hello"+i);
            
        }
        // TODO Auto-generated method stub
        
    }


    
}


.线程的实现方法二
创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。
示例代码：
package Tread;

public class CountThread1 implements Runnable {

    @Override
    public void run() {
        for(int i=0;i<17;i++){
            //输出线程的名字
            System.out.println(Thread.currentThread().getName()+"---hello"+i);
            
        }

}
}

测试代码
package Tread;

public class treaddemo1 {

    
    public static void main(String[] args) {
        //创建两个线程
        CountThread1 ct =new CountThread1();
        //实际工程中很少命名
        //Thread t1 =new Thread(ct,"线程一");
        Thread t1 =new Thread(ct);
        CountThread1 ct2 =new CountThread1();
        //Thread t2 =new Thread(ct2,"线程二");
        Thread t2 =new Thread(ct2);
        t1.start();
        t2.start();
    
        
        
    }

}

197over
3.线程的执行原理



                三个随机开始（抢资源）










线程的并发执行通过多个线程不断的切换CPU的资源这个速度非常快，我么嗯感受不到 我们能感受到的就是三个个线程在并发的执行
4.    线程的生命周期
1.    新建：线程被NEW出来
2.    准备就绪：线程具有执行资格，即线程调用了START()
3.    运行：具备执行的资格和执行的权力。
4.    阻塞：没有执行资格和执行权力
5.    销毁：线程的对象变成垃圾，释放资源
 
    Start()


Sleep时间到    等cpu的状态
Notify()    强到cpu
    
    Sleep()    Run()结束

    Wait()


5.并发
互联网的项目中存在着大量的并发案例，如买火车票 电商项目
范例：火车站有一百张票 4个窗口同是卖
分析：四个窗口是四个线程同时运行 100张票四个线程的共享资源
采用继承Thread来实现(并发问题：避免两个窗口同时卖一张票)

线程一    线程二







    解决方案：







针对线程的案的安全性，我们需要使用同步（就是加锁，共享资源只能一个人同时访问）
语法：synchronized（锁对象（非共享））{
//操作共享资源的代码
}
同步代码加在什么地方？
1.    代码同时多个线程访问
2.    代码中有共享资源
3.    共享数据被多条语句操作
package tickets;
/*
4.     * 
5.     * 买票的床口
6.     */
7.    public class selltickets extends  Thread{
8.        
9.        private String name;
10.        public selltickets(String name) {
11.            super(name);
12.        
13.            
14.        }
15.        
16.        //100 张票是共享资源
17.        private  static int tickets  = 100;
18.        
19.        //同步钥匙(一把钥匙)
20.        //private static Object obj=new Object();
21.        private static A a=new A();
22.        public void run() {
23.            while(true){
24.                
25.                synchronized(a){
26.                if(tickets>0){
27.                    try {
28.                        //放慢线程运行速度
29.                        Thread.sleep(20);
30.                    } catch (InterruptedException e) {
31.                        // TODO Auto-generated catch block
32.                        e.printStackTrace();
33.                    }
34.                    System.out.println(this.getName()+"正在卖"+tickets--+"票");
35.                }else{
36.                    
37.                    System.out.println("票已经售完了");
38.                    break;
39.                }
40.                }
41.            }
42.            
43.            // TODO Auto-generated constructor stub
44.        }
45.    
46.        
47.    
48.    
49.        
50.    
51.    }
52.    class A{
53.        54.        55.    }
package tickets;

public class TicketsTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        selltickets st1=new selltickets("窗口一");
        selltickets st2=new selltickets("窗口二");
        selltickets st3=new selltickets("窗口三");
        selltickets st4=new selltickets("窗口四");
        st1.start();
        st2.start();
        st3.start();
        st4.start();

    }

}

Synchronized同步代码块的锁定对象可以是任意的类对象 （线程的实现方式是继承于Thread）这个对象必须是线程共享的（静态的）
Synchronized是可以加在方法上的，如果是静态方法Synchronized的锁对象就是类的类对象，如果不是静态的方法，Synchronized如果加在对象方法上，那么他的锁是this
实例；
package tickets1;
/*
 * 
 * 买票的床口
 */
public class selltickets implements  Runnable{
    
    
    //100 张票是共享资源
    private int tickets  = 100;
    private Object obj =new Object();
    //同步钥匙(一把钥匙)
    //private static Object obj=new Object();
    //private static A a=new A();
    public void run() {
        while(true){
            int i=0;
            if(i%2==0){
            //同步代码块
            synchronized(obj){
            if(tickets>0){
                try {
                    //放慢线程运行速度
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在卖"+tickets--+"票");
            }else{
                
                System.out.println("票已经售完了");
                break;
            }
            }
            }else {
                //同步代码块
                
                    if(tickets>0){
                        try {
                            //放慢线程运行速度
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在卖"+tickets--+"票");
                    }else{
                        
                        System.out.println("票已经售完了");
                        break;
                    }
                    }
                //saleTickets();
                i++;
            }
            
        }
}
    
        /*
         * 静态方法synchronized锁是当前类的类对象
         * 
         */
        // TODO Auto-generated constructor stub
    /*public synchronized  void saleTickets(){
        
            if(tickets>0){
                try {
                    //放慢线程运行速度
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在卖"+tickets--+"票");
            }else{
                
                System.out.println("票已经售完了");
                
            }
            }
        
    }*/
package tickets1;

public class TicketsTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        selltickets st1=new selltickets();
        Thread t1=new Thread(st1,"窗口1");
        Thread t2=new Thread(st1,"窗口2");
        Thread t3=new Thread(st1,"窗口3");
        Thread t4=new Thread(st1,"窗口4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }

}

6.    线程的休眠
在线程的休眠是必要的，在做服务端的时候为了减少服务器的压力我们需要休眠，如果休眠是在同步代码块中执行，休眠不会让出锁对象。
7.线程之间的通信
生产者和消费者


生产者线程    消费者线程






生产者生成水果，如果水果没有被买走那么就不生产处于等待状态，如果水果被消费者买走就生产买走的时候会通知生产者告诉他我们已经把水果买走了请生产，消费者同理，如果水果已经生产出来那么就买走 ，买走之后再通知生产者水果偶已经没了请生产。

注意：1.线程间的通信共享数据一定要在同步代码块synchronized：
      2.一定要有wait和notify ,而且二者一定是成对出现 
      3.生产者和消费者的线程实现一定是在while(true)中
示例代码：

Tx
8线程优先级
通过 public final void setPriority (int newPriority) 来设置线程的有优先级 但是优先级并不是绝对大的 只是相对其他的线程得到的CPU资源更多一些。（随机性）
示例代码：
package prio;

public class prioThread extends Thread {
    
    private String name;

    public prioThread(String name) {
        //super();
        this.name=name;
        
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            
            System.out.println(this.getName()+"正在运行"+i);
        }
    
    }
    

}

package prio;

public class prioTest {
    public static void main(String[] args) {
        prioThread pt =new prioThread("线程1");
        prioThread pt1 =new prioThread("线程2");
        prioThread pt2 =new prioThread("线程3");
        /*System.out.println(pt.getPriority());
        System.out.println(pt1.getPriority());
        System.out.println(pt2.getPriority());*/
        pt.setPriority(10);
        
        pt.start();
        pt1.start();
        pt2.start();
        
        
    }
    
    

}

9.加入线程
join 线程都会抢先执行CPU执行线程 其他线程再来执行
package prio.join;

public class joinThread extends Thread {
    
    private String name;

    public joinThread(String name) {
        //super();
        this.name=name;
        
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            
            System.out.println(this.getName()+"正在运行"+i);
        }
    
    }
    

}

package prio.join;

public class joinTest {
    public static void main(String[] args) {
        joinThread pt =new joinThread("线程1");
        joinThread pt1 =new joinThread("线程2");
        joinThread pt2 =new joinThread("线程3");
        /*System.out.println(pt.getPriority());
        System.out.println(pt1.getPriority());
        System.out.println(pt2.getPriority());*/
        pt.setPriority(10);
        
        pt2.start();
        try {
            //join 线程都会抢先执行CPU 来执行线程 其他线程再来执行
            pt2.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        pt.start();
        pt1.start();
        
        
        
    }
    
    

}

10.等待线程
Static void    Vield()
暂停的当前正在执行的线程对象并执行其他线程
当前的线程从运行回到就绪状态 目的把CPU资源让给其他线程
package prio.yield;

public class yieldThread extends Thread {
    
    private String name;

    public yieldThread(String name) {
        //super();
        this.name=name;
        
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            
            System.out.println(this.getName()+"正在运行"+i);
            //当前线程回到就绪状态 让出CPU （谦让执行 ）
            Thread.yield();
        }
    
    }
    

}

package prio.yield;

public class yieldTest {
    public static void main(String[] args) {
        yieldThread pt =new yieldThread("线程1");
        yieldThread pt1 =new yieldThread("线程2");
        yieldThread pt2 =new yieldThread("线程3");
        
        
        pt2.start();
        pt.start();
        pt1.start();
        
        
        
    }
    
    

}

11．守护线程
Void    SetDaemon(Boolean on)
将线程标记为守护线程或用户线程
守护线程会随着主线程的结束而结束
package prio.daemon;

public class daemonThread extends Thread {
    
    private String name;

    public daemonThread(String name) {
        //super();
        this.name=name;
        
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            
            System.out.println(this.getName()+"正在运行"+i);
            //当前线程回到就绪状态 让出CPU （谦让执行 ）
            Thread.yield();
        }
    
    }
    

}

package prio.daemon;

public class daemonTest {
    public static void main(String[] args) {
        daemonThread pt =new daemonThread("线程1");
        daemonThread pt1 =new daemonThread("线程2");
        
        
        
        pt.setDaemon(true);
        pt1.setDaemon(true);
        pt.start();
        pt1.start();
        for(int i=0;i<10;i++){
            
            System.out.println(Thread.currentThread().getName()+"线程正在在运行"+i);
        }
        
        
    }
    
    

}

12.线程死锁








示例代码：
package dirrlock;

public class Lock {
    static Object lock1 =new Object(); 
    static Object lock2 =new Object(); 
    

}

package dirrlock;

public class DirLockDemo  implements Runnable{
    private boolean flag;
   
    public DirLockDemo(boolean flag) {
        super();
        this.flag = flag;
    }

    public void run() {
        if(flag){
            synchronized (Lock.lock1){
                System.out.println("线程1 拿到带第1把锁");
                synchronized (Lock.lock2) {
                    System.out.println("线程1拿到带第2把锁");
                    
                }
                
            }
            
        }else{
            
            synchronized (Lock.lock2) {
                System.out.println("线程2拿到带第2把锁");
                synchronized (Lock.lock1) {
                    System.out.println("线程2拿到带第1把锁");
                    
                }
            }
        }
        
    }
    

}

package dirrlock;

public class DieLockTest {
    public static void main(String[] args) {
        DirLockDemo dl1=new DirLockDemo(true);
        DirLockDemo dl2=new DirLockDemo(true);
        
        Thread t1=new Thread(dl1);
        Thread t2=new Thread(dl2);
        t1.start();
        t2.start();
        
        
        
    }

}

五．网络编程
网络通信三大条件：
IP   端口  协议
package net1;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPClient {
    public static void main(String[] args) {
        // 创建客户端的套换字对象
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket();
            byte[] bs = "你好".getBytes();
            // 创建要发送的目的地IP对象
            InetAddress ia = InetAddress.getByName("192.168.1.1");
            // 打数据包
            DatagramPacket dp = new DatagramPacket(bs, bs.length, ia, 10000);
            // 发送
            ds.send(dp);

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (ds != null) {
                ds.close();
            }
        }
    }

}
package net1;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;


public class UDPCSerever {
    public static void main(String[] args) {
        // 创建UDP服务端对象 必须指定端口
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(10000);

            // 定义接受数据字节的数组
            byte[] bs = new byte[1024];
            // 定义接收的数据包
            DatagramPacket dp = new DatagramPacket(bs, bs.length);
            System.out.println("服务器已启动");
            // 数据包的接收
            ds.receive(dp);
            // 获得发送端的IP
            InetAddress ia = dp.getAddress();
            // 获取数据包中的数据,这个数组的长度是我们自己定义时的长度（1024）
            byte[] bs1 = dp.getData();
            //获得接受数据的长度（实际接受的数据的长度）
            int len =dp.getLength();
            // 组装接受的数据
            String data = new String(bs1, 0, len);
            System.out.println(ia.getHostAddress() + "发送了：" + data);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {

            if (ds != null) {

                ds.close();
            }
        }

    }

}