java 运算符输入_java-运算符，IO输入输出，文件操作

Java 运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

算术运算符

关系运算符

位运算符

逻辑运算符

赋值运算符

其他运算符

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

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(",");

}

}

}

Java switch case 语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

switch case 语句有如下规则：

switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。

switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。

case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。

当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。

当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。

switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支(可以在任何位置，但建议在最后一个)。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case 的值都会输出。如果后续的 case 语句块有 break 语句则会跳出判断。

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 StringBuffer 和 StringBuilder 类

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

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

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

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

Java 数组

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。

本教程将为大家介绍 Java 数组的声明、创建和初始化，并给出其对应的代码。

For-Each 循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

语法格式如下：

public class TestArray {

public static void main(String[] args) {

double[] myList = {1.9, 2.9, 3.4, 3.5};

// 打印所有数组元素

for (double element: myList) {

System.out.println(element);

}

}

}

多维数组的动态初始化(以二维数组为例)

二维数组 a 可以看成一个两行三列的数组。

2. 从最高维开始，分别为每一维分配空间，例如：

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("!");

解析：

s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。

解析字符串为时间

SimpleDateFormat 类有一些附加的方法，特别是parse()，它试图按照给定的SimpleDateFormat 对象的格式化存储来解析字符串。例如：

import java.util.*;

import java.text.*;

public class DateDemo {

public static void main(String args[]) {

SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");

String input = args.length == 0 ? "1818-11-11" : args[0];

System.out.print(input + " Parses as ");

Date t;

try {

t = ft.parse(input);

System.out.println(t);

} catch (ParseException e) {

System.out.println("Unparseable using " + ft);

}

}

}

结果:

$ java DateDemo

1818-11-11 Parses as Wed Nov 11 00:00:00 GMT 1818

$ java DateDemo 2007-12-01

2007-12-01 Parses as Sat Dec 01 00:00:00 GMT 2007

Calendar类

我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。

Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

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

使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

//创建一个代表2009年6月12日的Calendar对象

Calendar c1 = Calendar.getInstance();

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

方法的重载

上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点类型数据的最大值呢？

解决方法是创建另一个有相同名字但参数不同的方法，如下面代码所示：

public static double max(double num1, double num2) {

if (num1 > num2)

return num1;

else

return num2;

}

如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；

如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；

就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

Java编译器根据方法签名判断哪个方法应该被调用。

方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。

重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。

构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。

通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。

不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，默认构造方法的访问修改符和类的访问修改符相同(类为 public，构造函数也为 public；类改为 private，构造函数也改为 private)。

一旦你定义了自己的构造方法，默认构造方法就会失效。

可变参数

JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。

方法的可变参数的声明如下所示

在方法声明中，在指定参数类型后加一个省略号(...) 。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class VarargsDemo {

public static void main(String args[]) {

// 调用可变参数的方法

printMax(34, 3, 3, 2, 56.5);

printMax(new double[]{1, 2, 3});

}

public static void printMax( double... numbers) {

if (numbers.length == 0) {

System.out.println("No argument passed");

return;

}

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() 方法

Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。

例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。

在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。

public class FinalizationDemo {

public static void main(String[] args) {

Cake c1 = new Cake(1);

Cake c2 = new Cake(2);

Cake c3 = new Cake(3);

c2 = c3 = null;

System.gc(); //调用Java垃圾收集器

}

}

class Cake extends Object {

private int id;

public Cake(int id) {

this.id = id;

System.out.println("Cake Object " + id + "is created");

}

protected void finalize() throws java.lang.Throwable {

super.finalize();

System.out.println("Cake Object " + id + "is disposed");

}

}

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() 方法，它的语法如下：vintread()throwsIOException

每次调用 read() 方法，它从输入流读取一个字符并把该字符作为整数值返回。 当流结束的时候返回 -1。该方法抛出 IOException。

下面的程序示范了用 read() 方法从控制台不断读取字符直到用户输入 "q"。

//使用 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');

}

}

Java 流(Stream)、文件(File)和IO

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

但本节讲述最基本的和流与 I/O 相关的功能。我们将通过一个个例子来学习这些功能。

读取控制台输入

Java 的控制台输入由 System.in 完成。

为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。

从 BufferedReader 对象读取一个字符要使用 read() 方法，

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');

}

}

从控制台读取字符串

从标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法。

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"));

}

}

FileInputStream

该流用于从文件读取数据，它的对象可以用关键字 new 来创建。

有多种构造方法可用来创建对象。

可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

InputStreamf= newFileInputStream("C:/java/hello");

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

Filef= newFile("C:/java/hello");

InputStreamout= newFileInputStream(f);

FileOutputStream

该类用来创建一个文件并向文件中写数据。

如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。

有两个构造方法可以用来创建 FileOutputStream 对象。

使用字符串类型的文件名来创建一个输出流对象：

OutputStreamf= newFileOutputStream("C:/java/hello")；

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

Filef= newFile("C:/java/hello");

OutputStreamf= newFileOutputStream(f);

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，并把给定的数字以二进制形式写进该文件，同时输出到控制台上。

以上代码由于是二进制写入，可能存在乱码，你可以使用以下代码实例来解决乱码问题：

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();

// 关闭输入流,释放系统资源

}

}

Java中的目录

创建目录：

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

mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。

mkdirs()方法创建一个文件夹和它的所有父文件夹。

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() 方法来检查一个文件夹中包含的内容：

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 + " 不是一个目录");

}

}

}

删除目录或文件

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

以下代码会删除目录 /tmp/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();

}

}

Java Scanner 类

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

下面是创建 Scanner 对象的基本语法：Scanners= newScanner(System.in);

接下来我们演示一个最简单的数据输入，并通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据：

其中：hasNext()方法包含判断和输入两个操作步骤

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);

}

scan.close();

}

}

结果：

$ javac ScannerDemo.java

$ java ScannerDemonext方式接收：runoob com

输入的数据为：runoob

使用 nextLine 方法：

import java.util.Scanner;

public class ScannerDemo {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

// 从键盘接收数据

// nextLine方式接收字符串

System.out.println("nextLine方式接收：");

// 判断是否还有输入

if (scan.hasNextLine()) {

String str2 = scan.nextLine();

System.out.println("输入的数据为：" + str2);

}

scan.close();

}

}

结果：

$ javac ScannerDemo.java

$ java ScannerDemonextLine方式接收：runoob com

输入的数据为：runoob com

next() 与 nextLine() 区别

next():

1、一定要读取到有效字符后才可以结束输入。

2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。

3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

next() 不能得到带有空格的字符串。

nextLine()：

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

2、可以获得空白。

如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取：

import java.util.Scanner;

public class ScannerDemo {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

// 从键盘接收数据

int i = 0;

float f = 0.0f;

System.out.print("输入整数：");

if (scan.hasNextInt()) {

// 判断输入的是否是整数

i = scan.nextInt();

// 接收整数

System.out.println("整数数据：" + i);

} else {

// 输入错误的信息

System.out.println("输入的不是整数！");

}

System.out.print("输入小数：");

if (scan.hasNextFloat()) {

// 判断输入的是否是小数

f = scan.nextFloat();

// 接收小数

System.out.println("小数数据：" + f);

} else {

// 输入错误的信息

System.out.println("输入的不是小数！");

}

scan.close();

}

}

结果：

$ javac ScannerDemo.java

$ java ScannerDemo输入整数：12整数数据：12输入小数：1.2小数数据：1.2