java简单上手

对于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%jrelib;
CLASSPATH = .;%java_home%lib;%java_home%libtools.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 : 布尔值,仅有两个值,truefalse.
byte :字节类型值,长度8位(一个字节),范围-128127short:短整型值,长度16位(两个字节),范围-3276832767int:整型值,长度32位(四个字节),范围-21474836482147483647
long:长整型,长度64位(八个字节),范围-92233720368547758089223372036854775807
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()
                        将输入信息的下一个标记扫描为一个 BigDecimalBigInteger   	nextBigInteger()
                        将输入信息的下一个标记扫描为一个 BigIntegerboolean      	nextBoolean()
                        扫描解释为一个布尔值的输入标记并返回该值。
byte          	nextByte()
                        将输入信息的下一个标记扫描为一个 bytedouble        	nextDouble()
                        将输入信息的下一个标记扫描为一个 doublefloat          	nextFloat()
                        将输入信息的下一个标记扫描为一个 floatint             	nextInt()
                        将输入信息的下一个标记扫描为一个 intString         	nextLine()
                        此扫描器执行当前行,并返回跳过的输入信息。
long           	nextLong()
                        将输入信息的下一个标记扫描为一个 longshort          	nextShort()
                        将输入信息的下一个标记扫描为一个 short

输出:

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

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

接下来以HDOJ 1002为例,简单介绍一下如何用java秒杀"简单"大数题(题目自己去看,代码如下):

import java.io.*;
import java.util.*;
import java.math.*;
 
public class Main{
    public static void main(String[] argc)
      {
	Scanner cin=new Scanner(System.in);
	BigInteger a,b,c;
	int t,id=1;
	t=cin.nextInt();
	while(t--!=0)//java不会进行默认强转,所以0和非0不会编程false和true
	  {
	    a=cin.nextBigInteger();
	    b=cin.nextBigInteger();
	    c=a.add(b);
	    System.out.println("Case "+id+":");
	    System.out.println(a+" + "+b+" = "+c);//"+"号运算符如果对字符串处理会把非字符创转化成字符串
	    if(t!=0) System.out.println();//输出空喊
	    id++;
	  }
      }
}

为了方便起见,一下贴出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 的常量 0BigInteger.ONE              BigInteger 的常量 1BigInteger.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的API远不止这些,以上列举出来的都是用的比较多的几个.最后附上HDU上几道"简单"大数题的代码,供参考

//1753
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(new BufferedInputStream(System.in));
      BigDecimal a,b,c;
      while(cin.hasNextBigDecimal())
	{
	  a=cin.nextBigDecimal();
	  b=cin.nextBigDecimal();
	  c=b.add(a);
	  String s=c.toString();
	  int i,j;
	  boolean flag=false;
	  for(i=0;i<s.length();i++)
	    if(s.charAt(i)=='.') flag=true;
	  if(flag)
	    {
	      for(j=s.length();j>=0;j--)
		if(s.charAt(j-1)!='0') break;
	      if(s.charAt(j-1)=='.') j--;
	      s=s.substring(0,j);
	    }
	  System.out.println(s);
	}
    }
}
 
 
//1042
import java.io.*;
import java.math.*;
import java.util.*;
 
public class Main
{
  public static void main(String[] argv)
    {
      BigInteger n,i,ans;
      Scanner cin=new Scanner(System.in);
      while(cin.hasNextBigInteger())
	{
	  n=cin.nextBigInteger();
	  ans=BigInteger.ONE;
	  for(i=BigInteger.ONE;i.compareTo(n)<=0;i=i.add(BigInteger.ONE))
	    ans=ans.multiply(i);
	  System.out.println(ans);
	}
    }
}
 
 
//1063
import java.io.*;
import java.math.*;
import java.util.*;
 
public class Main{
    public static void main(String[] argv){
	Scanner cin=new Scanner(System.in);
	BigDecimal R;
	String s;
	int n;
	while(cin.hasNextBigDecimal()){
	    R=cin.nextBigDecimal();
	    n=cin.nextInt();
	    R=R.pow(n);
	    s=R.stripTrailingZeros().toPlainString();
	    if(s.charAt(0)=='0') s=s.substring(1);
	    System.out.println(s);
	}
    }
}
 
 
//1715
import java.io.*;
import java.math.*;
import java.util.*;
 
public class Main{
    public static void main(String[] argc){
	Scanner cin=new Scanner(System.in);
	int i,j,k,n;
	BigInteger fib[]=new BigInteger[1001];
	fib[0]=BigInteger.ZERO;
	fib[1]=BigInteger.ONE;
	for(i=2;i<=1000;i++)
	  fib[i]=fib[i-1].add(fib[i-2]);
	n=cin.nextInt();
	while((n--)!=0)
	  {
	    i=cin.nextInt();
	    System.out.println(fib[i]);
	  }
    }
}
 
 
//1316
import java.io.*;
import java.math.*;
import java.util.*;
 
public class Main{
    public static void main(String[] argc){
	Scanner cin=new Scanner(System.in);
	int i,count;
	BigInteger a,b;
	BigInteger fib[]=new BigInteger[601];
	fib[1]=BigInteger.valueOf(1);
	fib[2]=BigInteger.valueOf(2);
	for(i=3;i<=600;i++)
	  fib[i]=fib[i-1].add(fib[i-2]);
	while(true){
	    a=cin.nextBigInteger();
	    b=cin.nextBigInteger();
	    if(a.add(b).compareTo(BigInteger.ZERO)==0) break;
	    count=0;
	    i=1;
	    while(fib[i].compareTo(a)<0) i++;
	    while(fib[i].compareTo(b)<=0){
		i++;
		count++;
	    }
	    System.out.println(count);
	}
    }
}
 
 
//1040
import java.io.*;
import java.math.*;
import java.util.*;
 
public class Main{
    public static void main(String[] argv){
	Scanner cin=new Scanner(System.in);
	int times,n,i,j,k;
	int D[]=new int[1005];
	times=cin.nextInt();
	while(times--!=0)
	  {
	    n=cin.nextInt();
	    for(i=0;i<n;i++)
	      D[i]=cin.nextInt();
	    Arrays.sort(D,0,n);
	    for(i=0;i<n;i++){
		System.out.printf("%d",D[i]);
		if(i!=(n-1))
		  System.out.printf(" ");
		else
		  System.out.printf("n");
	    }
	    System.out.printf("n");
	  }
    }
}
 
//1865
import java.io.*;
import java.math.*;
import java.util.*;
 
public class Main{
    public static void main(String[] argv){
	Scanner cin=new Scanner(System.in);
	String s;
	BigInteger D[]=new BigInteger[205];
	D[1]=BigInteger.valueOf(1);
	D[2]=BigInteger.valueOf(2);
	int i,k;
	for(i=3;i<=200;i++){
	    D[i]=D[i-1].add(D[i-2]);
	}
	int n=cin.nextInt();
	while(n--!=0){
	    s=cin.next();
	    i=s.length();
	    System.out.println(D[i]);
	}
    }
}
 
 
 
//1250
import java.io.*;
import java.math.*;
import java.util.*;
 
public class Main{
    public static void main(String[] argv){
	Scanner cin=new Scanner(System.in);
	BigInteger fib[]=new BigInteger[10000];
	fib[1]=fib[2]=fib[3]=fib[4]=BigInteger.ONE;
	int i;
	for(i=5;i<10000;i++){
	    fib[i]=fib[i-1].add(fib[i-2]).add(fib[i-3]).add(fib[i-4]);
	}
	while(cin.hasNextInt())
	  {
	    i=cin.nextInt();
	    System.out.println(fib[i]);
	  }
    }
}
 
//1390
import java.io.*;
import java.util.*;
import java.math.*;
 
public class Main{
    public static void main(String[] argc)
      {
	Scanner cin=new Scanner(System.in);
	int t,n,i,j,k;
	t=cin.nextInt();
	while(t--!=0)
	  {
	    n=cin.nextInt();
	    String s=Integer.toString(n,2);
	    int len=s.length();
	    Boolean flag=true;
	    for(i=len-1,k=0;i>=0;i--,k++)
	      {
		if(s.charAt(i)=='1')
		  {
		    if(flag)
		      {
			System.out.print(k);
			flag=false;
		      }
		    else
		      {
			System.out.print(" "+k);
		      }
		  }
	      }
	    System.out.println();
	  }
      }
}

五.附录


http://www.jingningedu.com/manage/java_api/index-files/index-1.html

» 本博客采用署名 2.5 中国大陆许可协议进行许可,本文版权归作者所有,欢迎转载,但必须在明显位置给出原文连接。
anyShare分享到:
发表评论?

0 条评论。

发表评论

注意 - 你可以用以下 HTML tags and attributes:
<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>