public static void main(String[] args) throws IOException { //读、写都会发生IO异常
       /*
       1：创建一个字符输出流对象，用于操作文件。该对象一建立，就必须明确数据存储位置，是一个文件。
       2：对象产生后，会在堆内存中有一个实体，同时也调用了系统底层资源，在指定的位置创建了一个存储数据的文件。
       3：如果指定位置，出现了同名文件，文件会被覆盖。
       */
       FileWriter fw = new FileWriter("demo.txt"); // FileNotFoundException
       /*
       调用Writer类中的write方法写入字符串。字符串并未直接写入到目的地中，而是写入到了流中，(其实是写入到内存缓冲区中)。怎么把数据弄到文件中？
       */
       fw.write("abcde");
       fw.flush(); // 刷新缓冲区，将缓冲区中的数据刷到目的地文件中。
       fw.close(); // 关闭流，其实关闭的就是java调用的系统底层资源。在关闭前，会先刷新该流。
}
close()和flush()的区别：
flush()：将缓冲区的数据刷到目的地中后，流可以使用。
close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。

public static void main(String[] args) {
              FileWriter fw = null;
              try {
                     fw = new FileWriter("demo.txt",true);
                     fw.write("abcde");
              }
              catch (IOException e ){
                     System.out.println(e.toString()+"....");
              }
              finally{
                     if(fw!=null)
                            try{
                                   fw.close();
                            }
                            catch (IOException e){
                                   System.out.println("close:"+e.toString());
                            }
              }
}

import java.io.*;
class  FileReaderDemo {
       public static void main(String[] args) throws IOException {
              /*
              创建可以读取文本文件的流对象，FileReader让创建好的流对象和指定的文件相关联。
              */
              FileReader fr = new FileReader("demo.txt");
              int ch = 0;
              while((ch = fr.read())!= -1) { //条件是没有读到结尾
                     System.out.println((char)ch); //调用读取流的read方法，读取一个字符。
              }
              fr.close();
       }
}

import java.io.*;
class FileReaderDemo2 {
       public static void main(String[] args) throws IOException {
              FileReader fr = new FileReader("demo.txt"); //创建读取流对象和指定文件关联。
              //因为要使用read(char[])方法，将读取到字符存入数组。所以要创建一个字符数组，一般数组的长度都是1024的整数倍。
              char[] buf = new char[1024];
              int len = 0;
              while(( len=fr.read(buf)) != -1) {
                     System.out.println(new String(buf,0,len));
              }
              fr.close();
       }
}

FileWriter fw = new FileWriter("bufdemo.txt");
    BufferedWriter bufw = new BufferedWriter(fw);//让缓冲区和指定流相关联。
    for(int x=0; x<4; x++){
        bufw.write(x+"abc");
        bufw.newLine(); //写入一个换行符，这个换行符可以依据平台的不同写入不同的换行符。
        bufw.flush();//对缓冲区进行刷新，可以让数据到目的地中。
    }
    bufw.close();//关闭缓冲区，其实就是在关闭具体的流

//读取键盘录入将数据转成大写显示在控制台.
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//源：键盘输入
//目的：把数据写到文件中，还想自动刷新。
PrintWriter out = new PrintWriter(new FileWriter("out.txt"),true);//设置true后自动刷新
String line = null;
while((line=bufr.readLine())!=null){
    if("over".equals(line))
        break;
    out.println(line.toUpperCase());//转大写输出
}
    //注意：System.in，System.out这两个标准的输入输出流，在jvm启动时已经存在了。随时可以使用。当jvm结束了，这两个流就结束了。但是，当使用了显示的close方法关闭时，这两个流在提前结束了。
out.close();
bufr.close();

import java.io.*;
import java.util.*;
class  SplitFileDemo{
    private static final String CFG = ".properties";
    private static final String SP = ".part";
    public static void main(String[] args) throws IOException{
        File file = new File("c:\\0.bmp");
        File dir = new File("c:\\partfiles");
        meger(dir);
    }
    //数据的合并。
    public static void meger(File dir)throws IOException{
        if(!(dir.exists() && dir.isDirectory()))
            throw new RuntimeException("指定的目录不存在，或者不是正确的目录");
        File[] files = dir.listFiles(new SuffixFilter(CFG));
        if(files.length==0)
            throw new RuntimeException("扩展名.proerpties的文件不存在");
        //获取到配置文件
        File config = files[0];
        //获取配置文件的信息。
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream(config);
        prop.load(fis);
        String fileName = prop.getProperty("filename");
        int partcount = Integer.parseInt(prop.getProperty("partcount"));
        //--------------------------
        File[] partFiles = dir.listFiles(new SuffixFilter(SP));
        if(partFiles.length!=partcount)
            throw new RuntimeException("缺少碎片文件");
        //---------------------
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        for(int x=0; x<partcount; x++){
            al.add(new FileInputStream(new File(dir,x+SP)));
        }
        Enumeration<FileInputStream> en = Collections.enumeration(al);
        SequenceInputStream sis = new SequenceInputStream(en);
        File file = new File(dir,fileName);
        FileOutputStream fos = new FileOutputStream(file);
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=sis.read(buf))!=-1){
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }
    //带有配置信息的数据切割。
    public static void splitFile(File file)throws IOException{
        //用一个读取流和文件关联。
        FileInputStream fis = new FileInputStream(file);
        //创建目的地。因为有多个。所以先创建引用。
        FileOutputStream fos = null;
        //指定碎片的位置。
        File dir = new File("c:\\partfiles");
        if(!dir.exists())
            dir.mkdir();
        //碎片文件大小引用。
        File f = null;
        byte[] buf = new byte[1024*1024];
        //因为切割完的文件通常都有规律的。为了简单标记规律使用计数器。
        int count = 0;
        int len = 0;
        while((len=fis.read(buf))!=-1){
            f = new File(dir,(count++)+".part");
            fos = new FileOutputStream(f);
            fos.write(buf,0,len);
            fos.close();
        }
        //碎片文件生成后，还需要定义配置文件记录生成的碎片文件个数。以及被切割文件的名称。
        //定义简单的键值信息，可是用Properties。
        String filename = file.getName();
        Properties prop = new Properties();
        prop.setProperty("filename",filename);
        prop.setProperty("partcount",count+"");
        File config = new File(dir,count+".properties");
        fos = new FileOutputStream(config);
        prop.store(fos,"");
        fos.close();
        fis.close();
    }
}
class SuffixFilter implements FileFilter{
    private String suffix;
    SuffixFilter(String suffix){
        this.suffix  = suffix;
    }
    public boolean accept(File file){
        return  file.getName().endsWith(suffix);
    }
}

class RandomAccessFileDemo{
    public static void main(String[] args) throws IOException{
        write();
        read();
        randomWrite();
    }
    //随机写入数据，可以实现已有数据的修改。
    public static void randomWrite()throws IOException{
        RandomAccessFile raf = new RandomAccessFile("random.txt","rw");
        raf.seek(8*4);
        System.out.println("pos :"+raf.getFilePointer());
        raf.write("王武".getBytes());
        raf.writeInt(102);
        raf.close();
    }
    public static void read()throws IOException{
        RandomAccessFile raf = new RandomAccessFile("random.txt","r");//只读模式。
        //指定指针的位置。
        raf.seek(8*1);//实现随机读取文件中的数据。注意：数据最好有规律。
        System.out.println("pos1 :"+raf.getFilePointer());
        byte[] buf = new byte[4];
        raf.read(buf);
        String name = new String(buf);
        int age = raf.readInt();
        System.out.println(name+"::"+age);
        System.out.println("pos2 :"+raf.getFilePointer());
        raf.close();
    }
    public static void write()throws IOException{
        //rw：当这个文件不存在，会创建该文件。当文件已存在，不会创建。所以不会像输出流一样覆盖。
        RandomAccessFile raf = new RandomAccessFile("random.txt","rw");//rw读写模式
        //往文件中写入人的基本信息，姓名，年龄。
        raf.write("张三".getBytes());
        raf.writeInt(97);
        raf.close();
    }
}

public static void main(String[] args) throws IOException{
    PipedInputStream pipin = new PipedInputStream();
    PipedOutputStream pipout = new PipedOutputStream();
    pipin.connect(pipout);
    new Thread(new Input(pipin)).start();
    new Thread(new Output(pipout)).start();
}

import java.io.*;
class ObjectStreamDemo {
    public static void main(String[] args) throws Exception{
        writeObj();
        readObj();
    }
    public static void readObj()throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
        Object obj = ois.readObject();//读取一个对象。
        System.out.println(obj.toString());
    }
    public static void writeObj()throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
        oos.writeObject(new Person("lisi",25)); //写入一个对象。
        oos.close();
    }
}
class Person implements Serializable{
    private static final long serialVersionUID = 42L;
    private transient String name;//用transient修饰后name将不会进行序列化
    public int age;
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return name+"::"+age;
    }
}

DataOutputStream dos =  new DataOutputStream(new FileOutputStream("data.txt"));
    dos.writeInt(256);
    dos.close();
    DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
    int num = dis.readInt();
    System.out.println(num);
    dis.close();

//创建源：
    ByteArrayInputStream bis = new ByteArrayInputStream("abcdef".getBytes());
    //创建目的：
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    int ch = 0;
    while((ch=bis.read())!=-1){
        bos.write(ch);
    }
    System.out.println(bos.toString());

import java.net.*;
class  IPDemo{
    public static void main(String[] args) throws UnknownHostException{
        //通过名称(ip字符串or主机名)来获取一个ip对象。
        InetAddress ip = InetAddress.getByName("www.baidu.com");//java.net.UnknownHostException
        System.out.println("addr:"+ip.getHostAddress());
        System.out.println("name:"+ip.getHostName());
    }
}

import java.net.*;
class  UdpSend{
    public static void main(String[] args)throws Exception {
//      1，建立udp的socket服务。
        DatagramSocket ds = new DatagramSocket(8888);//指定发送端口，不指定系统会随机分配。
//      2，明确要发送的具体数据。
        String text = "udp传输演示 哥们来了";
        byte[] buf = text.getBytes();
//      3，将数据封装成了数据包。
        DatagramPacket dp = new DatagramPacket(buf,
buf.length,InetAddress.getByName("10.1.31.127"),10000);
//      4，用socket服务的send方法将数据包发送出去。
        ds.send(dp);
//      5，关闭资源。
        ds.close();
    }
}

class UdpRece {
    public static void main(String[] args) throws Exception{
//      1，创建udp的socket服务。
        DatagramSocket ds = new DatagramSocket(10000);
//      2，定义数据包，用于存储接收到数据。先定义字节数组，数据包会把数据存储到字节数组中。
        byte[] buf = new byte[1024];
        DatagramPacket dp = new DatagramPacket(buf,buf.length);
//      3，通过socket服务的接收方法将收到的数据存储到数据包中。
        ds.receive(dp);//该方法是阻塞式方法。
//      4，通过数据包的方法获取数据包中的具体数据内容，比如ip，端口，数据等等。
        String ip = dp.getAddress().getHostAddress();
        int port = dp.getPort();
        String text = new String(dp.getData(),0,dp.getLength());//将字节数组中的有效部分转成字符串。
        System.out.println(ip+":"+port+"--"+text);
//      5，关闭资源。
        ds.close();
    }
}

--------------------------------------------------------------
import java.net.*;
import java.io.*;
//需求：客户端给服务器端发送一个数据。
class  TcpClient{
    public static void main(String[] args) throws Exception{
        Socket s = new Socket("10.1.31.69",10002);
        OutputStream out = s.getOutputStream();//获取了socket流中的输出流对象。
        out.write("tcp演示，哥们又来了!".getBytes());
        s.close();
    }
}
--------------------------------------------------------------

--------------------------------------------------------------
class  TcpServer{
    public static void main(String[] args) throws Exception{
        ServerSocket ss = new ServerSocket(10002);//建立服务端的socket服务
        Socket s = ss.accept();//获取客户端对象
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip+".....connected");
//      可以通过获取到的socket对象中的socket流和具体的客户端进行通讯。
        InputStream in = s.getInputStream();//读取客户端的数据，使用客户端对象的socket读取流
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        String text = new String(buf,0,len);
        System.out.println(text);
//      如果通讯结束，关闭资源。注意：要先关客户端，在关服务端。
        s.close();
        ss.close();
    }
}

// 如何生成获取到字节码文件对象的实例对象。
        Class clazz = Class.forName("cn.itcast.bean.Person");//类加载
// 直接获得指定的类型
       clazz = Person.class;
       // 根据对象获得类型
       Object obj = new Person("zhangsan", 19);
       clazz = obj.getClass();
        Object obj = clazz.newInstance();//该实例化对象的方法调用就是指定类中的空参数构造函数，给创建对象进行初始化。当指定类中没有空参数构造函数时，该如何创建该类对象呢？请看method_2();
    public static void method_2() throws Exception {
        Class clazz = Class.forName("cn.itcast.bean.Person");
        //既然类中没有空参数的构造函数,那么只有获取指定参数的构造函数,用该函数来进行实例化。
        //获取一个带参数的构造器。
        Constructor constructor = clazz.getConstructor(String.class,int.class);
        //想要对对象进行初始化，使用构造器的方法newInstance();
        Object obj = constructor.newInstance("zhagnsan",30);
        //获取所有构造器。
        Constructor[] constructors = clazz.getConstructors();//只包含公共的
        constructors = clazz.getDeclaredConstructors();//包含私有的
        for(Constructor con : constructors) {
            System.out.println(con);
        }
    }
------------------------------------------------------
反射指定类中的方法：
    //获取类中所有的方法。
    public static void method_1() throws Exception {
        Class clazz = Class.forName("cn.itcast.bean.Person");
        Method[] methods = clazz.getMethods();//获取的是该类中的公有方法和父类中的公有方法。
        methods = clazz.getDeclaredMethods();//获取本类中的方法，包含私有方法。
        for(Method method : methods) {
            System.out.println(method);
        }
    }
    //获取指定方法；
    public static void method_2() throws Exception {
        Class clazz = Class.forName("cn.itcast.bean.Person");
        //获取指定名称的方法。
        Method method = clazz.getMethod("show", int.class,String.class);
        //想要运行指定方法，当然是方法对象最清楚，为了让方法运行，调用方法对象的invoke方法即可，但是方法运行必须要明确所属的对象和具体的实际参数。
        Object obj = clazz.newInstance();
        method.invoke(obj, 39,"hehehe");//执行一个方法
    }
    //想要运行私有方法。
    public static void method_3() throws Exception {
        Class clazz = Class.forName("cn.itcast.bean.Person");
        //想要获取私有方法。必须用getDeclearMethod();
        Method method = clazz.getDeclaredMethod("method", null);
        // 私有方法不能直接访问，因为权限不够。非要访问，可以通过暴力的方式。
        method.setAccessible(true);//一般很少用，因为私有就是隐藏起来，所以尽量不要访问。
    }
    //反射静态方法。
    public static void method_4() throws Exception {
        Class clazz = Class.forName("cn.itcast.bean.Person");
        Method method = clazz.getMethod("function",null);
        method.invoke(null,null);
    }