长文：Java入门教程

Littlewith

于 2025-08-03 10:13:09 发布

阅读量409

点赞数 13

CC 4.0 BY-SA版权

分类专栏： Java系列教程文章标签： java python 开发语言运维 debian 服务器 eclipse

本文链接：https://blog.csdn.net/Andytoe/article/details/149876436

Java系列教程专栏收录该内容

8 篇文章

订阅专栏

Java

java是默认面向对象编程的

类与对象：

对象：类的一个实例
类：一个模板，描述对象的行为
方法：对象的行为
实例变量：每个对象都有独特的实例变量

第一个JAVA程序

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}

主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

Java数据类型

两大数据类型：内置数据类型、引用数据类型。

内置数据类型

byte:字节:8位、有符号、二进制补码表示的整数
byte表示的范围是-128–>127，否则必须进行转换。

byte a = 1;
short:短:16位、有符号二进制补码表示的整数

short b = 1;
int:常规
long:长
float:浮点数
double:双精度浮点数
boolen: true,false
char:‘A’

引用类型

类似于C/C++的指针，引用类型指向一个对象，指向对象的变量是引用变量，这些变量在声明时被指定为一个特定的类型，一旦声明就不能被改变了
对象、数组都是引用数据类型
所有引用变量可用来引用任何与之兼容的类型

常量

使用final关键字进行定义
声明方式和变量类似

final double PI = 3.14159265;
字面量可以赋值给任何内置类型的变量

byte a =68;
char a = ‘A’;
byte、int、long、short都可以用十进制、十六进制和八进制进行表示

int decimal = 100;
int octal = 0144;
int hexa = 0x64;
字符串常量

char a = ‘\u0001’;
String a = ‘\u0001’;

自动类型转换

和C语言类似，Java中默认也支持类型自动转换
从低到高
低------------------------------>高
byte,short,char,intlong,float,double
不能对boolen类型进行转换
不能把对象转换为不相关类的对象
不能把容量大的转换为容量小的
可能损失精度

public class HelloWorld {
public static void main(String[] args){
char c1 = ‘A’;
int c2 = c1;
System.out.println("c2的值为: "+c2);
}
}

强制类型转换

和C语言语法相同

public class HelloWorld {
public static void main(String[] args){
int i1 = 123;
byte b = (byte)i1;
System.out.println("int强制类型转换后为: "+b);
}
}

变量

所有的变量在使用之前必须进行声明

int a,b,c;
java支持的变量类型有

类变量：独立于方法之外的变量，用static修饰
实例变量：独立于方法之外的变量，没有static修饰
局部变量：类的方法中的变量

public class variable {
    static int allClicks = 0;//类变量
    String str = "Hello World!";//实例变量
    public void method(){
        int i = 0;//局部变量
    }
}

Java局部变量

在方法、构造方法、语句块中，当执行时创建，运行完即销毁
访问修饰符不能用于局部变量
实在栈上分配的，没有默认值
类似于C语言在函数中的值

public class Test {
public void pupAge(){
int age = 0;
age += 7;
System.out.println(“小狗的年龄是：”+age);
}
}

Java实例变量

声明在一个类中，但是在方法之外定义的
当一个对象被实例化后，对象内的变量的值即被确定
在对象被构造的时候创建，在对象被析构的时候销毁
应该至少定义一个接口使得该变量能被获取
访问修饰符可以修饰实例变量
有默认值
可以直接访问，但是推荐使用限定名字（类.variable）

public class Employee {
public Employee(String name,String idnumber,float salary){//构造函数
this.name = name;
this.idnumber = idnumber;
this.salary = salary;
}
private String name;
//员工的名字
private String idnumber;
//工号
private float salary;
```
  public void show(){
      System.out.printf("我叫%s，我的工号是%s，我的薪水是%.2f",this.name,this.idnumber,this.salary);
  }
```
}
public static void main(String[] args){
Employee xiaoming = new Employee(“小米”,“12345”, (float) 18000.35);
xiaoming.show();
}

类变量（静态变量）

类变量也是静态变量，以static关键字声明，但是必须在方法之外定义
无论一个类创建了多少个对象，类只有类变量的一份拷贝
静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变
常常被声明为常量，很少单独声明变量
静态变量可以通过：ClassName.VariableName的方式访问。为了对使用着可见，大多数声明为public。
类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

public class StaticVariable {
//salary是静态的私有变量
private static double salary;
// DEPARTMENT是一个常量
public static final String DEPARTMENT = “开发人员”;
public static void main(String[] args){
salary = 10000;
System.out.println(DEPARTMENT+“平均工资:”+salary);
}
}

Java修饰符

Java语言提供了很多修饰符，主要分为以下

访问修饰符
非访问修饰符

访问修饰符

用于保护嘞、变量、方法、构造器等的访问，Java支持四种权限

default 默认，什么都不写
private 私有
public 公开
protected 保护
详细的访问控制见下面这张表格

修饰符	当前类	同一包内	子孙类（同一包）	子孙类（不同包）	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

非访问控制符

为了实现一些其他的功能，Java提供了许多非访问控制符

static 静态方法，修饰类方法和类变量
final 修饰符，修饰类、方法、变量。final修饰的类不能够被继承，修饰的方法可以继承但是不能重新定义，修饰的变量为常量，不可修改
abstract 修饰符，创建抽象类和抽象方法
synchronized和volatile修饰符，用于线程的编程

Java运算符

Java运算符同C++和C语言，这里略过

Java循环语句

Java三种循环，语句同C语言，这里略过

增强for循环

Java5引入了一种主要用于处理数组的增强型for循环
声明语句如下

for(声明语句:表达式)
{
    //一些代码
}


public class StrongFor {
    public void testfor(){
        int [] number = {10,20,30,40,50,60,70,80,90,100};
        for(int x:number){
            System.out.println("Now value is "+x);
        }
        String [] names = {"James","Larry","Tom","Lucy"};
        for(String key:names){
            System.out.println("Noe the name is "+ key);
        }
    }
}

Java条件语句

Java的条件语句和C语言相同，这里省略

Java switch语句

Java的switch语句和C语言基本相同，这里省略

Java Number & Math 类

一般情况下，需要使用数字的时候，使用内置数据类型
Java语言为每一个内置数据类型提供了一个对应的包装
包装类(Integer Long Byte Double Float Short) 都是抽象类Number的子类

这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。

public class NumberClass {
    public void jisuan(){
        Integer x = 5;
        x = x + 10;
        System.out.println("This is "+x);
    }
}

Java Math 类

顾名思义，这个类主要是用于处理数学运算相关的问题的
Math的方法都被定义为static形式，通过Math类可以在主函数中直接调用，所有方法都属于这个类，而不属于这个类中的任何实例。
Java官网中，声明不准任何人实例化这个类！！！

public class HelloWorld {
    public static void main(String[] args){
       MathClass newmath = new MathClass();
       newmath.show();
    }
    public static void sayhello(String whattosay){
        System.out.println("I say "+whattosay);
        return;
    }
}

Pi is 3.141592653589793
60度的正弦值 0.8660254037844386
-1的绝对值 1
Π/4的角度 45.0

Math中的其他方法还可以对一些数据进行四舍五入等操作，具体请查阅手册

Java Character类

Character类用于对单个字符进行的操作
Character类在对象中包装一个基本类型char
通过对character类包装可以使开发人员对于类的使用更加方便
可以通过Character类来定义一个字符

Character ch = new Character('a');

Character类的方法
通过使用Character类中的方法，可以方便的对类进行操作，具体的方法请查阅有关的资料

Java String类

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

创建字符串

最简单的写法是这样的

String str = "Runoob";

也可以利用构造函数来创建字符串

String str2 = new String("Runoob");

字符串长度

用于获取有关对象信息的方法称为访问器方法
使用length()来获取字符串的长度

public class StringClass {
    public void test(){
        String haha = new String("HAHAHAHAHAHAHAHA");
        System.out.println("The length is "+haha.length());
    }
}

连接字符串

String类提供了两个连接字符串的方法

使用函数来连接：

string1.concat(string2);
使用’+'操作符来进行连接

string3 = string1 + string2;

创建格式化字符串

使用format()静态放大可以返回一个String对象而不是PrintStream对象
能用来创建可复用的格式化字符串，而不是仅仅用于一次打印输出

String fs; 
fs = String.format("浮点型变量的值为 " + "%f, 整型变量的值为 " + " %d, 字符串变量的值为 " + " %s", floatVar, intVar, stringVar);

String方法

关于String对象也有很多方法，请参阅有关手册

Java StringBuffer和StringBulider类

当对字符串进行修改的时候需要使用StringBuffer和StringBuilder类
和String类不同的是，StringBuffer和StringBuilder类可以被修改多次，并且不产生新的未使用的对象
在使用StringBuffer类的时候，会对其本身进行操作，不会产生新的对象。

public class StringBuild {
    public void builder(){
        StringBuilder sb = new StringBuilder(10);
        System.out.println(sb);
        sb.append("Littlewith");
        System.out.println(sb);
        sb.append("!!!");
        System.out.println(sb);
        sb.insert(6,"_");
        System.out.println(sb);
        sb.delete(6,7);
        System.out.println(sb);
    }
}

Java数组

数组是用于存储固定大小的同类型元素的集合

声明数组变量

必须先声明数组变量才能使用数组，有两种声明数组的风格的代码

dataType[] arrayRefVar;
Integer[] intlist;//建议使用
/*-----------------*/
dataType arrayRefVar[];
Integer intlist[];

创建数组

Java使用new操作符来创建数组，语法如下

arrayRefVar = new dataType[arraySize];

上面的语句做了两件事情

使用dataType[arraySize]创建了一个数组
把新建的数组引用赋值给了arrayRefVar

也可以简化语法

dataType [] arrayRefVar = new dataType[arraySize];
dataType [] arrayRefVar = {value1,value2......};

下面是一个实例

public class Array {
    public void printarray(){
        double[] mylist = new double[10];
        for(double i=0;i<10;i++){
            mylist[(int)i] = i/10;
        }
        for(int i=0;i<10;i++){
            System.out.println("This is the value: "+mylist[i]);
        }
    }
}

处理数组

数组的元素类型和大小都是确定的，所以处理数组元素的时候，通常使用循环
可以使用普通循环对数组进行处理

For-Each循环

JDK1.5引入了For-each循环，被称为加强型循环
声明语句如下

for(声明语句:表达式)
{
    //一些代码
}


public class StrongFor {
    public void testfor(){
        int [] number = {10,20,30,40,50,60,70,80,90,100};
        for(int x:number){
            System.out.println("Now value is "+x);
        }
        String [] names = {"James","Larry","Tom","Lucy"};
        for(String key:names){
            System.out.println("Noe the name is "+ key);
        }
    }
}

数组作为函数的参数

数组作为函数的参数，传入的时候只需要传入数组的名字即可

public class HelloWorld {
    public static void main(String[] args){
       Character[] arr = {'A','B','1','5','7'};
       printArr(arr);//这里直接传入数组的名字就好
    }
    public static void printArr(Character[] char_name){
        for(Character item:char_name){
            System.out.printf("The char is %c\n",item);
        }
    }
}

数组作为函数的返回值

数组也可以作为函数的返回值，返回的时候只需返回数组的名字就行

//ArrFunc.java
public class ArrFunc {
    public int[] ret(){
        int[] newarray = {1,0,2,3,5,8,9};
        return newarray;
    }
    public void printArr(Character[] char_name){
        for(Character item:char_name){
            System.out.printf("The char is %c\n",item);
        }
    }
}
//HelloWorld.java
public class HelloWorld {
    //main函数，程序入口
    public static void main(String[] args){
        ArrFunc newfunc = new ArrFunc();
        int[] resarray = newfunc.ret();
        for(int item:resarray){
            System.out.println("Now is "+item);
        }
    }
}

多维数组

多维数组可以看成是特殊的一维数组

int[][] mylist = new int[5][6];

多维数组的初始化

直接为每一维分配空间

int[][] mylist = new int[5][6];
从最高维开始，分别为每一维分配空间

String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String(“Good”);
s[0][1] = new String(“Luck”);
s[1][0] = new String(“to”);
s[1][1] = new String(“you”);
s[1][2] = new String(“!”);

Arrays类

同样也是一个打包和封装的过程，和Character类类似
Arrays具有以下的功能：

给数组赋值：通过fill方法
给数组排序：sort方法
比较数组：通过equals方法
查找元素：binarySearch，二分法查找

Java日期和时间

java.util包提供了Date类来封装当前的日期和时间
Date提供两个构造函数来实例化Date对象

使用当前日期来初始化对象

Date( )
传入一个时间戳，从1970年1月1日起的毫秒数

Date(long millisec)

对Date对象进行实例化之后，那么就可以调用下面的这一些方法

boolean after(Date date) 在某个日期之后为true，否则false
boolean before(Date date) 在某个日期之前为true，否则为false
Object clone( )返回对象的副本
int compareTo(Date date) 和某个日期相互比较，如果相等为0，在这个日期之前返回负数，在这个日期之后返回正数
boolean equals(Object date) 相等为true，不等为false
getTime( ) 获得时间戳
hashCode( ) 返回对象的哈希值
setTime(long Time) 设置时间戳
9）String toString( ) 转变为 String： dow mon dd hh:mm:ss zzz yyyy

获取当前的日期时间

很简单，直接打印就行

import java.util.Date;
public class HelloWorld {
    //main函数，程序入口
    public static void main(String[] args){
        Date date = new Date();
        System.out.println(date.toString());
    }
}

日期比较

Java使用三种方法来比较两个日期：

getTime()获取时间戳然后进行比较大小
before()、after()、equals()来进行比较
使用compareTo()来进行比较

SimpleDateFormat格式化日期

SimpleDateFormat是以一个语言环境敏感的方式来格式化日期的类，允许你选择任何用户自己定义日期格式来运行

import java.util.Date;
import java.text.*;
public class HelloWorld {
    //main函数，程序入口
    public static void main(String[] args){
        Date now = new Date();
        SimpleDateFormat ft = new SimpleDateFormat("yyyy--MM--dd  hh:mm:ss");//自定义时间显示格式
        System.out.println(ft.format(now));//使用format关键字来输出时间
    }
}

printf格式化日期

除此之外，还可以使用printf等方法进行格式化日期格式

import java.util.Date;
import java.text.*;
public class HelloWorld {
    //main函数，程序入口
    public static void main(String[] args){
        Date date = new Date();

        //c的使用
        System.out.printf("全部日期和时间信息：%tc%n",date);
        //f的使用
        System.out.printf("年-月-日格式：%tF%n",date);
        //d的使用
        System.out.printf("月/日/年格式：%tD%n",date);
        //r的使用
        System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);
        //t的使用
        System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);
        //R的使用
        System.out.printf("HH:MM格式（24时制）：%tR",date);
    }
}

全部日期和时间信息：周五 1月 13 13:52:52 CST 2023
年-月-日格式：2023-01-13
月/日/年格式：01/13/23
HH:MM:SS PM格式（12时制）：01:52:52 下午
HH:MM:SS格式（24时制）：13:52:52
HH:MM格式（24时制）：13:52
进程已结束,退出代码0

Java休眠(sleep)

sleep( )使当前的进程进入停滞状态，暂停程序运行
休眠的单位是毫秒

Thread.sleep(1000*3);

Calender类

类似于Date类的一个拓展库，比Date类要强大很多

创建一个当前日期的Calender类

Calender c = Calender.getInstance();//默认是当前日期

创建一个指定日期的Calender对象

Calender c1 = Calender.getInstance();
c1.set(2009,6-1,12);

引用日期的方法

https://www.runoob.com/java/java-date-time.html

正则表达式

包java.util.regex

Java方法

分析System.out.println( )

println() 是一个方法
System 是系统类
out 是标准输出对象
那么以上的意思是，调用系统类System中的标准输出对象out中的方法println()

方法

方法是一些语句的集合，用于在一起共同执行一个功能
是解决问题的有序步骤，包含在类或者对象中
方法需要被调用

方法的优点

利于维护
简短清晰
提高效率
可以提高重用性

命名规则

小写字母开头，后面使用大写，峰驼命名规则
可以使用下划线

定义一个方法

public static int max(int num1, int num2){
    //一些语句
    return result;
}

修饰符：修饰符，这是可选的，告诉编译器如何调试该方法，定义了该方法的访问类型
放回值类型：方法可能会返回值，在定义的时候要定义返回值类型
方法名字：方法的实际名称
参数类型：参数像是一个占位符，当方法被调用时，传递值给参数
方法体：方法体包含具体的语句，定义该方法的功能

下面的实例是用于返回两个数的最大值

public static int main(int num1, int num2){
int result;
if(num1>num2){
result = num1;
}else{
result = num2;
}
return result;
}

调用一个方法

Java支持两种调用方法的方式

带有返回值的调用
不带返回值的调用

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

当方法调用返回值的时候，方法通常被当成一个值
当方法返回void的时候，方法调用一定是一条语句

public class HelloWorld {
    //main函数，程序入口
    public static void main(String[] args){
       Character stack = rank(70);
       System.out.println(stack);
    }
    public static Character rank(Integer score){
        if(score>=50){
            return 'A';
        }else{
            return 'B';
        }
    }
}

方法的重载

Java重载的方法

不同的参数个数
不同的参数类型
其他的方式不可重载

变量的作用域

变量的范围是程序中该变量可以被引用的部分
方法内定义的变量称为局部变量
局部变量的作用范围从声明开始，知道包含它的块结束
局部变量必须进行声明才能够使用
在这里插入图片描述

命令行参数的使用

Java的命令行参数是通过main()函数来进行传递的

public class CommandLine {
   public static void main(String[] args){ 
      for(int i=0; i<args.length; i++){
         System.out.println("args[" + i + "]: " + args[i]);
      }
   }
}

构造函数

同C++中的构造函数
默认构造方法的访问修饰符和类的访问修饰符相同，一旦定义了自己的构造方法，默认的构造方法就会失效。

class MyClass{
    int x;
    MyClass(){
        x = 10;
    }
}

可变参数

从JDK1.5开始，Java支持传递同类型的可变参数给一个方法

public class Changeablevar {
    public void printMax(double...numbers){
        if(numbers.length == 0){
            System.out.println("No args passed!");
            return;
        }else{
            double result = numbers[0];
            for(int i =1;i<numbers.length;i++){
                if(numbers[i]>result){
                    result = numbers[i];
                }
            }
            System.out.println("The max value is: " +result);
        }
    }
}

finalize()方法

即析构函数，析构函数不可以传入任何参数

//Changeablevar.java
public class Changeablevar {
    public void printMax(double...numbers){
        if(numbers.length == 0){
            System.out.println("No args passed!");
            return;
        }else{
            double result = numbers[0];
            for(int i =1;i<numbers.length;i++){
                if(numbers[i]>result){
                    result = numbers[i];
                }
            }
            System.out.println("The max value is: " +result);
        }
    }
    protected void finalize(){
        System.out.println("析构函数被触发!");
    }
}
//HelloWorld.java
public class HelloWorld {
    //main函数，程序入口
    public static void main(String[] args){
       Changeablevar var = new Changeablevar();
       var.printMax(1,2,3,4,1,5,6);
       var = null;
       System.gc();
    }
    public void finalize(){
        System.out.println("主函数中的析构函数被调用!");
    }
}

Java流stream、文件file、IO

Java.io这个包几乎包含了所有的操作输入、输出所需要的类，这些流类代表了输入源和输出目标
Java.io包中的流支持很多种格式，比如基本类型、对象、本地化字符集等

读取控制台字符串

Java的控制台输入由System.in完成
为了获得绑定到控制台的字符流，可以把System.in封装在一个BufferedReader对象中来创建一个字符串流
当成功创建了字符流之后，我们就可以使用read()方法来从控制台读取一个字符，或者使用readLine()从控制台读取一个字符串

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Inpur {
    public void haha() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入一个字符串：");
        String abc = br.readLine();
        System.out.println("你好! "+abc);
    }
}

请输入一个字符串：
dddeeettt
你好! dddeeettt

读取多个字符输入

public void jaja() throws IOException{
        BufferedReader ar = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("请输入字符，直到按q退出程序：");
        Character bbc;
        do{
            bbc = (char)ar.read();
            System.out.println(bbc);
        }while(bbc!='q');
    }

控制台输出

PrintStream类继承了OutputStream类，并且实现了方法write()，这样子使用write()也可以向控制台写入一些信息
但是，使用write方法远远没有printf和println好用，不能写字符串。

public static void main(String[] args) throws IOException {
      Character b = 'A';
      System.out.write(b);
      System.out.write('\n');
    }

读写文件

读写文件使用两个流FileInputStream、FileOutputStream

FileInputStream

该流用于从文件中读取数据，他的对象可以用关键字new来进行创建
有多种构造方法可以用来创建对象

使用输入流对象来读取文件

InputStream file = new FileInputStream(“D:/test/a.txt”);
使用文件对象来创建一个输入流对象来读取文件，首先用File()方法来创建一个文件对象

File f = new File(“D:/test/a.txt”);
InputFile in = new FileInputStream(f);

当我们创建了InputStream对象，就可以用下面的这些方法对流进行读取或者进行其他的操作

public void close() throws IOException{}
关闭文件输入流，并释放系统资源
protected void finaize() throws IOException{}
清除与文件的连接
public void read(int r) throws IOExpection{}
从InputStream对象读取指定字节的数据，返回为整数值,返回下一字节数据，如果到了末尾则返回-1
public void read(byte[] r) throws IOExpection{}
从输入流读取r.length长度的字节，返回读取的字节数，如果结尾则返回-1
public int available() throws IOException{}
返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值

FileOutputStream

同样可以有两种方法来创建输出对象
1）使用输入流对象

OutputStream file = new FileOutputStream("D:/test/a.txt");

使用文件对象来创建一个输出流对象来写文件

File f = new File(“D:/test/a.txt”);
OutputStream fOut = new FileOutputStream(f);

创建了OutputStream对象完成后，可以使用下面的方法来写入流或者进行其他的操作
前两个方法和输入流一致

public void write(int w) throws IOExpection{}
把指定的字节流写入输出流
public void write(byte[] w)
把指定的数组中w.length长度的字节写到OutputStream中

public static void main(String[] args) throws IOException {
try{
byte[] bWrite = {11,21,31,41,51};
OutputStream os = new FileOutputStream(“D:/test/a.txt”);
for(int x = 0; x < bWrite.length;x++){
os.write(bWrite[x]);
}
os.close();
InputStream in = new FileInputStream(“D:/test/a.txt”);
int size = in.available();
for(int i=0;i<size;i++){
System.out.print((char)in.read()+" ");
}
in.close();
}catch (IOException e){
System.out.print(“Expection”);
}
}

以上的操作存在着乱码问题，需要指定编码来进行解决，如下面所示

public static void main(String[] args) throws IOException {

        File f = new File("D:/test/a.txt");
        OutputStream fop = new FileOutputStream(f);
        // 构建OutputStream对象,文件不存在会自动新建

        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();
        // 关闭输入流,释放系统资源

    }

Java中的目录

创建目录

File类中有两个方法可以用来创建文件夹

mkdir( )方法创建文件夹，成功则返回true，失败则返回false，失败表明File对象指定的路径已经存在或者整个路径还不存在
mkdirs( )方法创建一个文件夹和所有的父文件夹

public static void main(String[] args) throws IOException {
String dirname = “/tmp/user/java/bin”;
File d = new File(dirname);
d.mkdirs();
}

Java 在 UNIX 和 Windows 自动按约定分辨文件路径分隔符。如果你在 Windows 版本的 Java 中使用分隔符 (/) ，路径依然能够被正确解析。

读取目录

一个目录其实就是一个File对象，包含着其他的文件和文件夹
如果创建一个File对象并且这个是一个目录，那么调用isDirectory( )方法会返回true
可以通过调用对象上的list( )方法来提取它包含的文件、文件夹的列表

public static void main(String[] args) throws IOException {
        String name = "E:/";
        File file = new File(name);
        if(file.isDirectory()){
            System.out.println("Dir: "+name);
            String s[] = file.list();
            for(int i = 0;i < s.length;i++){
                File f = new File(name+"/"+s[i]);
                if(f.isDirectory()){
                    System.out.println(s[i]+"是一个目录");
                }else{
                    System.out.println(s[i]+"是一个文件");
                }
            }
        }else{
            System.out.println(name + " not a dir!");
        }
    }

删除目录或者删除文件

删除文件可以使用java.io.File.delete( )方法

File folder = new File("/tmp/java/"); 
deleteFolder(folder);

Java Scanner类

是Java5的新特性，可以通过Scanner类来获取用户输入

Scanner s = new Scanner(System.in);

next方法

使用next方法和nextLine( )方法来获取输入的字符串，之前应该使用hasNext和hasNextLine来判断是否还有输入的数据

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

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

}

next方法接收：
afaw faw
输入的数据为：afaw

nextLine方法

上述方法中faw这个输入没有被接收，因为该方法以空格作为划分，如果需要全部读入需要使用nextLine方法

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

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

next方法接收：
abcde fghijk lmnopq
输入的数据为：abcde fghijk lmnopq

next方法和nextLine方法的区别

next方法

一定要读取到有效字符后才能结束输入
对输入有效字符之前遇到的空白，next方法会自动去掉
只有输入有效字符后才将后面的输入的空白作为分隔符或者结束符
next方法得不到带空格的字符串

nextLine方法

以Enter作为结束，取得范围是输入回车之前的所有字符
可以获得空白

在使用这两种方法之前最好使用hasNextXXX方法进行验证。

nextInt、hasNextInt、nextFloat、hasNextFloat方法
顾名思义，该方法作用是对输入的数据转化为整数和浮点数

public static void main(String[] args) throws IOException {
Scanner scan = new Scanner(System.in);
//从键盘接收数据
System.out.println(“输入整数：”);
if(scan.hasNextInt()){
int i = scan.nextInt();
System.out.println(“整数的值为：”+i);
}else{
System.out.println(“输入的数据不是整数！”);
}
System.out.println(“输入小数：”);
if(scan.hasNextFloat()){
float j = scan.nextFloat();
System.out.println(“小数的数值为：”+j);
}else{
System.out.println(“输入的数据不是小数！”);
}
scan.close();
}

输入整数：
12
整数的值为：12
输入小数：
3.21
小数的数值为：3.21

多组输入

输入多个数字并且求其总和，除非输入非数字才结束输入

public static void main(String[] args) throws IOException {
        System.out.println("请输入数字：");
        Scanner scan = new Scanner(System.in);

        double sum = 0;
        int m = 0;

        while(scan.hasNextDouble()){
            double x = scan.nextDouble();
            m += 1;
            sum += x;
        }
        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + (sum/m));
        scan.close();
    }