java基础

I/O

File、InputStream、URL、Resource的区别???

io流writer写时，若不关闭流，会出现什么；reader需要关闭吗

数据写不进去，其实手动writer.flush(),也可以将数据刷新进去
reader也需要关闭

flush方法应该怎么用

当有大量数据需要写入时，要分批进行writer.flush一下，否则缓存压力过大

FileWriter的write方法源码

FileWriter extends OutputStreamWriter

OutputStreamWriter extends Writer{
   
	final StreamEncoder se;
	public void write(char cbuf[], int off, int len) throws IOException {
   
        se.write(cbuf, off, len);
    }
    
	public void flush() throws IOException {
   
        se.flush();
    }
}

class nio.StreamEncoder extends Writer {
   
}

nio对普通IO的优化？？？

BufferedWriter源码

class BufferedWriter extends Writer {
   
	Writer out;
	char cb[];

	public void write(String s, int off, int len) throws IOException {
   
        synchronized (lock) {
   
            ensureOpen();
            int b = off, t = off + len;
            while (b < t) {
        
            	// 不停往cb里面填数据      
                s.getChars(b, b + d, cb, nextChar);
                // 当数据超出一个临界值时，会自动先out.write(cb, 0, nextChar);
                if (nextChar >= nChars)
                    flushBuffer();
            }
        }
    }

	public void flush() throws IOException {
   
        synchronized (lock) {
   
            flushBuffer();
            out.flush();
        }
    }

	void flushBuffer() throws IOException {
   
        synchronized (lock) {
   
            ensureOpen();
            if (nextChar == 0)
                return;
            out.write(cb, 0, nextChar);
            nextChar = 0;
        }
    }

}

read()方法读出的是什么，read(char[] chars)呢

reader = new FileReader(file);
//一个数字，ASCII码，可以强制转换回char
int i = reader.read();

// 连续读三次，可以读到三个字符，若第三个没值，则返回-1，可作为读取结束条件
reader.read()
reader.read()
reader.read()

read(char[] chars)是将数据读入到参数的数组中，返回的是读取到数据的长度

reader = new FileReader(file);
char[] cs = new char[5];
int i = reader.read(cs);
// 若最后只读取到i=2个数据，只会覆盖原数组的前两个数据，后面三个不变
// 当i = -1时候,说明没有读到数据了
i = reader.read(cs);

以追加的方式写入，而不是覆盖;换行怎么写

new FileWriter（“file.txt”,true）
\n代表换行，或\r\n

BufferedReader

reader = new BufferedReader(new FileReader(file));
String line = reader.readLine();
// BufferedReader关闭，里面的FileReader也会关闭
reader.close();

if(line != null){
   
	//这个就是读取的边界
}

writer = new BufferedWriter(new FileWriter(file));
//写入一行
writer.write("abc");
// 要想换换必须加这个方法
writer.newLine();
writer.write("xyz");
writer.flush();

字节流FileOutputStream、FileInputStream 、BufferedInputStream、BufferedOutputStream

byte[] bytes = {
   123,34,45,34};
outputStream = new FileOutputStream(file);
outputStream.write(bytes);
// 字节流无需flush
outputStream.close()

byte[] bs = new byte[5];
FileInputStream inputStream = new FileInputStream(file);
// 读到多少个字节 i，当i为-1时，表示没有读到数据
int i = inputStream.read(bs);

// 指定解码格式，对字节进行解码
 String(@NotNull byte[] bytes,
              int offset,
              int length,
              @NotNull java.nio.Charset charset)

in = new BufferedInputStream(new FileInputStream(file));
out = new BufferedOutputStream(new FileOutputStream(file));

byte[] bs = new byte[1024];
// 当len为-1时候表示没读到数据
int len = in.read(bs)
out.write(bs,0,len)

InputStream转字节数组

byte[] readStream(final InputStream inputStream) {
   
	ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    byte[] data = new byte[INPUT_STREAM_DATA_CHUNK_SIZE];
    int bytesRead;
    while ((bytesRead = inputStream.read(data, 0, data.length)) != -1) {
   
      outputStream.write(data, 0, bytesRead);
    }
    outputStream.flush();
    return outputStream.toByteArray();
}

class ByteArrayOutputStream extends OutputStream {
   
	// 数据没有存在文件里，而是这个数组中
	byte buf[];
	public ByteArrayOutputStream() {
   
        this(32);
    }
    
    void write(byte b[], int off, int len) {
   
        if ((off < 0) || (off > b.length) || (len < 0) ||
            ((off + len) - b.length > 0)) {
   
            throw new IndexOutOfBoundsException();
        }
        ensureCapacity(count + len);
        // 复制数组
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }
}

BufferedOutputStream源码

class BufferedOutputStream extends FilterOutputStream {
   
	byte buf[];
	
	public synchronized void write(byte b[], int off, int len) throws IOException {
   
        if (len >= buf.length) {
   
            flushBuffer();
            out.write(b, off, len);
            return;
        }
        // 将数据先放到buf缓存中
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }

	private void flushBuffer() throws IOException {
   
        if (count > 0) {
   
            out.write(buf, 0, count);
            count = 0;
        }
    }
}

class FilterOutputStream extends OutputStream {
   
	OutputStream out;
	
	public void write(int b) throws IOException {
   
        out.write(b);
    }
}

字符流编码与字节流

OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(file), "gbk");
// 这个“中”字是以gbk形式存储，将来读取的时候也要以gbk取数据
writer.write("中");

char[] cs = new char[1024];
// 解码必须以jdb
InputStreamReader reader = new InputStreamReader(new FileInputStream(file), "GBK");
int len = reader.read(cs);
new String(cs,0,len);

打印流，只有writer，没有reader

// 将数据输出到文件file
PrintWriter writer = new PrintWriter(file);
writer.println("hello");
writer.print("world");
writer.flush();

// 将读到的数据打印到控制台
PrintWriter writer = new PrintWriter(System.out);
writer.flush();

Properties

// 线程安全，只能存字符串
Properties extends Hashtable<Object,Object> {
   
	public synchronized Object setProperty(String key, String value) {
   
        return put(key, value);
    }
}

Properties properties = new Properties();
properties.setProperty("001","张三");
properties.setProperty("002","李四");

String value = properties.getProperty("001");

// 将properties数据写到文件中
PrintWriter writer = new PrintWriter(file);
properties.list(writer);
writer.flush();

// 从文件中加载到properties里
Properties properties = new Properties();
FileInputStream inputStream = new FileInputStream(file);
properties.load(inputStream);

序列化流

// Person要实现序列化接口，加一个序列化id，不加序列化id，当类变化例如增加字段时，反序列化会报错

ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));
outputStream.writeObject(new Person());
outputStream.flush();

ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(file));
Object o = inputStream.readObject();

// 一般使用集合，集合实现了序列化接口
list.add(person1)
list.add(person2)
outputStream.writeObject(list);

标签接口

• 标签接口没有任何方法和属性
• 主要有两个用途，第一：标识同一类型的类，如org.aopalliance.aop.Advice；第二：使程序或JVM采取一些特殊处理，如io.Serializable

File

1. File：

file.exists()
file.createNewFile()
file.mkdir()
//创建多级目录
file.mkdirs()
//删除不走回收站，删除文件和目录最后一层
file.delete()
//获取文件绝对路径
file.getAbsolutePath()
//new File("b.txt"),相对路径是相对项目名作为根路径
//获取相对路径
file.getPath()
file.getName()
//文件大小，多少字节
file.length()
File[] files = file.listFiles();
boolean canExecute = file.canExecute();
boolean canRead = file.canRead();
boolean canWrite = file.canWrite();
boolean hidden = file.isHidden();

//体现层级关系递归打印目录树,注意space的使用
int space = 1;
void print(File file) {
   
	space ++;
    File[] files = file.listFiles();
    for (File f : files) {
   
        printSpace(space);

        System.out.println(f);

        if (f.isDirectory()) {
   
            printFile(file);
        }
    }
    space --;
}


// 递归删除目录下的所有文件和目录，注意，只能删除空目录
void deleteDirector(File file) {
   
	   if (file == null || !file.exists()) {
   
	       return;
	   }
	
	   File[] files = file.listFiles();
	   for (File f : files) {
   
	       if (f.isDirectory()) {
   
	           deleteDirector(f);
	       }else {
   
	           f.delete();
	       }
	   }
	   //这步是点睛之笔
	   file.delete();
}

nio之Paths、Files使用

Path path= Paths.get(new URI(myPath));
byte[] cLassBytes= Files.readAllBytes(path);

反射

每个类编译之后都会有一个class文件，什么时候加载到JVM中的，static{//代码块}这里面的代码块什么时候被执行

对其第一次使用时:

new Dog();
Class<?> clazz = Class.forName("com.file.Dog");
Dog.staticAttribute
Dog.staticMethod

类加载器的意义

任意一个类，都需要由加载它的类加载器和这个类本身一同确定其在java虚拟机中的唯一性

双亲委派模型的好处

Java类随着它的类加载器具备了一种带有优先级的层次关系。例如Object放在rt.jar中，无论哪一个类加载器加载这个类，最终都是委派给模型最顶端的启动类加载器加载

ClassLoader的使用与getDefaultClassLoader源码

• 双亲委派模型
  启动类加载器（bootstrap classloader）：负责JAVA_HOME/lib目录
  扩展类加载器（extension classloader）：JAVA_HOME/lib/ext目录
  应用程序类加载器（application classloader）：也叫系统类加载器，负责类路径

// 应用程序类加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

Class<?> loadClass(String name) {
   
	// 检查是否已被加载过
	Class<?> c = findLoadedClass(name);