------------恢复内容开始------------
Java笔记
一直以来，总想着Java会点基础就可以写后端程序了，但越到后来越发现Java基础的重要性。更不必说在面试时，Java基础有多么的重要。为了防止学了就忘，还是决定花点时间边查资料边整理成笔记。
才疏学浅，若有错误，望大力斧正。
一、Demo与运行
1、选择合适的IDE
首选eclipse和IDEA，社区版不推荐用，但企业版要￥，不过有破解方法和申请免费的方法。
在接触Spring后，愈发爱上了IDEA。
2、环境变量配置
没啥好说的
JAVA_HOME, Path
3、简单的helloworld示例
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}运行方式：
$ javac HelloWorld.java
$ java HelloWorld
Hello Worldjavac将source编译成class字节码
java直接由jvm运行class字节码（java命令后无需加.class后缀）
4、谈下jdk版本
面试可能容易问道这个，具体特性理解放在后面再谈，如果想掌握扎实，可能还得结合源码。
- jdk1.5
自动装箱与拆箱
枚举
静态导入
可变参数(Varargs)
内省(Introspector)
泛型(Generic)
For-Each寻缓缓
- jdk1.6
Desktop类和System Tray类
使用JAXB2来实现对象与XML之间的映射
StAX
使用Compiler API
轻量级Http Server API
插入式注解处理API（Pluggable Annotation Processing API）
可用Console开发控制台程序
对ruby\goovy\js脚本语言支持
Comman Annotations
- jdk1.7
switch
“<>”这个玩意的运用 List tempList = new ArrayList<>(); 即泛型实例化类型自动推断
自定义自动关闭类
新增一些取环境信息的方法
Boolean类型反转、空指针安全、参与位运算
char之间的equals
安全的加减乘除
对Collections的增强
数值可加下划线
支持了二进制文字
简化了可变参数方法的调用
在try catch异常捕捉中，一个catch可以写多个异常类型，用“|”隔开
1.7之后，try{}}finally{}的finally不一定要来关闭资源，也可以省略
- jdk1.8（8）
接口的默认方法
Lambda表达式
函数式接口
方法与构造函数引用
Lambda作用域
访问局部变量
访问对象字段与静态变量
访问接口默认方法
Data API
Annotation注解
总之，1.8是划时代的
- jdk1.9（9）
响应式编程模型Reactive
Linking
JShell：交互式Java REPL
改进的Javadoc
集合工厂方法
改进的Stream API
私有接口方法
HTTP/2
多版本兼容JAR
- jdk10（10）
局部变量类型推断
应用类数据共享(CDS)
额外的 Unicode 语言标签扩展
基于时间的版本控制
根证书
并行全垃圾回收器 G1
移除 Native-Header 自动生成工具
垃圾回收器接口
线程-局部变量管控
在备用存储装置上的堆分配
试验性的基于 Java 的 JIT 编译器
合并 JDK 多个代码仓库到一个单独的储存库中
- jdk11
1、本地变量类型推断
2、字符串加强
3、集合加强
4、Stream 加强
5、Optional 加强
6、InputStream 加强
7、HTTP Client API
8、化繁为简，一个命令编译运行源代码
- jdk12
1.Shenandoah：低暂停时间的 GC（实验性功能）
2.微基准测试套件
3.Switch 表达式（预览功能）
4.JVM 常量 API
5.只保留一个 AArch64 实现
6.默认类数据共享归档文件
7.可中止的 G1 混合 GC
8.G1 及时返回未使用的已分配内存
- jdk13
1: Dynamic CDS Archives
2.: ZGC: Uncommit Unused Memory
3: Reimplement the Legacy Socket API
4: Switch Expressions (Preview)
5: Text Blocks (Preview）
二、基础语法与数据类型
1、基础语法
没啥好说的，跟c差不多
提醒下，善用文档注释↓，这样写出来的代码会清爽很多。
/**
*
*/- 类首字母大写
- 包小写
- 方法首字母小写的驼峰
- 静态变量全大写
2、内置8种数据类型
byte：
- byte 数据类型是8位、有符号的，以二进制补码表示的整数；
- 最小值是 -128（-2^7）；
- 最大值是 127（2^7-1）；
- 默认值是 0；
- byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
- 例子：byte a = 100，byte b = -50。
short：
- short 数据类型是 16 位、有符号的以二进制补码表示的整数
- 最小值是 -32768（-2^15）；
- 最大值是 32767（2^15 - 1）；
- Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
- 默认值是 0；
- 例子：short s = 1000，short r = -20000。
int：
- int 数据类型是32位、有符号的以二进制补码表示的整数；
- 最小值是 -2,147,483,648（-2^31）；
- 最大值是 2,147,483,647（2^31 - 1）；
- 一般地整型变量默认为 int 类型；
- 默认值是 0 ；
- 例子：int a = 100000, int b = -200000。
long：
- long 数据类型是 64 位、有符号的以二进制补码表示的整数；
- 最小值是 -9,223,372,036,854,775,808（-2^63）；
- 最大值是 9,223,372,036,854,775,807（2^63 -1）；
- 这种类型主要使用在需要比较大整数的系统上；
- 默认值是 0L；
- 例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
float：
- float 数据类型是单精度、32位、符合__IEEE 754__标准的浮点数；
- float 在储存大型浮点数组的时候可节省内存空间；
- 默认值是 0.0f；
- 浮点数不能用来表示精确的值，如货币；
- 例子：float f1 = 234.5f。
double：
- double 数据类型是双精度、64 位、符合__IEEE 754__标准的浮点数；
- 浮点数的默认类型为double类型；
- double类型同样不能表示精确的值，如货币；
- 默认值是 0.0d；
- 例子：double d1 = 123.4。
boolean：
- boolean数据类型表示一位的信息；
- 只有两个取值：true 和 false；
- 这种类型只作为一种标志来记录 true/false 情况；
- 默认值是 false；
- 例子：boolean one = true。
char：
- char类型是一个单一的 16 位 Unicode 字符；
- 最小值是 \u0000（即为0）；
- 最大值是 \uffff（即为65,535）；
- char 数据类型可以储存任何字符；
- 例子：char letter = 'A';。
3、数值类型相关的常量
public class PrimitiveTypeTest {
public static void main(String[] args) {
// byte
System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
System.out.println("包装类：java.lang.Byte");
System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();
// short
System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
System.out.println("包装类：java.lang.Short");
System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();
// int
System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
System.out.println("包装类：java.lang.Integer");
System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();
// long
System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
System.out.println("包装类：java.lang.Long");
System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();
// float
System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
System.out.println("包装类：java.lang.Float");
System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();
// double
System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
System.out.println("包装类：java.lang.Double");
System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();
// char
System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
System.out.println("包装类：java.lang.Character");
// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
System.out.println("最小值：Character.MIN_VALUE="
+ (int) Character.MIN_VALUE);
// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
System.out.println("最大值：Character.MAX_VALUE="
+ (int) Character.MAX_VALUE);
}
}结果：
基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127
基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767
基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647
基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807
基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38
基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308
基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=655354、各个类型默认值
数据类型 | 默认值 |
byte | 0 |
short | 0 |
int | 0 |
long | 0L |
float | 0.0f |
double | 0.0d |
char | 'u0000' |
String (or any object) | null |
boolean | false |
5、final声明常量
用final修饰的变量无法修改，达到常量效果，请以全大写表示常量。2
6、关于自动类型转换
byte→short→int→long
char→int （ASCII）
7、关于强制类型转换
1.条件：转换的数据类型必须是兼容的
2.格式：(type)value
三、变量类型
1、抛砖引玉
public class Variable{
static int allClicks=0; // 类变量（静态变量）
String str="hello world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}2、简单提下变量类型对应的生命周期和存储位置
和其他语言类似，不多讲了。
生命周期
- 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁
- 实例变量在对象创建的时候创建，在对象被销毁的时候销毁
- 类被卸载时，类变量被销毁，并释放内存空间。static变量的生命周期取决于类的生命周期
存储位置
- 局部变量包括局部对象是在栈(stack)
- 实例变量包括实例对象是在堆(heap)
- 静态变量、.class字节码文件、常量池是在方法区(Method)
举个例子吧，看了就懂了：
class Fruit {
static int x = 10;
static BigWaterMelon bigWaterMelon_1 = new BigWaterMelon(x);
int y = 20;
BigWaterMelon bigWaterMelon_2 = new BigWaterMelon(y);
public static void main(String[] args) {
final Fruit fruit = new Fruit();
int z = 30;
BigWaterMelon bigWaterMelon_3 = new BigWaterMelon(z);
new Thread() {
@Override
public void run() {
int k = 100;
setWeight(k);
}
void setWeight(int waterMelonWeight) {
fruit.bigWaterMelon_2.weight = waterMelonWeight;
}
}.start();
}
}
class BigWaterMelon {
public BigWaterMelon(int weight) {
this.weight = weight;
}
public int weight;
}
（PS：期末没考这个，但对于面试再基础和重要不过了）
四、访问与非访问修饰符
1、访问修饰符
对应访问权限
修饰符 | 当前类 | 同一包内 | 子类(同一包) | 子类(不同包) | 其他包 |
| Y | Y | Y | Y | Y |
| Y | Y | Y | Y/N（子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。） | N |
| Y | Y | Y | N | N |
| Y | N | N | N | N |
如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。
protected的同包一定能访问，不同包但是子类有点复杂，可以看下
https://www.runoob.com/w3cnote/java-protected-keyword-detailed-explanation.html
package p2;
class MyObject2 {
protected Object clone() throws CloneNotSupportedException{
return super.clone();
}
}
package p22;
public class Test2 extends MyObject2 {
public static void main(String args[]) {
MyObject2 obj = new MyObject2();
obj.clone(); // Compile Error ----（1）不能访问基类实例的
Test2 tobj = new Test2();
tobj.clone(); // Complie OK ----（2）能访问基类继承而来的
}
}访问控制和继承
请注意以下方法继承的规则：
- 父类中声明为 public 的方法在子类中也必须为 public。
- 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
- 父类中声明为 private 的方法，不能够被继承。
理解：我感觉像是为了符合继承只能做加法，不能做减法的原则，使得oop更加规范。
2、非访问控制符
概述
- static 静态变量、类变量；局部变量不能声明为静态变量。存储在jvm方法区。
- final 修饰的类不能被继承、修饰的方法可以被继承但不能被继承类重写、修饰的变量为常量，不可修改。
- abstract 用来创建抽象类和抽象方法
- synchronized 线程用，表示只能由一个线程访问。
- volatile 线程用，表示可变的，修饰的成员变量每次被线程访问时，都强制从共享内存中重新读取该变量的值。而且，当成员变量发生变化时，会强制线程将变化值写回内存。这样再任何时刻，两个不同的线程总是看到某个成员变量同一个值。
- transient 不会被序列化（持久化），jvm在序列化时会跳过该特定的变量。
实例
- 用static做counter
public class InstanceCounter {
private static int numInstances = 0;
protected static int getCount() {
return numInstances;
}
private static void addInstance() {
numInstances++;
}
InstanceCounter() {
InstanceCounter.addInstance();
}
public static void main(String[] arguments) {
System.out.println("Starting with " +
InstanceCounter.getCount() + " instances");
for (int i = 0; i < 500; ++i){
new InstanceCounter();
}
System.out.println("Created " +
InstanceCounter.getCount() + " instances");
}
}- final作为常量，且static final 声明为类常量
public class Test{
final int value = 10;
// 下面是声明常量的实例
public static final int BOXWIDTH = 6;
static final String TITLE = "Manager";
public void changeValue(){
value = 12; //将输出一个错误
}
}- abstract抽象类，声明为抽象类的唯一目的是为了将来可以对该类进行扩充。一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
abstract class Caravan{
private double price;
private String model;
private String year;
public abstract void goFast(); //抽象方法
public abstract void changeColor();
}- synchronized 声明使得该方法同一时间只能被同一个线程访问
public synchronized void showDetails(){
.......
}- volatile 声明易变，强制线程调用时都要重新读取且变化时写回内存
public class MyRunnable implements Runnable //实现Runnable接口来开启多线程
{
private volatile boolean active;
public void run()
{
active = true;
while (active) // 第一行
{
// 代码
}
}
public void stop()
{
active = false; // 第二行
}
}通常情况不声明volatile下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止（run()读取的仍为缓冲区的，而非堆的被另一线程改变的）。
但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。
五、运算符
没啥好讲的，和其他语言差不多。
至于精确的浮点数运算，用BigDecimal类吧。
右移和instanceof讲一下吧
1. 右移
>> 自动补原先操作数
>>> 操作数补为02. instanceof
String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真instanceof的实现原理如下如下
boolean result;
if (obj == null) { //先判断变量（或实例）是否为null，若为null，则返回false
result = false;
} else {
try { //利用可强转为类（或接口）不报错则返回ture
T temp = (T) obj;
result = true;
} catch (ClassCastException e) {
result = false;
}
}六、循环语句与条件
1.概述
Java中有三种主要的循环结构：
- while 循环
- do…while 循环
- for 循环
- for each循环
Java中有两种主要的条件结构：
- if else
- switch
- for 循环
- for each循环
没啥好说的，重点说下for each，jdk1.5（5）开始有了for each
2. for each
for(Type x : obj) { 引用x的java语句;}
public class Test {
public static void main(String args[]){
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
}3. break、continue
continue跟c一样。
break相比c的用法，还多了一个带标签的break，用于跳出指定嵌套层。
for (int i = 0; i < 2; i++) {//变量为i的循环
read_date://break标签，指向变量为j的循环
for (int j = 0; j < 2; j++) {//变量为j的循环
for (int z = 0; z < 2; z++){//变量为z的循环
System.out.print(i);
System.out.print(j);
System.out.println(z);
if ((i == 0) && (j == 1) & (z == 1)){
break read_date;//此时中断变量为j的循环
}
}
}
}4. switch
跟c一样。
public class Test {
public static void main(String args[]){
//char grade = args[0].charAt(0);
char grade = 'C';
switch(grade)
{
case 'A' :
System.out.println("优秀");
break;
case 'B' :
case 'C' :
System.out.println("良好");
break;
case 'D' :
System.out.println("及格");
break;
case 'F' :
System.out.println("你需要再努力努力");
break;
default :
System.out.println("未知等级");
}
System.out.println("你的等级是 " + grade);
}
}七、Java Number & Math类
1. Number抽象类
内置数据类型，如：byte、int、long、double 等，这些我们经常使用。但有时我们需要用对象而非内置数据类型，为了解决这个问题，Java为每个内置数据类型提供了对应的包装类(Wrapper Class)。
Numbers是一个抽象类，它是所有内置数值类型对应的包装类的父类。Number 类属于 java.lang 包。
Java 自动装箱和拆箱（Autoboxing and Unboxing）
简单一点说，装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。
下面是一个使用 Integer 对象的实例：
public class Test{
public static void main(String args[]){
Integer x = 5; //由于x是对象，在需要被直接赋值时，用到了自动装箱
x = x + 10;//由于x是对象，在需要被运算时，用到了自动装箱
System.out.println(x);
}
}2. Math类
下面的表中列出的是 Number & Math 类常用的一些方法（都是静态方法，类名.方法名就可以调用）：
序号 | 方法与描述 |
1 | 将 Number 对象转换为xxx数据类型的值并返回。 |
2 | 将number对象与参数比较。 |
3 | 判断number对象是否与参数相等。 |
4 | 返回一个 Number 对象指定的内置数据类型 |
5 | 以字符串形式返回值。 |
6 | 将字符串解析为int类型。 |
7 | 返回参数的绝对值。 |
8 | 返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。 |
9 | |返回小于等于（<=）给定参数的最大整数 。 |
10 | 返回与参数最接近的整数。返回类型为double。 |
11 | 它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。 |
12 | 返回两个参数中的最小值。 |
13 | 返回两个参数中的最大值。 |
14 | 返回自然数底数e的参数次方。 |
15 | 返回参数的自然数底数的对数值。 |
16 | 返回第一个参数的第二个参数次方。 |
17 | 求参数的算术平方根。 |
18 | 求指定double类型参数的正弦值。 |
19 | 求指定double类型参数的余弦值。 |
20 | 求指定double类型参数的正切值。 |
21 | 求指定double类型参数的反正弦值。 |
22 | 求指定double类型参数的反余弦值。 |
23 | 求指定double类型参数的反正切值。 |
24 | 将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。 |
25 | 将参数转化为角度。 |
26 | 将角度转换为弧度。 |
27 | 返回一个随机数。 |
八、Character类
// 原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';序号 | 方法与描述 |
1 | 是否是一个字母 |
2 | 是否是一个数字字符 |
3 | 是否是一个空白字符 |
4 | 是否是大写字母 |
5 | 是否是小写字母 |
6 | 指定字母的大写形式 |
7 | 指定字母的小写形式 |
8 | toString() 返回字符的字符串形式，字符串的长度仅为1 |
九、String类
字符串广泛应用 在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
创建字符串
创建字符串最简单的方式如下:
String greeting = "xxx";
在代码中遇到字符串常量时，这里的值是 "xxx""，编译器会使用该值创建一个 String 对象。
和其它对象一样，可以使用关键字和构造方法来创建 String 对象。
String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:
StringDemo.java 文件代码：
public class StringDemo{
public static void main(String args[]){
char[] helloArray = { 'r', 'b'};
String helloString = new String(helloArray); //字符数组也可以作为String类的构造参数
System.out.println( helloString );
}
}以上实例编译运行结果如下：
rb注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（详看笔记部分解析）。
如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。
字符串长度
用于获取有关对象的信息的方法称为访问器方法
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
下面的代码执行后，len 变量等于 14:
StringDemo.java 文件代码：
public class StringDemo {
public static void main(String args[]) {
String site = "abac";
int len = site.length();
System.out.println( "abac长度 : " + len );
}
}以上实例编译运行结果如下：
abca长度 : 4连接字符串
String 类提供了连接两个字符串的方法：
string1.concat(string2);
返回 string2 连接 string1 的新字符串。也可以对字符串常量使用 concat() 方法，如：
"我的名字是 ".concat("Runoob");更常用的是使用'+'操作符来连接字符串，如：
"Hello," + " runoob" + "!"结果如下:
"Hello, runoob!"下面是一个例子:
StringDemo.java 文件代码：
public class StringDemo { public static void main(String args[]) { String string1 = "菜鸟教程网址："; System.out.println("1、" + string1 + "www.runoob.com"); } }
以上实例编译运行结果如下：
1、菜鸟教程网址：www.runoob.com创建格式化字符串
我们知道输出格式化数字可以使用 printf() 和 format() 方法。
String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。
如下所示：
System.out.printf("浮点型变量的值为 " + "%f, 整型变量的值为 " + " %d, 字符串变量的值为 " + "is %s", floatVar, intVar, stringVar);
你也可以这样写
String fs; fs = String.format("浮点型变量的值为 " + "%f, 整型变量的值为 " + " %d, 字符串变量的值为 " + " %s", floatVar, intVar, stringVar);
String 方法
下面是 String 类支持的方法，更多详细，参看 Java String API 文档:
十、StringBuilder类和StringBuffer类
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
StringBuffer示例：
public class Test{
public static void main(String args[]){
StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");
sBuffer.append("www");
sBuffer.append(".runoob");
sBuffer.append(".com");
System.out.println(sBuffer);
}
}以上实例编译运行结果如下：
菜鸟教程官网：www.runoob.comStringBuffer 方法
以下是 StringBuffer 类支持的主要方法：
序号 | 方法描述 |
1 | public StringBuffer append(String s) 将指定的字符串追加到此字符序列。 |
2 | public StringBuffer reverse() 将此字符序列用其反转形式取代。 |
3 | public delete(int start, int end) 移除此序列的子字符串中的字符。 |
4 | public insert(int offset, int i) 将 |
5 | replace(int start, int end, String str) 使用给定 |
下面的列表里的方法和 String 类的方法类似：
序号 | 方法描述 |
1 | int capacity() 返回当前容量。 |
2 | char charAt(int index) 返回此序列中指定索引处的 |
3 | void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。 |
4 | void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 |
5 | int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。 |
6 | int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。 |
7 | int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。 |
8 | int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。 |
9 | int length() 返回长度（字符数）。 |
10 | void setCharAt(int index, char ch) 将给定索引处的字符设置为 |
11 | void setLength(int newLength) 设置字符序列的长度。 |
12 | CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。 |
13 | String substring(int start) 返回一个新的 |
14 | String substring(int start, int end) 返回一个新的 |
15 | String toString() 返回此序列中数据的字符串表示形式。 |
从源码深入分析Java中 StringBuffer和StringBuilder的异同？
- StringBuffer和StringBuilder都继承自抽象类AbstractStringBuilder，且实现了Serializable和,CharSequence。
- 存储数据的字符数组没有被final修饰，说明值可以改变，抽象类AbstractStringBuilder内部都提供了一个自动扩容机制，当发现长度不够的时候(初始默认长度是16)，会自动进行扩容工作，扩展为原数组长度的2倍加2，创建一个新的数组，并将数组的数据复制到新数组，所以对于拼接字符串效率要比String要高。
- 线程安全性：StringBuffer由于很多方法都被 synchronized 修饰了所以线程安全，但是当多线程访问时，加锁和释放锁的过程很平凡，所以效率相比StringBuilder要低。StringBuilder相反执行效率高，但是线程不安全。
执行速度:StringBuilder > StringBuffer > String。
- 继承关系分析
StringBuffer和StringBuiler都继承自AbstractStringBuilder类，JDK1.7源码如下：
/**StringBuffer类源码*/
public final class StringBuffer extends AbstractStringBuilder implements Serializable,CharSequence
/**StringBuilder类源码*/
public final class StringBuilder extends AbstractStringBuilder implements Serializable,CharSequence
/**AbstractStringBuilder类源码*/
abstract class AbstractStringBuilder implements Appendable，CharSequence动态实现扩容分析
StringBuffer的构造方法，JDK1.7源码如下：
/**默认长度是16*/
public StringBuffer()
{
super(16);
}
/**可以指定初始长度*/
public StringBuffer(int i)
{
super(i);
}
/**变量长度+16*/
public StringBuffer(String s)
{
super(s.length() + 16);
append(s);
}
/**变量长度+16*/
public StringBuffer(CharSequence charsequence)
{
this(charsequence.length() + 16);
append(charsequence);
}StringBuiler的构造方法，JDK1.7源码如下：
/**默认长度是16*/
public StringBuilder()
{
super(16);
}
/**可以指定初始长度*/
public StringBuilder(int i)
{
super(i);
}
/**变量长度+16*/
public StringBuilder(String s)
{
super(s.length() + 16);
append(s);
}
/**变量长度+16*/
public StringBuilder(CharSequence charsequence)
{
this(charsequence.length() + 16);
append(charsequence);
}抽象类AbstractStringBuilder扩容机制，JDK1.7源码如下：
public void ensureCapacity(int i)
{
if(i > 0)
ensureCapacityInternal(i);
}
private void ensureCapacityInternal(int i)
{
if(i - value.length > 0)
expandCapacity(i);
}
void expandCapacity(int i)
{
//扩展长度j = 为原数组长度的2倍加2
int j = value.length * 2 + 2;
if(j - i < 0)
j = i;
if(j < 0)
{
//注意：这里可能会溢出,溢出后是负数,
if(i < 0)
throw new OutOfMemoryError();
j = 2147483647;
}
value = Arrays.copyOf(value, j);
}由抽象类AbstractStringBuilder可知：StringBuffer和StringBuiler的扩容的机制在抽象类AbstractStringBuilder中实现，当发现长度不够的时候(默认长度是16)，会自动进行扩容工作，扩展为原数组长度的2倍加2，创建一个新的数组，并将数组的数据复制到新数组。
为什么要再加上2呢？在网上找了半天资料，然后在知乎上找到了一个合理的回答：在使用StringBuilder的时候，append()之后，我们一般会在后面在加上一个分隔符，例如逗号，也、就是再加上一个char，而char在java中占2个字节，避免了因为添加分隔符而再次引起扩容。不得不佩服JDK开发者的高瞻远瞩！
线程安全性分析
StringBuffer的相关方法，JDK1.7源码如下：
public synchronized StringBuffer append(Object obj)
{
super.append(String.valueOf(obj));
return this;
}
public synchronized String substring(int i, int j)
{
return super.substring(i, j);
}
public synchronized StringBuffer replace(int i, int j, String s)
{
super.replace(i, j, s);
return this;
}
public synchronized StringBuffer delete(int i, int j)
{
super.delete(i, j);
return this;
}
public synchronized int length()
{
return count;
}StringBuiler的相关方法，JDK1.7源码如下：
public StringBuilder append(Object obj)
{
return append(String.valueOf(obj));
}
public StringBuilder replace(int i, int j, String s)
{
super.replace(i, j, s);
return this;
}
public StringBuilder delete(int i, int j)
{
super.delete(i, j);
return this;
}
public volatile int length()
{
return super.length();
}由源码中我们可知：
StringBuffer几乎都是调用的父类的方法而且都加了synchronized修饰,所以是线程安全的；但是平凡的加锁和释放锁导致性能降低，执行速度上比StringBuffer要慢。
StringBuilder所有方法都没有用synchronized关键字修饰，所以线程不安全，但是由于没有加锁释放锁导的过程，执行速度上比StringBuffer要快。十一、Java数组
声明数组变量
dataType[] arrayRefVar; // 首选的方法
dataType arrayRefVar[]; // 效果相同，但不是首选方法创建数组
Java语言使用new操作符来创建数组，语法如下：
arrayRefVar = new dataType[arraySize];上面的语法语句做了两件事：
- 一、使用 dataType[arraySize] 创建了一个数组。
- 二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];另外，你还可以使用如下的方式创建数组。
dataType[] arrayRefVar = {value0, value1, ..., valuek};Array类提供 的常用静态方法
1 | public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。** |
2 | public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
3 | public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
4 | public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
十二、Data类
Java 日期时间
java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。
第一个构造函数使用当前日期和时间来初始化对象。
Date( )第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。
Date(long millisec)Date对象创建以后，可以调用下面的方法。
序号 | 方法和描述 |
1 | boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。 |
2 | boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。 |
3 | Object clone( ) 返回此对象的副本。 |
4 | int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。 |
5 | int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。 |
6 | boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。 |
7 | long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 |
8 | int hashCode( ) 返回此对象的哈希码值。 |
9 | void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。 |
10 | String toString( ) 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。 |
使用Date对象toString方法获取当前时间
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// 初始化 Date 对象
Date date = new Date();
// 使用 toString() 函数显示日期时间
System.out.println(date.toString());
}
}Mon May 04 09:51:52 CDT 2013格式化
没啥好说的，百度就vans了
测量时间
import java.util.*;
public class DiffDemo {
public static void main(String args[]) {
try {
long start = System.currentTimeMillis( );//初始时间戳，记得用long
System.out.println(new Date( ) + "\n");
Thread.sleep(5*60*10);
System.out.println(new Date( ) + "\n");
long end = System.currentTimeMillis( );//结束时间戳
long diff = end - start;//做差计算
System.out.println("Difference is : " + diff);
} catch (Exception e) {
System.out.println("Got an exception!");
}
}
}十三、finalize方法
Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。
在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。
finalize() 一般格式是：
protected void finalize()
{
// 在这里终结代码
}实例：
.尽量少用finalize函数。finalize函数是Java提供给程序员一个释放对象或资源的机会。但是，它会加大GC的工作量，因此尽量少采用finalize方式回收资源。
PS：复习一下protected
当在不同包时，子类能调用继承的父类方法，但不能调用父类实例的。总之，子类继承了父类的protected方法时，相当于是用自己的（虽然是抄的），所以直接调用、或者用super调用就没有问题。
但如果是是父类实例的，调用时需要跨包去找父类实例的方法，就会出现错误。
十四、gc
gc在面试时是重难点，涉及太多jvm的东西，在这就只放这篇高赞博客的链接了。
根据GC的工作原理，我们可以通过一些技巧和方式，让GC运行更加有效率，更加符合应用程序的要求。一些关于程序设计的几点建议：
1.最基本的建议就是尽早释放无用对象的引用。大多数程序员在使用临时变量的时候，都是让引用变量在退出活动域（scope）后，自动设置为 null.我们在使用这种方式时候，必须特别注意一些复杂的对象图，例如数组，队列，树，图等，这些对象之间有相互引用关系较为复杂。对于这类对象，GC 回收它们一般效率较低。如果程序允许，尽早将不用的引用对象赋为null.这样可以加速GC的工作。
2.尽量少用finalize函数。finalize函数是Java提供给程序员一个释放对象或资源的机会。但是，它会加大GC的工作量，因此尽量少采用finalize方式回收资源。
3.如果需要使用经常使用的图片，可以使用soft应用类型。它可以尽可能将图片保存在内存中，供程序调用，而不引起OutOfMemory.
4.注意集合数据类型，包括数组，树，图，链表等数据结构，这些数据结构对GC来说，回收更为复杂。另外，注意一些全局的变量，以及一些静态变量。这些变量往往容易引起悬挂对象（dangling reference），造成内存浪费。
5.当程序有一定的等待时间，程序员可以手动执行System.gc（），通知GC运行，但是Java语言规范并不保证GC一定会执行。使用增量式GC可以缩短Java程序的暂停时间。
十五、流Stream、文件File、IO
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。
一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。
但本节讲述最基本的和流与 I/O 相关的功能。我们将通过一个个例子来学习这些功能。
读取控制台输入
Java 的控制台输入由 System.in 完成。
为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。
下面是创建 BufferedReader 的基本语法：
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));BufferedReader 对象创建后，我们便可以使用 read() 方法从控制台读取一个字符，或者用 readLine() 方法读取一个字符串。
从控制台读取多字符输入
从 BufferedReader 对象读取一个字符要使用 read() 方法，它的语法如下：
int read( ) throws IOException每次调用 read() 方法，它从输入流读取一个字符并把该字符作为整数值返回。 当流结束的时候返回 -1。该方法抛出 IOException。
下面的程序示范了用 read() 方法从控制台不断读取字符直到用户输入 "q"。
BRRead.java 文件代码：
//使用 BufferedReader 在控制台读取字符
import java.io.*;
public class BRRead {
public static void main(String args[]) throws IOException {
char c;
// 使用 System.in 创建 BufferedReader
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("输入字符, 按下 'q' 键退出。");
// 读取字符
do {
c = (char) br.read();
System.out.println(c);
} while (c != 'q');
}
}以上实例编译运行结果如下:
输入字符, 按下 'q' 键退出。
runoob
r
u
n
o
o
b
q
q从控制台读取字符串
从标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法。
它的一般格式是：
String readLine( ) throws IOException
下面的程序读取和显示字符行直到你输入了单词"end"。
BRReadLines.java 文件代码：
//使用 BufferedReader 在控制台读取字符 import java.io.*; public class BRReadLines { public static void main(String args[]) throws IOException { // 使用 System.in 创建 BufferedReader BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String str; System.out.println("Enter lines of text."); System.out.println("Enter 'end' to quit."); do { str = br.readLine(); System.out.println(str); } while (!str.equals("end")); } }
以上实例编译运行结果如下:
Enter lines of text.
Enter 'end' to quit.
This is line one
This is line one
This is line two
This is line two
end
endJDK 5 后的版本我们也可以使用 Java Scanner 类来获取控制台的输入。
控制台输出
在此前已经介绍过，控制台的输出由 print( ) 和 println() 完成。这些方法都由类 PrintStream 定义，System.out 是该类对象的一个引用。
PrintStream 继承了 OutputStream类，并且实现了方法 write()。这样，write() 也可以用来往控制台写操作。
PrintStream 定义 write() 的最简单格式如下所示：
void write(int byteval)
该方法将 byteval 的低八位字节写到流中。
实例
下面的例子用 write() 把字符 "A" 和紧跟着的换行符输出到屏幕：
WriteDemo.java 文件代码：
import java.io.*; //演示 System.out.write(). public class WriteDemo { public static void main(String args[]) { int b; b = 'A'; System.out.write(b); System.out.write('\n'); } }
运行以上实例在输出窗口输出 "A" 字符
A注意：write() 方法不经常使用，因为 print() 和 println() 方法用起来更为方便。
读写文件
如前所述，一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。
下图是一个描述输入流和输出流的类层次图。
下面将要讨论的两个重要的流是 FileInputStream 和 FileOutputStream：
FileInputStream
该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
有多种构造方法可用来创建对象。
可以使用字符串类型的文件名来创建一个输入流对象来读取文件：
InputStream f = new FileInputStream("C:/java/hello");
也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：
File f = new File("C:/java/hello"); InputStream out = new FileInputStream(f);
创建了InputStream对象，就可以使用下面的方法来读取流或者进行其他的流操作。
序号 | 方法及描述 |
1 | public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。 |
2 | protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。 |
3 | public int read(int r)throws IOException{} 这个方法从 InputStream 对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。 |
4 | public int read(byte[] r) throws IOException{} 这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。 |
5 | public int available() throws IOException{} 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。 |
除了 InputStream 外，还有一些其他的输入流，更多的细节参考下面链接：
FileOutputStream
该类用来创建一个文件并向文件中写数据。
如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。
有两个构造方法可以用来创建 FileOutputStream 对象。
使用字符串类型的文件名来创建一个输出流对象：
OutputStream f = new FileOutputStream("C:/java/hello")
也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：
File f = new File("C:/java/hello"); OutputStream f = new FileOutputStream(f);
创建OutputStream 对象完成后，就可以使用下面的方法来写入流或者进行其他的流操作。
序号 | 方法及描述 |
1 | public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。 |
2 | protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。 |
3 | public void write(int w)throws IOException{} 这个方法把指定的字节写到输出流中。 |
4 | public void write(byte[] w) 把指定数组中w.length长度的字节写到OutputStream中。 |
除了OutputStream外，还有一些其他的输出流，更多的细节参考下面链接：
实例
下面是一个演示 InputStream 和 OutputStream 用法的例子：
fileStreamTest.java 文件代码：
import java.io.*; public class fileStreamTest { public static void main(String args[]) { try { byte bWrite[] = { 11, 21, 3, 40, 5 }; OutputStream os = new FileOutputStream("test.txt"); for (int x = 0; x < bWrite.length; x++) { os.write(bWrite[x]); // writes the bytes } os.close(); InputStream is = new FileInputStream("test.txt"); int size = is.available(); for (int i = 0; i < size; i++) { System.out.print((char) is.read() + " "); } is.close(); } catch (IOException e) { System.out.print("Exception"); } } }
上面的程序首先创建文件test.txt，并把给定的数字以二进制形式写进该文件，同时输出到控制台上。
以上代码由于是二进制写入，可能存在乱码，你可以使用以下代码实例来解决乱码问题：
fileStreamTest2.java 文件代码：
//文件名 :fileStreamTest2.java
import java.io.*;
public class fileStreamTest2 {
public static void main(String[] args) throws IOException {
File f = new File("a.txt");
FileOutputStream fop = new FileOutputStream(f);
// 构建FileOutputStream对象,文件不存在会自动新建
OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
// 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
writer.append("中文输入");
// 写入到缓冲区
writer.append("\r\n");
// 换行
writer.append("English");
// 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
writer.close();
// 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
fop.close();
// 关闭输出流,释放系统资源
FileInputStream fip = new FileInputStream(f);
// 构建FileInputStream对象
InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
// 构建InputStreamReader对象,编码与写入相同
StringBuffer sb = new StringBuffer();
while (reader.ready()) {
sb.append((char) reader.read());
// 转成char加到StringBuffer对象中
} System.out.println(sb.toString());
reader.close();
// 关闭读取流
fip.close();
// 关闭输入流,释放系统资源
}
}文件和I/O
还有一些关于文件和I/O的类，我们也需要知道：
Java中的目录
创建目录：
File类中有两个方法可以用来创建文件夹：
- mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
- mkdirs()方法创建一个文件夹和它的所有父文件夹。
下面的例子创建 "/tmp/user/java/bin"文件夹：
CreateDir.java 文件代码：
import java.io.File;
public class CreateDir {
public static void main(String args[]) {
String dirname = "/tmp/user/java/bin";
File d = new File(dirname);
// 现在创建目录
d.mkdirs();
}
}编译并执行上面代码来创建目录 "/tmp/user/java/bin"。
注意： Java 在 UNIX 和 Windows 自动按约定分辨文件路径分隔符。如果你在 Windows 版本的 Java 中使用分隔符 (/) ，路径依然能够被正确解析。
读取目录
一个目录其实就是一个 File 对象，它包含其他文件和文件夹。
如果创建一个 File 对象并且它是一个目录，那么调用 isDirectory() 方法会返回 true。
可以通过调用该对象上的 list() 方法，来提取它包含的文件和文件夹的列表。
下面展示的例子说明如何使用 list() 方法来检查一个文件夹中包含的内容：
DirList.java 文件代码：
import java.io.File;
public class DirList {
public static void main(String args[]) {
String dirname = "/tmp";
File f1 = new File(dirname);
if (f1.isDirectory()) {
System.out.println("目录 " + dirname);
String s[] = f1.list();
for (int i = 0; i < s.length; i++) {
File f = new File(dirname + "/" + s[i]);
if (f.isDirectory()) {
System.out.println(s[i] + " 是一个目录");
} else {
System.out.println(s[i] + " 是一个文件");
}
}
} else {
System.out.println(dirname + " 不是一个目录");
}
}
}以上实例编译运行结果如下：
目录 /tmp
bin 是一个目录
lib 是一个目录
demo 是一个目录
test.txt 是一个文件
README 是一个文件
index.html 是一个文件
include 是一个目录删除目录或文件
删除文件可以使用 java.io.File.delete() 方法。
以下代码会删除目录 /tmp/java/，需要注意的是当删除某一目录时，必须保证该目录下没有其他文件才能正确删除，否则将删除失败。
测试目录结构：
/tmp/java/
|-- 1.log
|-- testDeleteFileDemo.java 文件代码：
import java.io.File;
public class DeleteFileDemo {
public static void main(String args[]) {
// 这里修改为自己的测试目录
File folder = new File("/tmp/java/");
deleteFolder(folder);
}
// 删除文件及目录
public static void deleteFolder(File folder) {
File[] files = folder.listFiles();
if (files != null) {
for (File f : files) {
if (f.isDirectory()) {
deleteFolder(f);
} else {
f.delete();
}
}
}
folder.delete();
}
}------------恢复内容结束------------
