[转] Java之ACM速成

转载自：http://blog.csdn.net/skiffloveblue/article/details/7032290

　　相关题目：POJ 1131 1205 1220 1405 1503 1604 1894 2084 2305 2325 2389 2413 3101 3199

　　对于ACMer来说,java语言最大的优势就是BigInteger,Bigecimal,String三个类.这三个类分别是高精度整数,高精度浮点数和字符串,之所以说这个是它的优势是因为java的这三个类有丰富的成员函数可以调用,在比赛中可以省去敲大数模板的时间.
　　这里只讲一些在短时间内上手java的基础知识,java是一门非常强大的语言,要深入学习是需要花很长时间的.

一.准备工作

安装JDK (java development kit即JAVA开发工具包)
这里首先需要说明一下java的一些特殊性.一般我们的教材上介绍程序设计语言时会把它们按照运行方式的不同分为解释型和编译型(概念略),虽然java也有一个虚拟机来”解释执行”,但java并不是完全的解释型也不是编译型,可以认为是”部分”编译.一个java程序经过”编译”变成字节码再运行在虚拟机上,所以它比一般的编译型程序慢,比一般的解释型程序快.
如果你在至诚ACM的机房看这篇文章,以上的一大段都是废话了解一下就行,请跳到下面的”第一个Java程序”开始看.
这里我们使用的是JDK6,可以到SUN的网站下载:http://www.oracle.com/technetwork/java/javase/downloads/index.html
下载完成后，安装按默认路径即可。
配置环境变量如下：

JAVA_HOME = C:\Program Fils\Java\jdk1.6.0_20 (版本不同路径会略有不同)
PATH = %JAVA_HOME%\bin;%JAVA_HOME%\lib;%JAVA_HOME%\jre\lib;
CLASSPATH = .;%java_home%\lib;%java_home%\lib\tools.jar (前面要加.表示当前路径).

其实到这里Java的开发环境就已经完成了,但是对于不熟悉命令行编译的朋友最好能安装一个IDE(Integrated Development,集成开发环境).
现在比较流行的Java集成开发环境有IBM的Eclipse和Sun的Netbeans.至于安装配置什么的对于软件专业的学生应该不是什么难事,实在不行Google一下.
Eclipse:http://www.eclipse.org/downloads/
Netbeans:http://zh-cn.netbeans.org/
其实我个人还是推荐使用Netbeans,java和Netbeans都是Sun的东西,Sun对自家的东西自然会支持的好一些.
知道Eclipse这个单词是什么意思么?查一下,很有趣的.

二.第一个java程序

用任何你喜欢的编辑器(比如我最长用的是Vim)写如下代码:

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

并保存为Main.java
(注意大小写,Java是大小写敏感的语言,你的类名和这个文件名必须相同)
在命令行下输入

javac Main.java  //编译
java Main        //运行

这是很经典的例子,几乎所有的语言入门都会从这个例子开始.
在我学过的所有编程语言里PHP和java是两个极端,使用PHP你几乎不需要什么PHP知识就可以开始写,非常的自由松散.而java刚好相反,即使是一个Hello World程序也会涉及到像面向对象的概念.

解释一下上面的代码:
java是完全面向对象,所以一个程序就是一个类,而对于大多OJ都会要求建立一个Main类以及Main类的一个main函数,除开第4行代码其他的对于ACMer来说都是固定的,一大堆前缀无非是设置一些访问权限,暂时不必去理会,每个题目都这样写就是了.

三.常用数据类型及输入输出

数据类型
java语言在许多方面与C++非常类似,虽然是完全面向对象语言,但是为了使用方便它依然保留了C/C++中的基本数据类型(当然对于这些基本数据类型也有面向对象的实现)

boolean : 布尔值，仅有两个值，true和false.
byte :字节类型值，长度8位（一个字节），范围-128至127。
short：短整型值，长度16位（两个字节），范围-32768至32767。
int：整型值，长度32位（四个字节），范围-2147483648至2147483647
long：长整型，长度64位（八个字节），范围-9223372036854775808至9223372036854775807
float：单精度浮点数，长度32位（四个字节）。
double：双精度浮点数，长度64位（八个字节）。
char：字符型，长度16位，支持所有的UCS-2和ASCII编码。

除了以上的8种基本数据类型,对于ACMer还有BigInteger,BigDecimal,String三个类经常使用.

输入
java是完全面向对象语言,所以对于输入会有专门的一个Scanner类的对象来负责输入.
先声明一个Scanner对象,代码如下:

Scanner cin = new Scanner(System.in);
   类名  对象名      构造函数    参数

关于Scanner类更详细的使用,可以到按附录中的网址去查询Java的API

Scanner类提供了非常丰富的成员函数来负责读取各种数据类型:

返回值              成员函数
String          next(String pattern)
                        如果下一个标记与从指定字符串构造的模式匹配，则返回下一个标记,
                        如果参数为空,就是读取一个字符串
BigDecimal      nextBigDecimal()
                        将输入信息的下一个标记扫描为一个 BigDecimal。
BigInteger      nextBigInteger()
                        将输入信息的下一个标记扫描为一个 BigInteger。
boolean         nextBoolean()
                        扫描解释为一个布尔值的输入标记并返回该值。
byte            nextByte()
                        将输入信息的下一个标记扫描为一个 byte。
double          nextDouble()
                        将输入信息的下一个标记扫描为一个 double。
float           nextFloat()
                        将输入信息的下一个标记扫描为一个 float。
int                     nextInt()
                        将输入信息的下一个标记扫描为一个 int。
String          nextLine()
                        此扫描器执行当前行，并返回跳过的输入信息。
long            nextLong()
                        将输入信息的下一个标记扫描为一个 long。
short           nextShort()
                        将输入信息的下一个标记扫描为一个 short。

输出
在java中负责输出的函数有：

System.out.print(); // cout << …;
System.out.println(); //与C++的cout << … <<endl;
System.out.printf(); // 与C中的printf用法类似.

为了方便起见,一下贴出BigInteger,BigDecimal和String类最常用的成员函数:

Bignteger

返回值                   成员函数
BigInteger              add(BigInteger val)
                        返回其值为 (this + val) 的 BigInteger。

BigInteger              subtract(BigInteger val)
                        返回其值为 (this - val) 的 BigInteger。

BigInteger              multiply(BigInteger val)
                        返回其值为 (this * val) 的 BigInteger。

BigInteger              divide(BigInteger val)
                        返回其值为 (this / val) 的 BigInteger。

BigInteger              mod(BigInteger m)
                        返回其值为 (this mod m) 的 BigInteger。

int                     compareTo(BigInteger val)
                        将此 BigInteger 与指定的 BigInteger 进行比较。
                        如果和val相等返回0,小于返回-1,大于返回1

BigInteger              pow(int exponent)
                        返回其值为 (this exponent) 的 BigInteger。

String                  toString()
                        返回此 BigInteger 的十进制字符串表示形式。

String                  toString(int radix)
                        返回此 BigInteger 的给定基数的字符串表示形式。

static BigInteger       valueOf(long val)
                        返回其值等于指定 long 的值的 BigInteger。

BigInteger              gcd(BigInteger val)
                        返回一个 BigInteger，其值是 abs(this) 和 abs(val) 的最大公约数。

BigInteger              abs()
                        返回其值是此 BigInteger 的绝对值的 BigInteger。

int                     hashCode()
                        返回此 BigInteger 的哈希码。

boolean                 isProbablePrime(int certainty)
                        如果此 BigInteger 可能为素数，则返回 true，如果它一定为合数，则返回 false。

BigInteger              nextProbablePrime()
                        返回大于此 BigInteger 的可能为素数的第一个整数。

int                     signum()
                        返回此 BigInteger 的正负号函数。

除了以上成员函数,BigInteger还有几个非常常用的属性

BigInteger.ZERO             BigInteger 的常量 0。
BigInteger.ONE              BigInteger 的常量 1。
BigInteger.TEN              BigInteger 的常量 10。

BigDecimal

返回值                   成员函数
BigDecimal              add(BigDecimal augend)
                        返回一个 BigDecimal，其值为 (this + augend)。

BigDecimal              subtract(BigDecimal subtrahend)
                        返回一个 BigDecimal，其值为 (this - subtrahend)。

BigDecimal              multiply(BigDecimal multiplicand)
                        返回一个 BigDecimal，其值为 (this × multiplicand).

BigDecimal              divide(BigDecimal divisor)
                        返回一个 BigDecimal，其值为 (this / divisor).

BigDecimal              pow(int n)
                        返回其值为 (thisn) 的 BigDecimal，准确计算该幂，使其具有无限精度。

int                     compareTo(BigDecimal val)
                        将此 BigDecimal 与指定的 BigDecimal 比较。

static BigDecimal       valueOf(double val)
                        使用 Double.toString(double) 方法提供的 double 规范的字符串
                        表示形式将 double 转换为 BigDecimal。

BigDecimal              stripTrailingZeros()
                        返回数值上等于此小数，但从该表示形式移除所有尾部零的 BigDecimal。

String                  toPlainString()
                        返回不带指数字段的此 BigDecimal 的字符串表示形式。

String                  toString()
                        返回此 BigDecimal 的字符串表示形式，如果需要指数，则使用科学记数法。

BigDecimal              abs()
                        返回 BigDecimal，其值为此 BigDecimal 的绝对值，其标度为 this.scale()。

int                     hashCode()
                        返回此 BigDecimal 的哈希码。

int                     signum()
                        返回此 BigDecimal 的正负号函数。

BigInteger的三个重要属性,BigDecimal同样也有,这里就不再复述了.

String

返回值                   成员函数
char                    charAt(int index)
                        返回指定索引处的 char 值。

String                  substring(int beginIndex)
                        返回一个新的字符串，它是此字符串的一个子字符串。

String                  substring(int beginIndex, int endIndex)
                        返回一个新字符串，它是此字符串的一个子字符串。

int                     length()
                        返回此字符串的长度。

String                  toLowerCase()
                        使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

String                  toUpperCase()
                        使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

int                     compareTo(String anotherString)
                        按字典顺序比较两个字符串。

String                  concat(String str)
                        将指定字符串联到此字符串的结尾。

boolean                 contains(CharSequence s)
                        当且仅当此字符串包含 char 值的指定序列时，才返回 true。

int                     hashCode()
                        返回此字符串的哈希码。

boolean                 startsWith(String prefix)
                        测试此字符串是否以指定的前缀开始。

boolean                 endsWith(String suffix)
                        测试此字符串是否以指定的后缀结束。

String                  trim()
                        返回字符串的副本，忽略前导空白和尾部空白。

这里指的java速成，只限于java语法，包括输入输出，运算处理，字符串和高精度的处理，进制之间的转换等，能解决OJ上的一些高精度题目。

1. 输入：

格式为：Scannercin = new Scanner (new BufferedInputStream(System.in));

例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main{
    public static void main(String[] args)   {
        Scanner cin = new Scanner (newBufferedInputStream(System.in));
        int a; double b; BigInteger c;String st;
        a = cin.nextInt(); b =cin.nextDouble(); c = cin.nextBigInteger(); d = cin.nextLine(); // 每种类型都有相应的输入函数.
    }
}

2. 输出
函数：System.out.print();System.out.println(); System.out.printf();

例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main{
    public static void main(String[] args)    {
        Scanner cin = new Scanner (newBufferedInputStream(System.in));
        int a; double b;
        a = 12345; b = 1.234567;
        System.out.println(a + " "+ b);
        System.out.printf("%d%10.5f\n", a, b); // 输入b为字宽为10，右对齐，保留小数点后5位，四舍五入.

    }
}

规格化的输出：
函数：// 这里0指一位数字，#指除0以外的数字(如果是0，则不显示),四舍五入.
    DecimalFormat fd = new DecimalFormat("#.00#");
    DecimalFormat gd = new DecimalFormat("0.000");
    System.out.println("x =" + fd.format(x));
    System.out.println("x =" + gd.format(x));

3. 字符串处理
java中字符串String是不可以修改的，要修改只能转换为字符数组.
例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main{

    public static void main(String[] args)   {
        int i;
        Scanner cin = new Scanner (newBufferedInputStream(System.in));
        String st = "abcdefg";
        System.out.println(st.charAt(0)); //st.charAt(i)就相当于st.
        char [] ch;
        ch = st.toCharArray(); // 字符串转换为字符数组.
        for (i = 0; i < ch.length; i++)ch += 1;
        System.out.println(ch); // 输入为“bcdefgh”.
　　　　　if (st.startsWith("a")) // 如果字符串以'0'开头.
        {
            st =st.substring(1); // 则从第1位开始copy(开头为第0位).
        }
    }
}

4. 高精度
BigInteger和BigDecimal可以说是acmer选择java的首要原因。
函数：add, subtract,divide, mod, compareTo等，其中加减乘除模都要求是BigInteger(BigDecimal)和BigInteger(BigDecimal)之间的运算，所以需要把int(double)类型转换为BigInteger(BigDecimal)，用函数BigInteger.valueOf().
例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main
{
    public static void main(String[] args)   {

        Scanner cin = new Scanner (newBufferedInputStream(System.in));
        int a = 123, b = 456, c = 7890;
        BigInteger x, y, z, ans;
        x = BigInteger.valueOf(a); y =BigInteger.valueOf(b); z = BigInteger.valueOf(c);
        ans = x.add(y);System.out.println(ans);
        ans = z.divide(y);System.out.println(ans);
        ans = x.mod(z);System.out.println(ans);
        if (ans.compareTo(x) == 0)System.out.println("1");
    }
}

5. 进制转换

java很强大的一个功能。

函数： String st = Integer.toString(num, base); // 把num当做10进制的数转成base进制的st(base <= 35).

int num = Integer.parseInt(st, base); // 把st当做base进制，转成10进制的int(parseInt有两个参数,第一个为要转的字符串,第二个为说明是什么进制).

BigInter m = new BigInteger(st, base); // st是字符串，base是st的进制.

//Added by abilitytao

1.如果要将一个大数以2进制形式读入 可以使用cin.nextBigInteger(2);

　当然也可以使用其他进制方式读入；

2.如果要将一个大数转换成其他进制形式的字符串 使用cin.toString(2);//将它转换成2进制表示的字符串

例程：POJ 2305

import java.io.*;
import java.util.*;
import java.math.*;

public class Main
{
    public static void main(String[] args)
    {
        int b;
        BigInteger p,m,ans;
        String str ;
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        while(cin.hasNext())
        {
            b=cin.nextInt();
            if(b==0)
                break;
            p=cin.nextBigInteger(b);
            m=cin.nextBigInteger(b);
            ans=p.mod(m);
            str=ans.toString(b);
            System.out.println(str);
        }
    }
}

6. 排序
函数：Arrays.sort();至于怎么排序结构体，像C++里写个cmp的方法，在java还不太清楚，希望有人指点下～～
例程：

import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main{
    public static void main(String[] args)    {

        Scanner cin = new Scanner (newBufferedInputStream(System.in));
        int n = cin.nextInt();
        int a[] = new int [n];
        for (int i = 0; i < n; i++) a =cin.nextInt();
        Arrays.sort(a);
        for (int i = 0; i < n; i++)System.out.print(a + " ");
    }

}

------------------------------------------------------------------------------------------------------------------------------------

acm中Java的应用

Chapter I.

Java的优缺点各种书上都有，这里只说说用Java做ACM-ICPC的特点：

(1) 最明显的好处是，学会Java，可以参加Java Challenge

(2) 对于熟悉C/C++的程序员来说，Java 并不难学，找本书，一两周业余时间就可以搞定了。当然，这里只是指一般编程，想熟悉所有的Java库还是需要些时间的。

　　事实上，Java 只相当于C++的一个改进版，所有的语法都几乎是C++的，很少有变动。

(3) 在一般比赛中，Java程序会有额外的时间和空间，而实际上经过实验，在执行计算密集任务的时候Java并不比C/C++慢多少，只是IO操作较慢而已。

(4) Java 简单而功能强大，有些东西用Java实现起来更为方便，比如高精度。

(5) 用Java不易犯细微的错误，比如C/C++中的指针， “if (n = m) ... ” 等。

(6) 目前来看Eclipse已成基本配置，写Java程序反而比C/C++更方便调试，在具体竞赛时也算多一种选择。

(7) 学会Java对以后工作有好处。现在国外很多地方会Java的人比会C/C++的人多。

(8) 会Java可以使你看起来更像偶蹄类动物（牛）      hoho~

Chapter II.

下面说一下ACM-ICPC队员初用Java编程所遇到的一些问题：

1. 基本输入输出：

(1) JDK 1.5.0 新增的Scanner类为输入提供了良好的基础，简直就是为ACM-ICPC而设的。

一般用法为：

mport java.io.*
import java.util.* 

public class Main
{
      public static void main(String args[])
      {
          Scanner cin = new Scanner(new BufferedInputStream(System.in));
          ...
      }
} 

当然也可以直接 Scanner cin = new Scanner(System.in); 
只是加Buffer可能会快一些

(2) 基本数据输入

读一个整数：    int n = cin.nextInt();          　  相当于  scanf("%d", &n);    或 cin >> n; 
读一个字符串：String s = cin.next();          　　相当于  scanf("%s", s);      或 cin >> s; 
读一个浮点数：double t = cin.nextDouble();     相当于  scanf("%lf", &t);    或 cin >> t; 
读一整行：      String s = cin.nextLine();         相当于  gets(s);                 或 cin.getline(...); 
判断是否有下一个输入可以用 cin.hasNext() 或 cin.hasNextInt() 或 cin.hasNextDouble() 等，具体见 TOJ 1001 例程。

(3) 输出一般可以直接用 System.out.print() 和 System.out.println()，前者不输出换行，而后者输出。

比如：System.out.println(n);    // n 为 int 型

同一行输出多个整数可以用 
      System.out.println(new Integer(n).toString() + " " + new Integer(m).toString());

也可重新定义：

static PrintWriter cout = new PrintWriter(new BufferedOutputStream(System.out)); 
cout.println(n);

(4) 对于输出浮点数保留几位小数的问题，可以使用DecimalFormat类，

import java.text.*; 
DecimalFormat f = new DecimalFormat("#.00#"); 
DecimalFormat g = new DecimalFormat("0.000"); 
double a = 123.45678, b = 0.12; 
System.out.println(f.format(a)); 
System.out.println(f.format(b)); 
System.out.println(g.format(b));

这里0指一位数字，#指除0以外的数字。

2. 大数字

BigInteger 和 BigDecimal 是在java.math包中已有的类，前者表示整数，后者表示浮点数

用法： 不能直接用符号如+、-来使用大数字，例如：

(import java.math.*)    // 需要引入 java.math 包

BigInteger a = BigInteger.valueOf(100); 
BigInteger b = BigInteger.valueOf(50); 
BigInteger c = a.add(b)    // c = a + b;

主要有以下方法可以使用： 
BigInteger add(BigInteger other) 
BigInteger subtract(BigInteger other) 
BigInteger multiply(BigInteger other) 
BigInteger divide(BigInteger other) 
BigInteger mod(BigInteger other) 
int compareTo(BigInteger other) 
static BigInteger valueOf(long x)

输出大数字时直接使用 System.out.println(a) 即可。

3. 字符串

String 类用来存储字符串，可以用charAt方法来取出其中某一字节，计数从0开始：

String a = "Hello";      // a.charAt(1) = ’e’

用substring方法可得到子串，如上例

System.out.println(a.substring(0, 4))      // output "Hell"

注意第2个参数位置上的字符不包括进来。这样做使得 s.substring(a, b) 总是有 b-a个字符。 
字符串连接可以直接用 + 号，如

String a = "Hello"; 
String b = "world"; 
System.out.println(a + ", " + b + "!");      // output "Hello, world!"

如想直接将字符串中的某字节改变，可以使用另外的StringBuffer类。

4. 调用递归（或其他动态方法）

在主类中 main 方法必须是 public static void 的，在 main 中调用非static类时会有警告信息， 可以先建立对象，然后通过对象调用方法：

public class Main
{
      ...
      void dfs(int a)
      {
          if (...) return;
          ...
          dfs(a+1);
      }
      public static void main(String args[])
      {
          ...
          Main e = new Main();
          e.dfs(0);
          ...
      }
} 

5. 其他注意的事项

(1) Java 是面向对象的语言，思考方法需要变换一下，里面的函数统称为方法，不要搞错。

(2) Java 里的数组有些变动，多维数组的内部其实都是指针，所以Java不支持fill多维数组。

　　数组定义后必须初始化，如 int[] a = new int[100];

(3) 布尔类型为 boolean，只有true和false二值，在 if (...) / while (...) 等语句的条件中必须为boolean类型。

　　在C/C++中的 if (n % 2) ... 在Java中无法编译通过。

(4) 下面在java.util包里Arrays类的几个方法可替代C/C++里的memset、qsort/sort 和 bsearch:

　　Arrays.fill()

　　Arrays.sort()

　　Arrays.binarySearch()