Java基础

Java简介

Java是一门程序设计语言，属于高级语言。Java针对不同的开发市场分为三个技术平台：JavaSE，JavaEE，JavaME。

JavaSE（Java Platform Standard Edition）：标准版，是为开发普通桌面应用的解决方案，JavaEE和JavaME都由此发展而来，包括了Java的核心库，如数据类型，集合，数据库连接和网络编程等。

JavaEE（Java Platform Enterprise Eidtion）：企业版，是为开发企业级应用的解决方案，包括Servlet，JSP，JavaBean，JDBC，EJB，WebService等技术。

JavaME（Java Platform Micro Edition）：小型版，是为开发电子消费产品和嵌入式设备的解决方案。JavaME主要用于小型数字电子设备上的应用程序的开发，为家电增加智能化控制和网络功能，为手机增加新游戏和通讯录管理功能。JavaME提供了HTTP等高级Internet协议，使移动电话能以Client和Server的方式直接访问Internet的全部信息，提供高效的无线交流。

Java语言特点

Java 语言不使用指针，而是引用。并提供了自动分配和回收内存空间，使得程序员不必为内存管理而担忧。引用与指针的区别引用指向一个对象，对引用操纵相当于对对象操作，指针指向内存地址，对指针操作相当于对内存空间操作。
Java 语言是面向对象的：继承封装和多态的特性。Java 语言提供类、接口和继承等面向对象的特性，支持类之间的单继承，支持接口之间的多继承，并支持类与接口之间的实现机制。
Java语言是分布式的：Java 语言支持 Internet 应用的开发，在基本的 Java 应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括 URL、URLConnection、Socket、ServerSocket 等。Java 的 RMI（远程方法激活）机制也是开发分布式应用的重要手段。
Java语言是跨平台的：Java 平台上被编译为体系结构中立的字节码格式（后缀为 class 的文件），然后可以在实现这个 Java 平台的任何系统中运行。
Java语言支持多线程：Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制，来提高程序运行效率。

JDK

JDK（Java Development Kit）是一套Java的开发环境，其中包括Java编辑器，Java运行工具，Java文档生成工具，Java打包工具等。JDK环境用于Java引用程序的开发。

JRE （java Runtime Environment）是Java运行时环境，用于运行Java代码，对于非开发人员只需要下载JRE就可以运行Java应用程序。

开发Java应用程序需要需要安装JDK环境，官方下载JDK，安装并配置环境变量，doc命令输入：java -version和javac -version出现版本号即为安装成功。

JDK目录介绍：

bin目录：存放java可执行程序，如java.exe(运行工具)、javac.exe（java编辑器），jar.exe（打包工具，将java程序生成可重复应用的工具包），javadoc.exe（文档生成工具）等。
jre目录：java运行时环境目录，包括java虚拟机，运行时的工具包，java引用启动器等。
include目录：jdk是由c和c++实现的，需要引用c的一些头文件。
lib目录：java类库或库文件，是开发工具使用的归档包文件。
src.zip:存放jdk的核心源代码。
javafx-src.zip:javase桌面引用开发的源文件。

JDK中最重要的就是java.exe和javax.exe以及jvm(Java Virtual Machine),javac用于编译java代码，java用于启动jvm并运行java代码。

包的定义与使用

同文件系统对目录的管理一样，java也引入了包机制，程序可以通过包的声明来对类定义目录。java中包是用来存放类的，功能相同的类放在同一个包中。
声明包用package声明类用class,**包的声明只能位于java源文件的第一行。**通过import关键字引入不同包下的类，包于包直接用.来区分。

package chapter.exanmple.Student

import chapter2.example.Teacher

class User{
	//代码
}

使用import package.*来导入包下的所有类。

在JDK中，不同功能的类方法在不同功能的包下，其中java包及其子包是核心包，javax即子包是扩展包。
Java的核心包：

java.util：包含大量工具类，集合等，如Arrays，List，Set。
java.net：包含网络编程的相关接口和类。
java.io：java输入输出有关的接口和类。
java.awt：java构建图形化界面相关的包和类。
java.swing:和awt一样构建桌面应用，最新的模块由javafx。
java.sql：数据库编程。

Java编程基础

每种编程语言都有一套属于自己的编程规范，Java同样由自己的编程规范，如代码的关键字，标识符，代码书写等。

Java代码格式

Java代码必须放在一个类中（面向对象的规范），类用class声明：

//声明一个Sutdent类
class Student{
	//Java代码
}

Java程序代码分为结构定义语句和功能执行语句，前者用于定义类或方法，后者来实现具体的功能。

class Student{
	//定义变量
	String name="zhansan";
	//执行功能
	System.out.print(name);
}

Java代码严格区分大小写，每条语句需用;隔开，用+连接需要换行的代码。

class Student{
	//三个不同的变量
	String Name="zhansan";
	String name="zhansan";
	String NNAME="zahnsan";
	//
	System.out.println(Name
	+name+
	NAME);
	
}

方法用括号()声明，方法名首字母小写

 public void show(){
        System.out.println(name+"---"+price);
    }
 
//声明格式
修饰符 返回值类型 方法名 (参数列表){
	//执行体
	return 返回值
}

Java的单行注释是//，多行注释是/*...*/,文档注释是/**...*/。文档注释是对一段代码的概括描述使用javadoc.exe将注释生成文档。
运行java程序必须要有一个主函数main

public class HelloWorld {
    /* 第一个Java程序
     * 它将输出字符串 Hello World
     */
    public static void main(String[] args) {
        System.out.println("Hello World"); // 输出 Hello World
    }
}

Java标识符

程序中需要标识符该标记包名，类名，方法名，参数和变量等，这些符号被称为标识符。标识符可以有字母数字下划线和美元符号组成，但标识符不能是数字开头，不能是java关键字。且定义标识符遵循以下规范：

包名所有字母一律小写；
类名和接口名首字母大写；
常量名都大写，单词之间通过下划线连接；
变量名和方法名第一个单词小写，后面单词首字母都大写。

Java关键字

Java变量

Java 语言是强类型（Strongly Typed）语言，强类型包含以下两方面的含义：所有的变量必须先声明、后使用。指定类型的变量只能接受类型与之匹配的值。

程序运行期间，产生的临时数据都保存在内存中，通过表示符来访问这些数据，Java变量是通过引用类型定义的。

整数类型一个byte占8为依次是16，32，64位，long定义时超过int的范围需要加L后缀。
浮点类型定义时要加f和d后缀，没有会当作double类型。当是科学表达法是e或E为以10为底+和-为正或负。

double

字符类，用'...'包裹。

变量类型转换

自动类型转化

自动转化必须满足两个条件：两种数据类彼此兼容，目标的取值范围大于源类型范围。
数值类型之间满足这两个条件可以自动转化：整数之间，整数转float，其他类型转double。

byte b=3;
int a=b;

强制类型转化

强制类型转化需要显示声明，强制类型转化可能会造成数据丢失。显示转换需要用(目标类型)标识

double a=34.5
int b=(int) a;

// b=34
char[] b='1234';
int a=(int) b;

变量作用域

Java中主要有如下几种类型的变量：局部变量，类变量（静态变量），成员变量（非静态变量）变量需要在其作用范围类才可以使用，这个作用范围为作用域。
方法中定义的变量都是局部变量：

成员变量，类变量定义在方法外类中，通过修饰词(public)来管理作用域，其实不仅可以在该包或类，方法中使用还能再其他包，模块中使用。参见访问权限一节。
成员变量：

public class Book {
    public String name;
    public double price;

    public Book(String name, double price){
        this.name=name;
        this.price=price;
    }

    public void show(){
        System.out.println(name+"---"+price);
    }
}

Java运算符

算数运行算符

在自增和自减运算时符号在前，是先自增或自减在进行其他运算，在后则先运算再自增或自减。
除法运算时，整数相除为整数，有小数参与才能得到小数。
取模运算时，运算结果符号取决于%符号左边的数。

赋值运算符

可以通过一条赋值语句对多个变量赋值：

int x,y,z;
x=y=x=5;

类似+=的符号都是先加再赋值：

int a=0;
a +=3;
//相当于a先加3再赋值给a

比较运算符

逻辑运算符

运算符优先级

分支结构

if...else分支：

//if选择
if(条件判断){
	//选择体
}

//if...else...
if(...){
	//
}
else{
	//
}

//if...else if ... else ...
if(...){
	//
}
else if(...){
	//
}
else{
	//
}

switch分支

switch(条件){
	case 条件值1: 
		//
		break;
	case 条件值1: 
		//
		break;
	...
	default:
		//
		break;
}

循环结构

while循环

while(循环条件){
	//执行语句
}

do…while循环

//do...while循环会先执行依次子判断
do{
	//执行语句
}while(循环条件);

for循环

for(初始条件;循环条件;操作表达式){
	//循环体
}

break和continue:break是跳出整个循环，continue是结束本次循环。

方法

方法是可重复利用的单元。

方法定义：

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法重载
Java程序允许再类中定义多个同名的方法，但是参数的类型和个数必须不同，这就是方法的重载。

class AddNumber{
	public int add(int a,int b){
		return a+b;
	}
	public int add(int a,int b,int c){
		return a+b+c;
	}
}

方法是解决一类问题的步骤的有序组合，方法包含于类或对象中方法在程序中被创建，在其他地方被引用。

方法调用
Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

数组

Java中可以使用以下格式来定义一个数组：

//声明式定义
int [] arr=new int[100];
/*
	含义是声明一个数组命名为arr占100个空间
*/

//初始化定义
int[] arr={...}
/*
	含义是声明一个int数组，赋值内容
*/

数组初始化：

int [] a=new int[]{1,2,3,4};  //定义有空间，初始化要一致
int [] b={1234};

数组通过下标访问。

多维数组：

int [][] arr=new int[][];
//定义是可以直接定义为几行几列直接在[]赋值

int [][] arr={{1,2,3},{4,5,6}};
//定义时初始化，标识两行三列的数组

面向对象

提到面向对象，先想到的时面向过程。面向过程就是分析解决问题所需要的方法步骤，然后把这些步骤一一实现。面向对象就是将将解决问题的事务划分为一个个对象，然后通过调用对象解决问题。在c语言中不同文件直接的相互引用通过引用头文件，但是这些头文件中的内容都直接执行了，即使不需要，而在面向对象中将对象实例化才执行，用则取。

面向对象的特性：

封装

类于对象

类时对某一抽象事物的描述，对象则是某类事物的个体。通过类的实例化得到各种不同的对象。

类的定义与对象的创建

定义类用class关键字,创建对象用new关键字，类成员变量或方法的引用用.。

修饰词 class 类名{
	//成员变量
	//成员方法

}

类名 变量 = new 类名();

public Person{
	public int age;

}

Person person=new Person();
prson.age;

变量定义在类中为成员变量，定义在方法中为局部变量。

类的封装

类的封装是指在定义一个类时将类的属性私有化，使用private关键字，私有化的属性只能在类中被访问，外界想访问需要使用public关键字修饰公有方法，其中包括getter和setter方法。

public class Student{
	private int age;

	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return this.age
	}
	public String toString(){
		return this.age;
	}
}

构造方法

在一个类中，实例化一个类时必须通过setter方法给属性赋值，getter方法获取属性值。而构造方法可以在实例化的同时为属性赋值。

构造方法的定义

一个类中定义一个构造方法需满足三个条件：

方法名与类名相同

在方法名前没有返回值类型的声明

方法中没有return返回值

构造方法的重载
构造方法也可以重载，只要满足重载的条件，参数类型不同，参数个数不同即可。

在Java中每个类都至少有一个构造方法，如果没有构造方法，系统会自动创建一个构造方法（没有参数也没有方法体）

this关键字
在类的方法中，变量的作用域是方法体内，如果要访问成员变量需要通过this关键字，this.成员变量。this表示当前对象。

通过this可以访问类的成员变量
通过this’可以访问成员方法’
构造方法是实例化时调用的，也可以通过this调用this(参数列表)。

垃圾回收

System.gc()实现垃圾回收。

static关键字

Java的static关键字，用于修饰类的成员，如成员变量，成员方法，以及代码块。static修饰的变量为静态变量，静态变量被所有实例共享，通过类名.方法名访问不需要实例化，每次引用同一个对象。修饰方法为静态方法，也通过类名.方法名调用。修饰代码块，为静态代码块，类被加载时静态代码块会执行，静态代码块只执行一次。

final关键字

final关键字用于修饰类，变量和方法，它时最终的含义，用该关键字修饰的类，方法，变量具有以下特性：

final修饰的类不能继承
final修饰的方法不能重写
final修饰的变量时常量，只能赋值一次

Java中允许类中定义类，称为成员内部类通过外部类.内部类变量=new 外部类().new内部类()调用。

继承

继承是指基于现有类的基础上构建一个新的类，构建出来的类为子类，子类自动具有父类所有的属性和方法。

extends关键子继承
一个类只能有一个直接父类。

public class Pig extends Animals{
	...
}

重写父类方法
在继承中，子类会继承父类的属性和方法，有时需要对父类的方法重写，重写需要与父类具有相同的方法名，参数列表及返回值类型。

super关键字
子类重写父类方法后，需要访问父类的属性或方法用super关键字。super.成员变量和super.成员方法(参数对列)，访问父类的构造方法super(参数对列)

抽象类
当类的方法无法具体定义时，可以将其定义为抽象类，抽象类允许成员方法没有方法体，而具体的实现方法在继承的子类重写实现。抽象类通过abstract修饰。

抽象类不能被实例化，需要继承类，通过子类实例化。

abstract class Animal{
	abstract void shout();
} 

class Dog extends Animal{
	void shout(){
		System.out.println("汪汪");
	}
}

接口
当一个抽象类的所有方法都为抽象方法时，可以将该类定义为接口。接口克服了单继承的限制，一个类可以实现多个接口，接口的变量默认public static final修饰，即全局变量；接口的方法默认public修饰。

定义接口通过interface关键字，并由implements关键字实现该接口。多个接口的实现用,隔开。

//定义接口
public interface 接口名{
	[默认public static finnal修饰] 变量类型  变量
	[默认public abstract修饰] 方法名(参数列表)
}

//接口的实现类
public 类名 implements  接口名{
	//
} 


//实现多个接口
public implements 接口名1,接口名2 ...{
	//
}

多态

在类的实例化时，需要声明类的类型，由于实现的类不同，从而具有效果各异的现象就是多态。继承是多态的基础。

//父类作为声明对象，子类作为实例化对象
Animal animal=new Dog()
/*
此时的animal具有Dog的特性
*/

Animal animal=new Pig()
/*
此时的animal具有Pig的特性
*/

对象类型的转换，子类当作父类对象使用。Animal animal=new Dog()，父类对象当作子类使用Dog dog=new Animal()。

Object类
Object类是类参差结构的根类，所有类都直接或间接继承该类。

异常

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。Exception 类是 Throwable 类的子类。除了Exception类外，Throwable 还有一个子类 Error 。Java 程序通常不捕获错误。Error 用来指示运行时环境发生的错误。

捕获异常

try..catch捕获异常
try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

//throws抛出异常
throws/throw关键字

public class className
{
   public void deposit(double amount) throws RemoteException
   {
      // Method implementation
      throw new RemoteException();
   }
   //Remainder of class definition
}

finally 关键字
finally 关键字用来创建在 try 代码块后面执行的代码块。无论是否发生异常，finally 代码块中的代码总会被执行。

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }finally{
    // 程序代码
 }

可以使用多个catch语句，每个catch分别捕获对应的Exception及其子类。JVM在捕获到异常后，会从上到下匹配catch语句，匹配到某个catch后，执行catch代码块，然后不再继续匹配。简单地说就是：多个catch语句只有一个能被执行。存在多个catch的时候，catch的顺序非常重要：子类必须写在前面。finally语句块保证有无错误都会执行。

处理异常的方法

try
{
   // 程序代码
}catch(Exception e)
{
   e.printStackTrace();
}

访问权限

类，成员变量，方法的修饰词,控制了其被访问的权限。

Java API

api是应用程序接口，调用java的接口实现各种功能。

String类

字符串广泛应用在Java编程中，在Java中字符串属于对象，Java提供了String类来创建和操作字符串。

最简单的创建方法：


String hello= "Hello world!";

Java StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和String类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的。

Java Number类

数据的基本数据类型：byte、int、short、long、double、float、boolean、char；

对应的包装类型也有八种：Byte、Integer、Short、Long、Double、Float、Character、Boolean;

基本数据类型只能够存储变量而相应的包装类包含操作变量的方法。

Java Character类

Java 语言为内置数据类型 char 提供了包装类 Character 类。Character类的用法：Character 类提供了一系列方法来操纵字符。
你可以使用 Character 的构造方法创建一个 Character 类对象，例如：

Character ch = new Character('a');

Date类

java.util包提供了Date类来封装当前的日期和时间。

//获取的是系统的时间戳
DateFormat format=new SimpleDateFormat("YYYYMMdd");
//格式化时间

System与Runtime类

runtime类表示虚拟机的运行状态，用于封装JVM进程，该类是单例模式，对象不能直接实例化，通过：

Runtime run=Runtime.getRuntime();

Scanner 类

java.util.Scanner是Java5的新特征，我们可以通过 Scanner 类来获取用户的输入。

 Scanner sc = new Scanner(System.in);

Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要使用 hasNext 与 hasNextLine 判断是否还有输入的数据：

import java.util.Scanner; 

public class ScannerDemo {  
    public static void main(String[] args) {  
        Scanner scan = new Scanner(System.in); 
		// 从键盘接收数据  

		//next方式接收字符串
        System.out.println("next方式接收：");
        // 判断是否还有输入
        if(scan.hasNext()){   
        	String str1 = scan.next();
        	System.out.println("输入的数据为："+str1);  
        }  

    }  
}

next()与nextLine()区别
next():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next()不能得到带有空格的字符串。
nextLine()：

1、以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

Math与Random类

math是数学计算的类，random用于生产一个随机数。

import java.lang.math;

Random random=new Random();

集合

Collection接口方法：

List接口

List接口方法：

ArrayList和LinkedList是顺序表和链表。

Iterrater接口

Iterater接口
Iterater接口是逸代器,用来遍历集合的元素。

ArrayList list=new ArrayList();

Iterater iterater=new Iterater();
while(iterater.hasNext()){
	Object obj=iterater.next();
	System.out.print(obj);
}

foreach循环
foreach循环也是用来遍历集合的元素的。

for(容器中元素类型 变量 ： 集合容器){
	//执行语句
}

Set接口

set接口中元素不重复，set和list的存取元素一样。

Map接口

map接口
Map接口时一种双列集合，每个元素存储一个键（key）对象和一个值对象（value），键和值对象对应关系为映射。Map的一个元素时一个Entry包含一个key-value。Map的键必须唯一。遍历Map通过获取键来遍历所有键取值或获取Entry再遍历。

Properties集合

Properties集合
Properties集合主要用来存储key-value字符串的，通过该集合来获取配置项。通过setProperties和getPropertes存取字符串，通过propertiesNames()方法得到包含所有键的集合对象。

泛型

集合可以存储任何类型的对象，但是把一个对象存入到集合后，集合会忘记这个对象的类型，只有再取出的时候，才编译为Object类型。如果事先不记得，声明时发生类型转换就会出错。Java引入了泛型的概念，即参数化类型。在操作集合时限定元素的类型，在定义集合时通过<T>指定该集合中元素数据类型，这样显示声明，就可以知道集合中元素的类型了。

//声明泛型
ArrayList<String> arr=new ArrayList<String>();

//该List集合只能存储String类

IO

应用程序之间需要与设备之间进行数据传输，例如显示屏输入数据，显示程序运行结果。在Java中不同设备之间的数据传输称为流。位于java.io包中。

IO流有很多，按照操作数据的不同分为字节流和字符流，按照传输方向的不同分为输入流和输出流。

在IO包中字节流的输入输出用java.io.InputStream和java.io.OutputStream。
在IO包中字符流的输入输出用java.io.Reader和java.io.Writer。

字节流输入流：

InputStream是所有的输入字节流的父类，它是一个抽象类。
ByteArrayInputStream、StringBufferInputStream(上图的StreamBufferInputStream)、FileInputStream是三种基本的介质流，它们分别从Byte数组、StringBuffer、和本地文件中读取数据。
PipedInputStream是从与其它线程共用的管道中读取数据.
ObjectInputStream和所有FilterInputStream的子类都是装饰流（装饰器模式的主角）。

字节输出流：

OutputStream是所有的输出字节流的父类，它是一个抽象类。
ByteArrayOutputStream、FileOutputStream是两种基本的介质流，它们分别向Byte数组、和本地文件中写入数据。PipedOutputStream是向与其它线程共用的管道中写入数据。
ObjectOutputStream和所有FilterOutputStream的子类都是装饰流。

字符流输入流：

Reader是所有的输入字符流的父类，它是一个抽象类。
CharReader、StringReader是两种基本的介质流，它们分别将Char数组、String中读取数据。PipedReader是从与其它线程共用的管道中读取数据。
BufferedReader很明显就是一个装饰器，它和其子类负责装饰其它Reader对象。
FilterReader是所有自定义具体装饰流的父类，其子类PushbackReader对Reader对象进行装饰，会增加一个行号。
InputStreamReader是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。FileReader可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将FileInputStream转变为Reader的方法。我们可以从这个类中得到一定的技巧。Reader中各个类的用途和使用方法基本和InputStream中的类使用一致。后面会有Reader与InputStream的对应关系。

字符输出流：

Writer是所有的输出字符流的父类，它是一个抽象类。
CharArrayWriter、StringWriter是两种基本的介质流，它们分别向Char数组、String中写入数据。PipedWriter是向与其它线程共用的管道中写入数据，
BufferedWriter是一个装饰器为Writer提供缓冲功能。
PrintWriter和PrintStream极其类似，功能和使用也非常相似。
OutputStreamWriter是OutputStream到Writer转换的桥梁，它的子类FileWriter其实就是一个实现此功能的具体类。功能和使用和OutputStream极其类似。

系统类System对IO的支持

System类对IO的支持,系统类的方法都是静态的。直接调用系统即可。System针对IO提供了标准输入、输出设备，如键盘、显示器进行信息交换的方式。

System.in（标准输入），通常代表键盘输入。借助Scanner类。

System.out（标准输出）：通常写往显示器。

System.err（标准错误输出）：通常写往显示器。

字节流

在计算机中，无论时文本，图片，还是音频，视频，所有文件都是以二进制（字节）形式存在的，IO中针对字节的输入输出统称为字节流。输入输出用java.io.InputStream和java.io.OutputStream是两个顶级接口。

InputStream常用方法

OutputStream常用方法


FileInputStream 常用的构造方法主要有如下两种重载形式。

FileInputStream(File file)：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String name)：通过打开一个到实际文件的链接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

FileOutputStream 类的构造方法主要有如下 4 种重载形式。

FileOutputStream(File file)：创建一个文件输出流，参数 file 指定目标文件。
FileOutputStream(File file,boolean append)：创建一个文件输出流，参数 file 指定目标文件，append 指定是否将数据添加到目标文件的内容末尾，如果为 true，则在末尾添加；如果为 false，则覆盖原有内容；其默认值为 false。
FileOutputStream(String name)：创建一个文件输出流，参数 name 指定目标文件的文件路径信息。
FileOutputStream(String name,boolean append)：创建一个文件输出流，参数 name 和 append 的含义同上。

字节流读取文件

FileInputStream(String fileName);
//创建文件输入流

文件数据是一种常见的IO操作，对文件的读写有专门的两个类FileOutputStream和FileInputStream。

//核心步骤

FileInputStream fis2 = new FileInputStream("F:/mxl.txt");
//处理传递文件名也可以传递File对象

字节流输出文件

FileOutputStream(String fileName,boolean append)
//创建文件输出流，append表示是否为追加

定义文件路径是要是用\\因为\是表示转义字符。

字节缓冲流
在字节流读取中通过read方法，将字节读取一个一个读取到目标中，这样效率很低，虽然提供了read(byte [] byte)方法，但是事先并不知道字节流长度。Java提供了字节缓冲流来提高效率。

用法都差不多。

字符流

尽管 Java 中字节流的功能十分强大，几乎可以直接或间接地处理任何类型的输入/输出操作，但使用字符流是操作字符集更方便。

Java 提供了用来读取字符文件的便捷类——FileReader。该类的构造方法有如下两种重载形式。

FileReader(File file)：在给定要读取数据的文件的情况下创建一个新的 FileReader 对象。其中，file 表示要从中读取数据的文件。
FileReader(String fileName)：在给定从中读取数据的文件名的情况下创建一个新 FileReader 对象。其中，fileName 表示要从中读取数据的文件的名称，表示的是一个文件的完整路径。

Java 提供了写入字符文件的便捷类——FileWriter，该类的构造方法有如下 4 种重载形式。

FileWriter(File file)：在指定 File 对象的情况下构造一个 FileWriter 对象。其中，file 表示要写入数据的 File 对象。
FileWriter(File file,boolean append)：在指定 File 对象的情况下构造一个 FileWriter 对象，如果 append 的值为 true，则将字节写入文件末尾，而不是写入文件开始处。
FileWriter(String fileName)：在指定文件名的情况下构造一个 FileWriter 对象。其中，fileName 表示要写入字符的文件名，表示的是完整路径。
FileWriter(String fileName,boolean append)：在指定文件名以及要写入文件的位置的情况下构造 FileWriter 对象。其中，append 是一个 boolean 值，如果为 true，则将数据写入文件末尾，而不是文件开始处。

字符缓冲区流

字符缓冲区输入流

BufferedReader 类主要用于辅助其他字符输入流，它带有缓冲区，可以先将一批数据读到内存缓冲区。接下来的读操作就可以直接从缓冲区中获取数据，而不需要每次都从数据源读取数据并进行字符编码转换，这样就可以提高数据的读取效率。

BufferedReader 类的构造方法有如下两种重载形式。

BufferedReader(Reader in)：创建一个 BufferedReader 来修饰参数 in 指定的字符输入流。
BufferedReader(Reader in,int size)：创建一个 BufferedReader 来修饰参数 in 指定的字符输入流，参数 size 则用于指定缓冲区的大小，单位为字符。

BufferedReader 还提供了 readLine() 方法，该方法返回包含该行内容的字符串，但该字符串中不包含任何终止符，如果已到达流末尾，则返回 null。readLine() 方法表示每次读取一行文本内容，当遇到换行（\n）、回车（\r）或回车后直接跟着换行标记符即可认为某行已终止。

字符缓冲区输出流

BufferedWriter 类主要用于辅助其他字符输出流，它同样带有缓冲区，可以先将一批数据写入缓冲区，当缓冲区满了以后，再将缓冲区的数据一次性写到字符输出流，其目的是为了提高数据的写效率。

BufferedWriter 类的构造方法有如下两种重载形式。

BufferedWriter(Writer out)：创建一个 BufferedWriter 来修饰参数 out 指定的字符输出流。
BufferedWriter(Writer out,int size)：创建一个 BufferedWriter 来修饰参数 out 指定的字符输出流，参数 size 则用于指定缓冲区的大小，单位为字符。

该类除了可以给字符输出流提供缓冲区之外，还提供了一个新的方法 newLine()，该方法用于写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义，并且不一定是单个新行（\n）符。

文件类

在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过 File 类来完成。File 类定义了一些方法来操作文件，如新建、删除、重命名文件和目录等。

File 类不能访问文件内容本身，如果需要访问文件内容本身，则需要使用输入/输出流。

系统流

每个 Java 程序运行时都带有一个系统流，系统流对应的类为 java.lang.System。Sytem 类封装了 Java 程序运行时的 3 个系统流，分别通过 in、out 和 err 变量来引用。

System.in：标准输入流，默认设备是键盘。
System.out：标准输出流，默认设备是控制台。
System.err：标准错误流，默认设备是控制台。

System.in 是 InputStream 类的一个对象， System.in.read() 方法实际是访问 InputStream 类定义的 read() 方法。该方法可以从键盘读取一个或多个字符。对于 System.out 输出流主要用于将指定内容输出到控制台。

System.out 和 System.error 是 PrintStream 类的对象。因为 PrintStream 是一个从 OutputStream 派生的输出流，所以它还执行低级别的 write() 方法。因此，除了 print() 和 println() 方法可以完成控制台输出以外，System.out 还可以调用 write() 方法实现控制台输出。

PrintStream和PrintWriter

PrintStream扩展OutputStream的接口，额外提供了一些写入各种数据类型的方法：

写入int：print(int)
写入boolean：print(boolean)
写入String：print(String)
写入Object：print(Object)，实际上相当于print(object.toString())

规避了只能通过write写入字节的缺陷。经常使用的System.out.println()实际上就是使用PrintStream写入各种数据。其中，System.out是系统默认提供的PrintStream。

PrintStream和OutputStream相比，除了添加了一组print()/println()方法，可以打印各种数据类型，比较方便外，它还有一个额外的优点，就是不会抛出IOException，这样我们在编写代码的时候，就不必捕获IOException。

PrintStream最终输出的总是byte数据，而PrintWriter则是扩展了Writer接口，它的print()/println()方法最终输出的是char数据。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/156303.html