Java基础(5) 泛型日期和时间线程 File-输入流

泛型

java的泛型有点像ts的泛型

public class ArrayList<T> {private T[] array;private int size;public void add(T e) {...}public void remove(int index) {...}public T get(int index) {...}
}

// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();

泛型就是编写模板代码来适应任意类型；
泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查；
注意泛型的继承关系：可以把ArrayList向上转型为List（T不能变！），但不能把ArrayList向上转型为ArrayList（T不能变成父类）。

使用泛型

使用ArrayList的时候，不指定类型，默认就是object;
泛型接口

public interface Comparable<T> {/*** 返回负数: 当前实例比参数o小* 返回0: 当前实例与参数o相等* 返回正数: 当前实例比参数o大*/int compareTo(T o);
}

想要使用Array.sorts，放入里面的元素就需要实现comapreTo方法。

class Person implements Comparable<Person> {String name;int score;Person(String name, int score) {this.name = name;this.score = score;}public int compareTo(Person other) {return this.name.compareTo(other.name);}public String toString() {return this.name + "," + this.score;}
}

自己编写

class Pari<T> {private T first;private T last;public Pari(T first, T last){this.first = first;this.last = last;}public T getFirst(){return this.first;}// 编译报错public static Pari<T> create (T first, T last){return new Pari<T>(first, last);}}

不能在静态方法上面添加泛型，静态泛型方法应该使用其他类型区分

 // 编译报错public static <K>Pari<K> create(K first, K last) {return new Pari<K>(first, last);}

擦拭法

泛型是一种类似”模板代码“的技术，不同语言的泛型实现方式不一定相同。
Java语言的泛型实现方式是擦拭法（Type Erasure）。
就是，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。
当我们编写的泛型，实际上到虚拟机执行的时候

public class Pair {private Object first;private Object last;public Pair(Object first, Object last) {this.first = first;this.last = last;}public Object getFirst() {return first;}public Object getLast() {return last;}
}

编译器把类型视为Object；
编译器根据实现安全的强制转型。

Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

了解java泛型的实现，才能知道它的局限性，

T不能是基本类型，比如int，因为实际编译是object，object无法持有基本类型。
无法取得带泛型的Class，因为T是Object，我们对Pair< String>和Pair< Integer>类型获取Class时，获取到的是同一个Class，也就是Pair类的Class。也就是说，无论T是啥，getClass都会返回一个class实力，因为编译后它们都属于Pair< Object>
无法判断带泛型的类型：并不存在Pair< String>.class，而是只有唯一的Pair.class

Pair<Integer> p = new Pair<>(123, 456);
// Compile error:
if (p instanceof Pair<String>) {
}

所以无法通过实例p来获取泛型T

局限四：不能实例化T类型：

public class Pair<T> {private T first;private T last;public Pair() {// Compile error:first = new T(); //  本意是想创建String，但编译后 first = new Object();last = new T(); //last = new Object();}
}

创建new Pair< String>()和创建new Pair< Integer>()就全部成了Object
可以通过反射

public class Pair<T> {private T first;private T last;public Pair(Class<T> clazz) {this.first = clazz.newInstance();this.last = clazz.newInstance()}
}
Pair<String> pair = new Pair<>(String.class);

通过String的反射获取到构造函数，然后调用创建一个新的String实例。

泛型方法要防止重复定义方法，例如：public boolean equals(T obj)；
虽然，实例p无法获取创建时候传入的T，但是子类可以获取父类的泛型类型。

java的泛型继承

 static int add(Pari<? extends Number> p){Number first = p.getFirst();Number second = 2;return first.intValue()  + second.intValue();}

在java中，使用< ? extends xxx > 来限定传入的值 (上界通配符,泛型类型T的上界限定在Number了)，
使用< T extends xxx>来限定T的范围
如上

add(Pari<Integer>)
add(Pari<Number>)

都可以

class Pari<T extends Number> {private T first;private T last;public Pari(T first, T last) {this.first = first;this.last = last;}public T getFirst() {return this.first;}public void setFirst(T val) {this.first = val;}// 编译报错public static <K extends Number> Pari<K> create(K first, K last) {return new Pari<K>(first, last);}static int add(Pari<? extends Number> p) {Number first = p.getFirst();Number second = 2;return first.intValue() + second.intValue();}}

这里要注意，当我们使用？ extends Number获取到对应的实例的时候，是不能调用对应的set方法的
在这里插入图片描述

原因还是在于擦拭法，当我们传入的p是Pari< Double>时，他满足？ extends Number，但是他的setFirst显然无法接受Ingeter类型。这就是? extends Number的一个重要限制。
方法参数签名setFirst(? extends Number)无法传递任何Number的子类型给setFirst(? extends Number)。
唯一的例外是可以给方法参数传入null。

作用

当我们需要实现要一个只读接口的时候，就可以通过这种方式。

public interface List<T> {int size(); // 获取个数T get(int index); // 根据索引获取指定元素void add(T t); // 添加一个新元素void remove(T t); // 删除一个已有元素
}int sumOfList(List<? extends Integer> list) {int sum = 0;for (int i=0; i<list.size(); i++) {Integer n = list.get(i);sum = sum + n;}return sum;
}

这里定义的? extends Integer跟直接定义Integer是一样的，但是? extends Integer有个好处，

允许调用get()方法获取Integer的引用；
不允许调用add(? extends Integer)方法并传入任何Integer的引用（null除外）。

所以

使用类似<? extends Number>通配符作为方法参数时表示：
- 方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst();；
- 方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。
- 使用extends通配符表示可以读，不能写。

super

上面的extends限制了T的上限，比如 ? extends Number，那么只能传入Number和Number的子类。
那如果想限制下限呢，比如限制只能传入Integet和 integer的父类，可以用super

  static void setFirst1(Pari<? super Integer> p, Integer val1) {// void Pari.setFirst(Object val)p.setFirst(Integer.valueOf(123));// Object Pari.getFirst()p.getFirst();}

? super Integer表示，方法参数接受，所有泛型类型为Integer或Integer父类的 Pari类型。
此时setFirst也接受Integer及以上的类型的值。

考察Pair< ? super Integer>的setFirst方法，我们传入了? super Integer给 T，那么setFirst，getFirst就是

void setFirst(? super Integer)
? super Integer getFirst();

所以setFirst可以接受Integer以上的值，但是不能用Integer去接受getFirst的值，因为如果传入了Number，那么无法将Number转为Integer(Number即使是抽象类，这里也不能通过编译)
唯一可以接收getFirst()方法返回值的是Object类型

Object obj = p.getFirst();

这些点恰好和extends相反。
所以，? super Integer表示

允许调用set(? super Integer)方法传入Integer的引用；
不允许调用get()方法获得Integer的引用

换句话说，使用<? super Integer>通配符作为方法参数，表示方法内部代码对于参数只能写，不能读。

extends 和 super的区别

? extends T 允许调用读方法 T get()获取T的引用，但不允许set(T)传入T的引用。
? super T 允许调用set(T)传入T的引用，不允许调用 T get()获取T的引用（获取object除外）

案例 collections的copy，复制集合

public class Collections {// 把src的每个元素复制到dest中:public static <T> void copy(List<? super T> dest, List<? extends T> src) {for (int i=0; i<src.size(); i++) {T t = src.get(i);dest.add(t);}}
}

这个copy()方法的定义就完美地展示了extends和super的意图：

copy()方法内部不会读取dest，因为不能调用dest.get()来获取T的引用；
copy()方法内部也不会修改src，因为不能调用src.add(T)。

这个copy()方法的另一个好处是可以安全地把一个List< Integer>添加到List< Number>，但是无法反过来添加

因为? super T 表示 ? super Integer, 表示 dest可以写入Integer以上的值，比如Number
? extends T 表示 ? extends Number，表示src可以读取Number一下的值，比如Integer
然后将读取的Integer写入到 add( ? super Integer)中。
但如果反过来则不行了， ? super Number只允许写入Number以上的，Integer显然不行。

PECS原则

Producer Extends Consumer Super
如果需要返回T，它是生产者（Producer），要使用extends通配符；
如果需要写入T，它是消费者（Consumer），要使用super通配符。
如上述的src的生产者，dest的消费者。
需要返回T的src是生产者，因此声明为List<? extends T>，需要写入T的dest是消费者，因此声明为List<? super T>。

无限定通配符

void sample(Pair<?> p) {
}

既不是extends也不是super，所以她不能读，也不能写，只能做一些null判断

static boolean isNull(Pair<?> p) {return p.getFirst() == null || p.getLast() == null;
}

Pair<?>是所有Pair的超类

  Pair<Integer> p = new Pair<>(123, 456);Pair<?> p2 = p; // 安全地向上转型System.out.println(p2.getFirst() + ", " + p2.getLast());

日期和时间

System.currentTimeMillis()，这是Java程序获取时间戳最常用的方法。

标准库API

我们再来看一下Java标准库提供的API。Java标准库有两套处理日期和时间的API：

一套定义在java.util这个包里面，主要包括Date、Calendar和TimeZone这几个类；
一套新的API是在Java 8引入的，定义在java.time这个包里面，主要包括LocalDateTime、ZonedDateTime、ZoneId等。

// 获取当前时间:Date date = new Date();System.out.println(date.getYear() + 1900); // 必须加上1900System.out.println(date.getMonth() + 1); // 0~11，必须加上1System.out.println(date.getDate()); // 1~31，不能加1// 转换为String:System.out.println(date.toString());// 转换为GMT时区:System.out.println(date.toGMTString());// 转换为本地时区:System.out.println(date.toLocaleString());// 想要针对用户的偏好精确地控制日期和时间的格式var sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println(sdf.format(date)); //2024-03-02 11:32:47

Date对象有几个严重的问题：它不能转换时区，除了toGMTString()可以按GMT+0:00输出外，Date总是以当前计算机系统的默认时区为基础进行输出。此外，我们也很难对日期和时间进行加减，计算两个日期相差多少天，计算某个月第一个星期一的日期等。

Calendar

Calendar可以用于获取并设置年、月、日、时、分、秒，它和Date比，主要多了一个可以做简单的日期和时间运算的功能。

TimeZone

Calendar和Date相比，它提供了时区转换的功能

新的一套api

本地日期和时间：LocalDateTime，LocalDate，LocalTime；
带时区的日期和时间：ZonedDateTime；
时刻：Instant；
时区：ZoneId，ZoneOffset；
时间间隔：Duration。
以及一套新的用于取代SimpleDateFormat的格式化类型DateTimeFormatter。

   LocalDate d = LocalDate.now(); // 2024-03-02LocalTime t = LocalTime.now(); // 11:36:39.612LocalDateTime dt = LocalDateTime.now(); //2024-03-02T11:36:39.612

由于执行时机的相差，上述的时间可能对不是，毫秒数。

LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间
LocalDate d = dt.toLocalDate(); // 转换到当前日期
LocalTime t = dt.toLocalTime(); // 转换到当前时间// 指定日期和时间:
LocalDate d2 = LocalDate.of(2019, 11, 30); // 2019-11-30, 注意11=11月
LocalTime t2 = LocalTime.of(15, 16, 17); // 15:16:17
LocalDateTime dt2 = LocalDateTime.of(2019, 11, 30, 15, 16, 17);
LocalDateTime dt3 = LocalDateTime.of(d2, t2);LocalDateTime dt = LocalDateTime.parse("2019-11-19T15:16:17");
LocalDate d = LocalDate.parse("2019-11-19");
LocalTime t = LocalTime.parse("15:16:17");

ISO 8601规定的日期和时间分隔符是T。标准格式如下：
日期：yyyy-MM-dd
时间：HH:mm:ss
带毫秒的时间：HH:mm:ss.SSS
日期和时间：yyyy-MM-dd’T’HH:mm:ss
带毫秒的日期和时间：yyyy-MM-dd’T’HH:mm:ss.SSS

DateTimeFormatter

      // 自定义格式化:DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");System.out.println(dtf.format(LocalDateTime.now()));// 用自定义格式解析:LocalDateTime dt2 = LocalDateTime.parse("2019/11/30 15:16:17", dtf);System.out.println(dt2);

此外localDateTime还提供了简单的加减法。

   LocalDateTime dt = LocalDateTime.of(2019, 10, 26, 20, 30, 59);System.out.println(dt);// 加5天减3小时:LocalDateTime dt2 = dt.plusDays(5).minusHours(3);System.out.println(dt2); // 2019-10-31T17:30:59// 减1月:LocalDateTime dt3 = dt2.minusMonths(1);System.out.println(dt3); // 2019-09-30T17:30:59

注意到月份加减会自动调整日期，例如从2019-10-31减去1个月得到的结果是2019-09-30，因为9月没有31日。
对日期和时间进行调整则使用withXxx()方法，例如：withHour(15)会把10:11:12变为15:11:12：

调整年：withYear()
调整月：withMonth()
调整日：withDayOfMonth()
调整时：withHour()
调整分：withMinute()
调整秒：withSecond()LocalDateTime dt = LocalDateTime.of(2019, 10, 26, 20, 30, 59);System.out.println(dt);// 日期变为31日:LocalDateTime dt2 = dt.withDayOfMonth(31);System.out.println(dt2); // 2019-10-31T20:30:59// 月份变为9:LocalDateTime dt3 = dt2.withMonth(9);System.out.println(dt3); // 2019-09-30T20:30:59

…

线程

进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个线程。

和多线程相比，多进程的缺点在于：

创建进程比创建线程开销大，尤其是在Windows系统上；
进程间通信比线程间通信要慢，因为线程间通信就是读写同一个变量，速度很快。
而多进程的优点在于：
多进程稳定性比多线程高，因为在多进程的情况下，一个进程崩溃不会影响其他进程，而在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃。

Java多线程编程的特点又在于：

多线程模型是Java程序最基本的并发模型；
后续读写网络、数据库、Web开发等都依赖Java多线程模型。

创建一个线程

java通过new Thread
或者一个Thread的子类
或者实现Runnable接口的类来创建一个线程，
通过start启动一个线程

class MyThread extends Thread {@Overridepublic void run() {System.out.println("start new thread1");}
}class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("start new thread2");}
}public class HelloWorld {public static void main(String[] args) {System.out.println("main start");Thread t = new MyThread("test"); //参数是线程名称// start()方法会在内部自动调用实例的run()方法t.start(); // 开始并发执行Thread t2 = new Thread(new MyRunnable());t2.start();Thread t3 = new Thread() {public void run() {System.out.println("start new thread3");}};t3.start();System.out.println("main end");}}

上述执行结果

main start
start new thread1
main end
start new thread2
start new thread3

main主线程在执行start之后，其他线程就跟主线程开始同时运行了，并且由操作系统调度，程序本身无法确定线程的调度顺序。
Thread.sleep()可以把当前线程暂停一段时间。

Thread类常用的方法

public void run() 线程相关的代码都写在里面执行
public void start()启动线程
public void join(long ms) t.join()，会等待t线程之行结束再执行其他线程，参数是等待最多的时间，超过这个时间就不等待了
public static void sleep(long m) 调用Thread.sleep可以让当前线程暂停m毫秒。

Runnable接口

只有一个方法
Runnable是Java实现线程的接口。
任何实现线程功能的类，都必须实现该接口。

线程状态

一个线程对象只能调用一次start启动新线程，并在新线程中执行run方法，一旦run方法执行完毕，线程就结束了，因此，java线程的状态有以下几种。

New：新创建的线程，尚未执行；
Runnable：线程调用了start()方法后进入就绪状态，并且当线程调度器为其分配CPU资源时，它会转为运行状态。在Java中，这个状态包括了“就绪”和“运行”两种情况，也就是说，线程可能正在执行，也可能准备好了随时可以执行，只是当前没有获得CPU时间片。
Blocked：阻塞状态运行中的线程，因为某些操作被阻塞而挂起；
Waiting：运行中的线程，因为某些操作在等待中；
Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；
Terminated：线程已终止，因为run()方法执行完毕。

在这里插入图片描述
t.join()可以等到t线程结束后再执行主线程。

线程优先级

java提供了十个优先级，1-10，主线程优先级默认为5，
优先级常量 MAX_PRIORITY 最高优先级10，MIN_PRIORITY最低优先级1，NORMOR_PRIORITY默认优先级5
public int getPriority()获取优先级 public void setPriority(int newPriority)设置优先级
JVM自动把1（低）~10（高）的优先级映射到操作系统实际优先级上（不同操作系统有不同的优先级数量）。优先级高的线程被操作系统调度的优先级较高，操作系统对高优先级线程可能调度更频繁，但我们决不能通过设置优先级来确保高优先级的线程一定会先执行。

中断线程

假设从网络下载一个100M的文件，如果网速很慢，用户等得不耐烦，就可能在下载过程中点“取消”，这时，程序就需要中断下载线程的执行。
中断一个线程非常简单，只需要在其他线程中对目标线程调用interrupt()方法，目标线程需要反复检测自身状态是否是interrupted状态，如果是，就立刻结束运行。

class MyThread extends Thread {@Overridepublic void run() {int n = 0;while (!isInterrupted()) {n++;System.out.println(n + " hello!");}}
}public static void main(String[] args) throws InterruptedException {System.out.println("main start");Thread t = new MyThread();// start()方法会在内部自动调用实例的run()方法t.start(); // 开始并发执行Thread.sleep(1); // 暂停1毫秒t.interrupt(); // 中断t线程t.join(); // 等待t线程结束System.out.println("main end");}

另一个常用的中断线程的方法是设置标志位。我们通常会用一个running标志位来标识线程是否应该继续运行，在外部线程中，通过把HelloThread.running置为false，就可以让线程结束：

public class Main {public static void main(String[] args)  throws InterruptedException {HelloThread t = new HelloThread();t.start();Thread.sleep(1);t.running = false; // 标志位置为false}
}class HelloThread extends Thread {public volatile boolean running = true;public void run() {int n = 0;while (running) {n ++;System.out.println(n + " hello!");}System.out.println("end!");}
}

注意到HelloThread的标志位boolean running是一个线程间共享的变量。线程间共享变量需要使用volatile关键字标记，确保每个线程都能读取到更新后的变量值。

volatile关键字的目的是告诉虚拟机：

每次访问变量时，总是获取主内存的最新值；
每次修改变量后，立刻回写到主内存。

小结

对目标线程调用interrupt()方法可以请求中断一个线程，目标线程通过检测isInterrupted()标志获取自身是否已中断。如果目标线程处于等待状态，该线程会捕获到InterruptedException；
目标线程检测到isInterrupted()为true或者捕获了InterruptedException都应该立刻结束自身线程；
通过标志位判断需要正确使用volatile关键字；
volatile关键字解决了共享变量在线程间的可见性问题。

守护线程

守护线程是指为其他线程服务的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出。

因此，JVM退出时，不必关心守护线程是否已结束。
setDaemon 标记为守护线程

Thread t = new MyThread();
t.setDaemon(true);
t.start();

多线程运行问题

各个线程是通过竞争CPU时间获得运行机会的。
各个线程在什么时候得到CPU时间，占用多久，是不可预测的。
一个正在运行着的线程在什么地方被暂停是不确定的。

线程同步

如果有两个线程，比如银行系统，他有一个Bank对象，一个线程用来存，一个线程用来取，因为线程的操作时机是不确定的，就会导致存取时候得到的银行余额并不是最新的，导致出错。
为了解决这个问题，就需要将Bank对象锁住。

使用synchronized关键字。

public synchornized void set(){}
public static synchornized void set(){}
synchornized(obj){setxx}

多线程模型下，要保证逻辑正确，对共享变量进行读写时，必须保证一组指令以原子方式执行：即某一个线程执行时，其他线程必须等待：
在这里插入图片描述
通过加锁和解锁的操作，就能保证3条指令总是在一个线程执行期间，不会有其他线程会进入此指令区间。
这种加锁和解锁之间的代码块我们称之为临界区（Critical Section），任何时候临界区最多只有一个线程能执行。
保证一段代码的原子性就是通过加锁和解锁实现的。Java程序使用synchronized关键字对一个对象进行加锁：

synchronized(lock) {n = n + 1;
}public class Main {public static void main(String[] args) throws Exception {var add = new AddThread();var dec = new DecThread();add.start();dec.start();add.join();dec.join();System.out.println(Counter.count);}
}class Counter {public static final Object lock = new Object();public static int count = 0;
}class AddThread extends Thread {public void run() {for (int i=0; i<10000; i++) {synchronized(Counter.lock) {Counter.count += 1;}}}
}class DecThread extends Thread {public void run() {for (int i=0; i<10000; i++) {synchronized(Counter.lock) {Counter.count -= 1;}}}
}

注意·

synchronized(Counter.lock) { // 获取锁...
} // 释放锁

不需要synchronized的操作

原子操作不需要synchronized操作，比如基本类型赋值(long,double除外)int n = m; 引用类型赋值List< string> list = anthoerList;
单条原子操作语句不需要赋值
多行赋值语句，就必须保证是同步操作
如果多线程读写的是一个不可变对象，那么无需同步，因为不会修改对象的状态

小结

多线程同时读写共享变量时，可能会造成逻辑错误，因此需要通过synchronized同步；
同步的本质就是给指定对象加锁，加锁后才能继续执行后续代码；
注意加锁对象必须是同一个实例；
对JVM定义的单个原子操作不需要同步。

同步方法

自己写synchronized，还得注意需要锁住同一个对象，更好的方法是把synchronized封装起来

public class Counter {private int count = 0;public void add(int n) {synchronized(this) {count += n;}}// 等同于public synchronized void add(int n) { // 锁住thiscount += n;} // 解锁public void dec(int n) {synchronized(this) {count -= n;}}public int get() {return count;}
}

用synchronized修饰的方法就是同步方法，他会将当前的this实例锁起来。

线程调用add()、dec()方法时，它不必关心同步逻辑，因为synchronized代码块在add()、dec()方法内部。并且，我们注意到，synchronized锁住的对象是this，即当前实例，这又使得创建多个Counter实例的时候，它们之间互不影响，可以并发执行

如果一个类被设计为允许多线程正确访问，我们就说这个类就是“线程安全”的（thread-safe），上面的Counter类就是线程安全的。Java标准库的java.lang.StringBuffer也是线程安全的。

如果用synchronized修饰static，static没有this，但是JVM会给每个类创建一个Class 实例，所以用synchronized修饰static方法，锁住的是Class实例

public class Counter {public static void test(int n) {synchronized(Counter.class) {...}}
}

线程通信

wait() 中断方法的执行，使线程等待
notfify方法，唤醒处于等待的某一个线程，使其结束等待
notifyall方法，唤醒所有处于等待的线程，使他们结束等待。

输入输出流

输出流：

流就是指一串流动的字符，以先进先出的方式发送信息的通道。
System.out.println("test")
输出流就是程序进行写操作，将字符串"test" 以 t. e. s. t的形式一个一个通过通道塞到目的地，而这个通道就是流的形式。
更多的操作比如打印文件也是通过流的方式。

输入流

程序通过流的形式读取数据，比如键盘输入数据，程序通过流的形式一个一个读取数据，比如读取文件，也是通过流的形式。
输入对应读取
输出对应写入

File类

Java的标准库java.io提供了File对象来操作文件和目录。

文件或文件目录

构造一个File对象，即使传入的文件或目录不存在，代码也不会出错，因为构造一个File对象，并不会导致任何磁盘操作。只有当我们调用File对象的某些方法的时候，才真正进行磁盘操作。

 // file// File file = new File("./test.txt");// File file = new File("/Users/test/Desktop/java/test.txt");File file1 = new File("/Users/test");File file = new File(file1, "Desktop/java/test.txt");System.out.println("是否文件" + file.isFile());System.out.println("是否目录" + file.isDirectory());System.out.println(file.getPath()); // 传入的路径System.out.println(file.getAbsolutePath()); // 绝对路径try {System.out.println(file.getCanonicalPath()); // 规范路径} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}// 创建目录File file2 = new File("./test/test2");System.out.println("test2存在?" + file2.exists());if (!file2.exists()) {// 不存在则创建目录file2.mkdirs();// 多层级用mkdirs，单层用mkdir}// 创建文件 createNewFileFile file3 = new File("./test2.txt");if (!file3.exists()) {try {file3.createNewFile();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}

new File可以传入绝对路径，也可以传入相对路径。
file.exists()判断文件是否存在
file.isDirector判断file是否目录
file.isFile()判断file是否文件
file.mkdir[s]创建file目录,+s表示多层目录
file.createNewFile()创建file文件
file.getPath() 传入的路径
file.getAbsolutePath() 绝对路径
file.getCanonicalPath 规范路径
boolean canExecute()：是否可执行；
long length()：文件字节大小。
file.delete() 删除文件，成功返回true

注意Windows平台使用\作为路径分隔符，在Java字符串中需要用\表示一个\。Linux平台使用/作为路径分隔符

// 假设当前目录是C:\Docs
File f1 = new File("sub\\javac"); // 绝对路径是C:\Docs\sub\javac
File f3 = new File(".\\sub\\javac"); // 绝对路径是C:\Docs\sub\javac
File f3 = new File("..\\sub\\javac"); // 绝对路径是C:\sub\javac

规范路径

 File f = new File("..");System.out.println(f.getPath());System.out.println(f.getAbsolutePath());try {System.out.println(f.getCanonicalPath());} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}

打印结果

..
/Users/test/Desktop/java/..
/Users/test/Desktop

可以看到，绝对路径就是/Users/test/Desktop/java/…，规范路径就是把.和…转换成标准的绝对路径后的路径
如/Users/test/Desktop/java/..实际上就是/Users/test/Desktop

打印系统分隔符

System.out.println(File.separator); // 根据当前平台打印"“或”/"

其他文件操作

程序需要读写一些临时文件，File对象提供了createTempFile()来创建一个临时文件，以及deleteOnExit()在JVM退出时自动删除该文件。

  public static void main(String[] args) throws IOException {File f = File.createTempFile("tmp-", ".txt"); // 提供临时文件的前缀和后缀f.deleteOnExit(); // JVM退出时自动删除System.out.println(f.isFile());System.out.println(f.getAbsolutePath());}

遍历文件和目录

当File对象表示一个目录时，可以使用list()和listFiles()列出目录下的文件和子目录名。

 public static void main(String[] ages) {File f = new File("./");String[] fs1 = f.list();System.out.println(Arrays.toString(fs1));// printFiles(fs1);File[] fs2 = f.listFiles(new FilenameFilter() {public boolean accept(File dir, String name) {return name.endsWith(".txt");}});printFiles(fs2);}static void printFiles(File[] files) {System.out.println("==========");if (files != null) {for (File f : files) {System.out.println(f);}}System.out.println("==========");}

file.list()获取当面文件目录的名称，返回字符串数组，即使是目录也会返回。
file.listFiles可以遍历当前文件目录下的所有文件/文件夹，参数可以传入FilenameFilter实例，过滤数据。

Path

Java标准库还提供了一个Path对象，它位于java.nio.file包。Path对象和File对象类似，但操作更加简单：

 Path p1 = Paths.get(".", "text.txt"); // 构造一个Path对象 System.out.println(p1); //传入的路径Path p2 = p1.toAbsolutePath(); // 转换为绝对路径System.out.println(p2);Path p3 = p2.normalize(); // 转换为规范路径System.out.println(p3);File f = p3.toFile(); // 转换为File对象System.out.println(f.isFile());

结果就是

./text.txt
/Users/test/Desktop/java/./text.txt
/Users/test/Desktop/java/text.txt
/Users/test/Desktop/java/text.txt

p1 传入的路径
p1.toAbsolutePath()转为绝对路径
p1.normalize转为规范路径
p1.toFile转为file对象

如果需要对目录进行复杂的拼接、遍历等操作，使用Path对象更方便。

小结

Java标准库的java.io.File对象表示一个文件或者目录：

创建file对象不涉及IO操作
通过file.getPath, getAbsoultePath(), getCanonicalPath() 可以获取传入的路径，绝对路径和规范路径
file.lists() 获取当前目录下的所有文件/文件夹的名称，返回数组，file.listFiles返回目录下的所有file对象
可以创建或删除文件和目录。

InputStream 输入流

InputStream就是Java标准库提供的最基本的输入流。它位于java.io这个包里。java.io包提供了所有同步IO的功能。
InputStream并不是一个接口，而是一个抽象类，它是所有输入流的超类。这个抽象类定义的一个最重要的方法就是int read()
public abstract int read() throws IOException;
这个方法会读取输入流的下一个字节，并返回字节表示的int值（0~255）。如果已读到末尾，返回-1表示不能继续读取了。

FileInputStream

FileInputStream是InputStream的子类

public void readFile() throws IOException {try {InputStream input = new FileInputStream("./test.txt");for (;;) {int n;n = input.read();if (n == -1) {break;}System.out.println(n); // 打印byte的值}} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally{if (input != null) { input.close(); }}
}

文件不存在导致无法读取，没有写权限导致写入失败，等等，这些底层错误由Java虚拟机自动封装成IOException异常并抛出
所有与IO操作相关的代码都必须正确处理IOException

用try … finally来编写上述代码会感觉比较复杂，更好的写法是利用Java 7引入的新的try(resource)的语法，只需要编写try语句，让编译器自动为我们关闭资源。

public void readFile() throws IOException {try (InputStream input = new FileInputStream("src/readme.txt")) {int n;while ((n = input.read()) != -1) {System.out.println(n);}} // 编译器在此自动为我们写入finally并调用close()
}

实际上，编译器并不会特别地为InputStream加上自动关闭。编译器只看try(resource = …)中的对象是否实现了java.lang.AutoCloseable接口，如果实现了，就自动加上finally语句并调用close()方法。InputStream和OutputStream都实现了这个接口，因此，都可以用在try(resource)中。

缓冲

在读取流的时候，一次读取一个字节并不是最高效的方法。很多流支持一次性读取多个字节到缓冲区，对于文件和网络流来说，利用缓冲区一次性读取多个字节效率往往要高很多。

InputStream提供了两个重载方法来支持读取多个字节：

int read(byte[] b)：读取若干字节并填充到byte[]数组，返回读取的字节数
int read(byte[] b, int off, int len)：指定byte[]数组的偏移量和最大填

read()方法会尽可能多地读取字节到缓冲区，但不会超过缓冲区的大小。read()方法的返回值不再是字节的int值，而是返回实际读取了多少个字节。如果返回-1，表示没有更多的数据了。

 try (InputStream input = new FileInputStream("src\\test.txt")) {byte[] buffer = new byte[5];int n;while ((n = input.read(buffer)) != -1) { // 读取到缓冲区System.out.println("read" + n + "bytes");// read5bytes// read5bytes// read1bytes}}

一次读取5个字节

阻塞

read方法读取数据的时候，read方法是阻塞的，他的意见是

int n;
n = input.read(); // 必须等待read()方法返回才能执行下一行代码
int m = n;

执行到第二行代码时，必须等read()方法返回后才能继续。因为读取IO流相比执行普通代码，速度会慢很多，因此，无法确定read()方法调用到底要花费多长时间。

InputStream实现类

用FileInputStream可以从文件获取输入流，这是InputStream常用的一个实现类。此外，ByteArrayInputStream可以在内存中模拟一个InputStream

public class Main {public static void main(String[] args) throws IOException {byte[] data = { 72, 101, 108, 108, 111, 33 };try (InputStream input = new ByteArrayInputStream(data)) {int n;while ((n = input.read()) != -1) {System.out.println((char)n);}}}
}

用ByteArrayInputStream,实际上是把一个byte[]数组在内存中变成一个InputStream。
我们稍微改变下

   String s;try (InputStream input = new FileInputStream("src\\test.txt")) {s = readAsString(input);}System.out.println(s);byte[] data = { 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100 };try (InputStream input2 = new ByteArrayInputStream(data)) {String s2 = readAsString(input2);System.out.println(s2);}public static String readAsString(InputStream input) throws IOException {int n;StringBuilder sb = new StringBuilder();while ((n = input.read()) != -1) {System.out.print(n + "\n");sb.append((char) n);}return sb.toString();}