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 DateDemo1818-11-11 Parses as Wed Nov 11 00:00:00 GMT 1818$ java DateDemo 2007-12-012007-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() 方法，它的语法如下：vint read( ) throws IOException

每次调用 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 来创建。

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

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

InputStream f = new FileInputStream("C:/java/hello");

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

File f = new File("C:/java/hello");

InputStream out = new FileInputStream(f);

 

FileOutputStream

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

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

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

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

OutputStream f = new FileOutputStream("C:/java/hello")；

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

File f = new File("C:/java/hello");

OutputStream f = new FileOutputStream(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 对象的基本语法：Scanner s = new Scanner(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 ScannerDemo next方式接收： 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 ScannerDemo nextLine方式接收： 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