Java的I/O框架、网络编程、反射

【Java总结】

目录
I/O框架
什么是流
流的分类
字节流
字符编码
字符流
字符节点流
File
网络编程
计算机网络
网络模型
TCP/IP模型
TCP/UDP
IP
InetAddress
基于TCP的网络编程
反射
类的对象
类对象
获取类对象
常用方法
工厂设计模式
单例模式
I/O框架
什么是流
内存与存储设备之间传输数据的通道
流的分类
方向
输入流 : 将存储设备中的内容读入到内存中
输出流 : 将内存中的内容写入到存储设备中
单位
字节流 : 以字节为单位,可以读写所有数据
字符流 : 以字符为单位,只能读写文本数据
功能
节点流 : 具有实际传输数据的读写功能
过滤流 : 在节点流的基础上增强功能
字节流
InputStream抽象类
OutputStream抽象类
字节节点流
FileInputStream
FileOutputStream
字节过滤流
BufferedOutputStream
BufferedInputStream
提供了IO效率,减少访问磁盘的次数。数据存放在缓冲区中。flush()刷新缓冲区,提交数据
对象流
ObjectInputStream
ObjectOutputStream
增强读写8中基本数据类型和字符串功能
读写对象,可以实现对象的持久化存储
序列化和反序列化
必须实现接口Serializable
必须保证所有属性均支持序列化
Transient修饰的为临时属性,不参与序列化
读取到文件末尾时:java.IO.EOFException
public class TestInputAndOutputStream {
























































List<String> testList = new ArrayList<String>(); 
static String path = "./src/txt/a.txt";
public static void main(String[] args) {

    //testFileOutPut();
    //testFileInput();
    //testBufferedInput();
    //testBufferedOutput();
    testObjectInputStream();
    testObjectOutputStream();
}

private static void  testFileInput() {
    try(
            // 创建一个FileInputStream对象
            InputStream inputStream = new FileInputStream(path);
        ) {
        int n = 0;
        byte[] bytes = testDataLength();
        while((n=inputStream.read(bytes)) != -1) {
            for (int i = 0; i < n; i++) {
                System.out.print((char) bytes[i]);
            }
        }

    } catch (Exception e) {
        // TODO: handle exception
    }

}
private static void  testFileOutPut()  {

    try(OutputStream op = new FileOutputStream(path,true);) {
        op.write(testData());
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
private static void testBufferedInput() {
    try (BufferedInputStream is = new BufferedInputStream(new FileInputStream(path)); ){
        byte[] bytes = testData();
        int n=0;
        while ((n=is.read(bytes))!=-1) {
            for (int i = 0; i < n; i++) {
                System.out.print((char)bytes[i]);
            }
        }

    } catch (Exception e) {
        // TODO: handle exception
    }

}
private static void testBufferedOutput() {
    try (OutputStream is = new BufferedOutputStream(new FileOutputStream(path,true)); ){
        byte[] bytes = testData();
        is.write(testData());
        is.flush();
    } catch (Exception e) {
        // TODO: handle exception
        e.getMessage();
    }
}
private static void testObjectInputStream() {
    try(ObjectInputStream iStream = new ObjectInputStream(new FileInputStream(path));) {
        byte bytes[] = testDataLength();
        // 常常用来反序列化
        Object stream ;
        while((stream = iStream.readObject())!=null) {
            testSerializable t1 = (testSerializable)stream;
            System.out.println(t1.toString());
        }


    } catch (Exception e) {
        // TODO: handle exception
    }

}
private static void testObjectOutputStream() {
    try(ObjectOutputStream iStream = new ObjectOutputStream(new FileOutputStream(path));) {
        byte bytes[] = testDataLength();
        // 常常用来反序列化
        iStream.writeObject(new testSerializable("李敢敢",23));
        iStream.writeObject(new testSerializable("赵岩岩",23));
        iStream.flush();
    } catch (Exception e) {
        // TODO: handle exception
    }
}
// 读取数据的容量大小
private static byte[] testDataLength() {
    return new byte[1024];
}
// 准备数据
private static byte[] testData() {
    byte[] bytes = new byte[] {'1','2','3','4','5','6','7','8','8','a','b','c'};
    return bytes;
}

}

class testSerializable implements Serializable{

public String name;
public Integer age;
public testSerializable(String name, Integer age) {
    super();
    this.name = name;
    this.age = age;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public Integer getAge() {
    return age;
}
public void setAge(Integer age) {
    this.age = age;
}
@Override
public String toString() {
    return "testSerializable [name=" + name + ", age=" + age + "]";

字符编码
GBK 简体中文、扩展
UTF-8针对Unicode的可变字符编码
GB2312简体中文
当编码和解码方式不一致时,会出现乱码
字符流
字符流的父类
Reader
Writer
字符节点流
FileReader
FileWriter
字符过滤流
BufferedWriter/PrintWriter
BufferedReader
支持写一行、读一行
public class TestReaderAndWriter {















static String path = "./src/txt/a.txt";
public static void main(String[] args) {
    // ---
    testFileWriter();
    testFileReader();
    // ---
    testBufferedWriter();
    testBufferedReader();
    testPrintWriter();
    testBufferedReader();
}
private static void testFileReader() {
    try(Reader reader = new FileReader(path);) {
        int n;
        char[] bytes =dataLength();
        while((n=reader.read(bytes))!=-1) {
            for (int i = 0; i < n; i++) {
                System.out.print(bytes[i]);
            }
        }
    } catch (Exception e) {
        // TODO: handle exception
    }

} 
private static void testFileWriter() {
    try(Writer w = new FileWriter(path);) {
        w.write("I love you!");
        w.flush();
    } catch (Exception e) {
        // TODO: handle exception
    }        
}
private static void testBufferedWriter() {
    try(BufferedWriter bfw = new BufferedWriter(new FileWriter(path));) {
        bfw.write("基本没啥区别");
        bfw.flush();
    } catch (Exception e) {
        // TODO: handle exception    
    }    
}
private static void testBufferedReader() {
    try(BufferedReader br = new BufferedReader(new FileReader(path));) {
        String str;
        while((str=br.readLine())!=null) {
            System.out.println(str);
        }

    } catch (Exception e) {
        // TODO: handle exception
    }    
}
private static void testPrintWriter() {
    try(PrintWriter pw = new PrintWriter(new FileWriter(path));) {
        pw.println("床前明月光");
        pw.println("疑似地上霜");
        pw.println("举头望明月");
        pw.println("岩岩在身旁");
        pw.flush();
    } catch (Exception e) {
        // TODO: handle exception
    }        
}
private static char[] dataLength() {
    return new char[1024];

字符节点流
字符节点流
桥转换流
InputStreamReader
OutputStreamWriter
可将字节流转换为字符流。可设置编码方式,编码与解码一定要一致。
使用步骤
创建节点流
创建过滤流,设置字符编码
封装过滤流
读写数据
关闭流
public class TestConvertStream {











public static void main(String[] args) {
    String path ="./src/txt/a.txt";
    try(    //1.创建字节流
            FileInputStream is = new FileInputStream(path);
            FileOutputStream os = new FileOutputStream(path,true);
            //2.创建转换流
            InputStreamReader isr = new InputStreamReader(is,"UTF-8");
            OutputStreamWriter isw = new OutputStreamWriter(os,"UTF-8");
            //3.创建字符流
            BufferedReader br = new BufferedReader(isr); 
            PrintWriter pw = new PrintWriter(isw);
        ){
        //1.读取
        String string;
        while((string = br.readLine())!=null) {
            System.out.println(string);
        }

                    //2.写入
        pw.println("床前明月光\r\n" + 
                "疑似地上霜\r\n" + 
                "举头望明月\r\n" + 
                "岩岩在身旁\r\n" + 
                "");

// pw.flush();

    }catch (Exception e) {
        // TODO: handle exception

File
FileFilter
File类的构造方法

public class TestFile {

public static void main(String[] args) throws IOException {
    File file = new File("./src");
    file.canExecute();//是否可执行
    file.canRead();//是否可读
    file.canWrite();//是否可写
    //file.createNewFile();// 创建一个文件
    //file.mkdir();//创建文件夹
    //file.mkdirs();//递归文件夹
    //file.delete();//删除文件或文件夹
    //file.exists();//判断文件是否存在
    System.out.println(file.getAbsoluteFile());//获得文件绝对路径
    System.out.println(file.getAbsolutePath());//获得文件绝对路径
    System.out.println(file.getName());//获得文件名
    System.out.println(file.getParent());//获得文件父目录
    System.out.println(file.getParentFile());//获得文件父目录
    file.isDirectory();//判断是否是目录
    file.isFile();//判断是否是文件
    System.out.println("---");

    // 递归遍历
    readfile(file.listFiles());
    // 遍历一层
    File[] files = file.listFiles((pathname)->{
        if(pathname.isFile() && pathname.getName().endsWith(".java")) {
            return true;    
        }
        return false;
    });
    System.out.println("---------");
    for (File file2 : files) {
        System.out.println(file2);
    }
}
private static void readfile(File[] files) {
    if(files == null) {
        return;
    }
    for (File file : files) {
        if(file.isFile()) {
            System.out.println(file.getName());
        }else if(file.isDirectory()) {
            readfile(file.listFiles());

网络编程

  • 由点和线构成的,标识诸多对象间的相互联系 ##### 计算机网络

实现资源共享和信息传递,通过通信线路连接起来的若干(Host)
互联网:点与点
万维网:端与端相连
物联网:物与物相连
网络编程:让计算机与计算机之间建立了链接、进行通信
网络模型
第一层:物理层(双绞线、光导纤维)
第二层:链路层(MAC)
第三层:网络层(IP地址)
第四层:传输层(TCP、UDP)
第五层:会话层(断点续传)
第六层:表示层(对数据转化以及加密)
第七层:应用层(HTTP、FTP、SMTP)
TCP/IP模型
一组用于实现网络互连的通信协议,分为四层
第一层:网络接口层(以太网、ADSL)
第二层:网络层(分配地址、传输数据、IP地址)
第三层:传输层(文本数据,协议是Tcp、UDP协议)
第四层:应用层(负责传送最终形态的数据,协议为HTTP、FTP)
TCP/UDP
tcp:传输控制协议 :是一种面向连接、可靠的、基于字节流的传输层通信
数据大小无限制
建立连接的过程需要三次握手
断开连接的过程需要四次挥手
UDP:用户数据报协议:是一种无连接的传输层协议,提供面向事务的简单、不可靠信息传送服务
每个包大小是64KB
IP
互联网协议/网际协议地址
分配给互联网设备的唯一数字标识
IPV4
4字节32位正数,分成4段8位的二进制数
255.255.255.255
IPV6
16字节128位正数,分成8段十六进制正数
FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF
回环地址
127.0.0.1
localhost
Port(端口)
在通信实体上进行网络通讯的程序的唯一标识 0~65535
Mysql:3306 Oracle:1521 Tomcat:8080
InetAddress
标识互联网协议(IP)地址对象。封装了与该IP地址对象相关的所有信息,并提供常用方法
无法直接创建对象,构造方法私有化,需要通过getXXX方法获得
public class TestInetAddress {











































public static void main(String[] args) throws UnknownHostException {
    //获取本地连接
    InetAddress ia = InetAddress.getLocalHost();
    // 获取本机地址
    System.out.println(ia.getAddress());
    // 获取本机的ip
    System.out.println(ia.getHostAddress());
    //获取本机名
    System.out.println(ia.getHostName());
    //获取本机名/ip
    System.out.println(ia.getLocalHost());

基于TCP的网络编程
Socket
是网络中的一个通讯节点
分为客户端Socket 服务端ServerSocket
通讯要求:IP地址和端口Port
public class Client {




public static void main(String[] args) throws UnknownHostException, IOException {
    //创建客户端
    Socket client = new Socket("127.0.0.1",9999);
    //创建输入输出流
    //创建输入输出流
    PrintWriter pw = new PrintWriter(new OutputStreamWriter(client.getOutputStream(),"UTF-8"));
    BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream(),"UTF-8"));

    pw.println("床前明月光");
    pw.println("疑似地上霜");
    pw.println("举头望明月");
    pw.println("岩岩在身旁");
    pw.flush();

    String string;
    while((string=br.readLine())!=null) 
    {
        System.out.println(string);
    }
    pw.close();
    br.close();
    client.close();

public class Server {

public static void main(String[] args) throws IOException {
    //配置服务器端口号
    ServerSocket server = new ServerSocket(9999);
    System.out.println("服务器启动");
    //监听客户端
    Socket client = server.accept();
    //创建输入输出流
    PrintWriter pw = new PrintWriter(new OutputStreamWriter(client.getOutputStream(),"UTF-8"));
    BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream(),"UTF-8"));
    // 响应
    pw.println("欢迎"+client.getInetAddress().getHostName()+"访问客户端");
    pw.flush();
    String string;
    while((string=br.readLine())!=null) 
    {
        System.out.println(string);
    }
    //----------------
    pw.close();
    br.close();
    client.close();
    server.close();

反射
类的对象

  • 基于某个类new出来的对象,也称为实例对象

public class TestA{

public static void main(String[] args){
    TestA t = new TestA(); //t就是实例对象

类对象
类加载的产物
封装了一个类所有信息(类名、父类、接口、属性、方法、构造方法)
一个.class文件就代表一个类对象
获取类对象
通过类的对象,回去类对象
Student s = new Student();
Class c = s.getClass();
1
2
通过类名获取类对象
Class c = 类名.class
1
通过静态方法获取类对象
Class.forName("包名.类名")
1
常用方法
public String getName()//获取全路径类名
public Package getPackage();//获取全路径包名
public Class<? super T> getSuperclass();//获取父类返回Class
public Class<?>[] getInterfaces() // 获取接口返回数组



















public Field[] getFields()//获取属性(自身加父类的公开属性) 必须是Public的
public Field[] getDeclaredFields()//获取自身所有属性不分权限

public Method[] getMethods()// 获取方法(自身的和父类的公共方法)必须是Public的
public Method[] getDeclaredMethods()//获取自身所有非构造方法
getReturnType() 方法返回值类型

public Constructor<?>[] getConstructors()
public Constructor<?>[] getDeclaredConstructors()

public T newInstance()

package com.review.reflect;

public class TestReflects {

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
    //方法一
    Student t = new Student();
    Class c1 = t.getClass();
    //方法二
    Class c2 = Student.class;
    //方法三
    Class c3 = Class.forName("com.review.reflect.Student");
    // 获取全路径类名
    String name = c2.getName();
    // 获取全路径报名
    Package p = c2.getPackage();
    //获取父类返回Class
    Class  cparent = c2.getSuperclass();
    // 获取接口返回数组
    Class[] ci = c2.getInterfaces();
    //获取属性(自身加父类的公开属性) 必须是Public的
    c2.getFields();
    //获取自身所有属性不分权限
    c2.getDeclaredFields();
    // 获取方法(自身的和父类的公共方法)必须是Public的
    c2.getMethods();
    //获取自身所有非构造方法
    c2.getDeclaredMethods();
    // 获取构造函数
    c2.getConstructors();
    c2.getDeclaredConstructors();
    // 实例化
    Student student = (Student)c2.newInstance();
}

}
class Student{

private String name;
private String sex;
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}
@Override
public String toString() {
    return "Student [name=" + name + ", sex=" + sex + "]";
}
public Student(String name, String sex) {
    super();
    this.name = name;
    this.sex = sex;
}
public Student() {
    super();
    // TODO Auto-generated constructor stub

工厂设计模式
开发中有一个非常重要的原则,:“开闭原则”.对拓展开放、对修改关闭
工厂模式主要负责对象创建的问题
通过反射进行工厂模式的设计,完成动态的对象创建
public class TestFactory {



public static void main(String[] args) {
    Object o = createObject("com.qfedu.review.reflect.Person");
    Class c= o.getClass();

    System.out.println(o.getClass().getTypeName());
}
private static Object createObject(String className) {
    try{
        Class sClass = Class.forName(className);
        return sClass.newInstance();

    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return null;
}
//使用反射技术执行任何方法
public static void invokeAny(Object obj,String methodName,Class[] types,Object...args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

    //类对象
    Class c = obj.getClass();
    //获得方法的对象Method
    Method m = c.getDeclaredMethod(methodName, types);
    //执行方法
    m.invoke(c,args);
}

}
class Person{

单例模式
只允许创建一个该类的对象
方式1:饿汉式(类加载时创建,天生线程安全)
方式2:懒汉式(使用时创建,线程不安全,需要加锁)
方式3:懒汉式(使用时创建、线程安全,天生不需要加锁)
public class TestSingleton {




public static void main(String[] args) {

}
// 方式1

}

// 饿汉
class TestSingletonOne {

private final static TestSingletonOne tobj = new TestSingletonOne(); 
private TestSingletonOne() {}
public TestSingletonOne CreateObj() {
    return tobj;
}

}
// 懒汉1
class TestSingletonTwo {

private  static TestSingletonTwo tobj = null; 
private TestSingletonTwo() {}
synchronized public TestSingletonTwo CreateObj() {
    if(this.tobj == null) {
        this.tobj = new TestSingletonTwo();
    }
    return tobj;
}

}
// 懒汉2
class TestSingletonThree {

private TestSingletonThree() {}
private static class Create{
    final static TestSingletonThree tobj =new TestSingletonThree();
} 
public TestSingletonThree CreateObj() {
    return Create.tobj;
原文链接:segmentfault.com

上一篇:编辑表格输入内容、根据input输入框输入数字动态生成表格行数、编辑表格内容提交传给后台数据处理
下一篇:element的el-time-picker组件,无法使用

相关推荐

官方社区

扫码加入 JavaScript 社区