JAVA与ACM

这两天学了一下JAVA的语法，还没有学习后面的核心地方，突然间觉得JAVA这门语言很棒，我要在接下来的时间系统的学习一下。就这么愉快地决定了。

Java对于大数计算这方面的优势很大。最重要的是代码量小了（时间复杂度我有点拿不准）。于是针对这两天对Java的摸索，写一篇日志。记录一下针对ACM来说常用的Java方面的东西。

1、输入

首先要想输入需要先包括：

import java.util.Scanner;

我们需要其中的 Scanner类声明的对象来扫描控制台输入。

针对A+B来说：（如果看不懂，请自行翻书，都讲得很清楚）

import java.util.Scanner;
public class Main //必须写成Main,否则CE
{
    public static void main(String [] args)
    {
        Scanner cin = new Scanner(System.in);//对于Scanner 类声明对象cin用来扫描控制台输入
        int a = cin.nextInt();
        int b = cin.nextInt();
        System.out.println(a+b);//输出a+b
        cin.close();
    }
}

 读一个整数：  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(...); 

读一个大数：  BigInteger c = cin.nextBigInteger();

如果你想指教输入一个字符的话，可以这样：
Scanner in = new Scanner(System.in);
String str = in.nextLine();
char ch = str.charAt(0);
System.out.println(ch);

不过需要注意的是它们没有像scanf一样有判断是否输入到结尾的功能。

这时候需要用一个Scanner类的方法hasnext()来判断是否输入到文件结尾;

import java.math.*;//大数类在Java.math里面，如果不包括的话声明不了大数对象
import java.util.Scanner;

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

        BigInteger [] a=new BigInteger[255]; //大数数组,动态开数组
        a[0]=BigInteger.ONE; //初始化，这里我现在还没看懂，我会写成a[0]=BigInteger.valueOf(1);把1强制转换成大数类
        a[1]=BigInteger.ONE;
        a[2]=a[1].add(a[0].add(a[0]));
        for(int i=3;i<=250;i++)
        {
            a[i]=a[i-1].add(a[i-2].add(a[i-2]));
        }
        Scanner cin = new Scanner(System.in); //输入打开
        
        while(cin.hasNext())//判断是否文件结束
        {
            int n=cin.nextInt();
            System.out.println(a[n]); //输出
        }
        cin .close();//输入关闭
    }
} 

2、输出：

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

        // TODO Auto-generated method stub
        
        double d;
        
        d=9999.99999;
        
        System.out.format("%f",d);                //9999.999990     没有回车
        
        System.out.format("%10.10f",d).println(); //9999.9999900000 输出回车
        
        System.out.format("%.4f",d).println();    //10000.0000      输出回车
        
        System.out.format("%3.4f",d).println();   //10000.0000        输出回车
        
        System.out.println(d);                    //输出当前变量      输出回车
        
        System.out.println();                     //                输出回车
        
        System.out.printf("%f",d);                     //9999.999990     没有回车
        
        System.out.print(d);                      //9999.99999      没有回车
        
    }
}

当然，输出的时候也有对小数位数处理的方法：

0代表当前位向后都是0就输出0占位，#代表若当前位向后都是0就不输出这些位上的数字。

import java.text.DecimalFormat;
public class Main {
    public static void main(String[] args)  {
        double num = 9.999;
        DecimalFormat p3 = new DecimalFormat("#.00#");
        DecimalFormat p4 = new DecimalFormat("#.000#");
        DecimalFormat p5 = new DecimalFormat("#.0000#");
        System.out.println(p3.format(num));//输出9.999
        System.out.println(p4.format(num));//输出9.999
        System.out.println(p5.format(num));//输出9.9990
    }
}

3、高精度

对于大数来说，Java提供了BigDecimal和BigInteger两个类，都包含在java.math.*里面。

BigInteger是大整形类，BigDecimal是大浮点型类。

这两个类产生的对象没有数据范围，只要你的电脑内存足够就可以。

下面用BigInteger举个例子：

import java.math.BigInteger;

public class Main {
    
    public static void main(String[] args)
    
    {
        
        int a=6,b=3;
        
        BigInteger x,y,z;
        
        x=BigInteger.valueOf(a);            //转化赋值
        
        y=BigInteger.valueOf(b);
        
        System.out.println(x.add(y));      //加
        
        System.out.println(x.subtract(y)); //减
        
        System.out.println(x.multiply(y)); //乘
        
        System.out.println(x.divide(y));   //除
        
        System.out.println(x.mod(y));      //取余
    }
}

4、进制转换

java一直就是作弊器一般的存在，就像它的进制转换函数一样：

public class Main {
    
    public static void main(String[] args)
    
    {
        String string;
        int a=8;
        int x=2;
        string = Integer.toString(a, x);    //把int型数据转换乘X进制数并转换成string型
        System.out.println(string);
        
        int b = Integer.parseInt(string, x);//把字符串当作X进制数转换成int型
        System.out.println(b);
    }
}

5、字符串

Java中的String   和char数组是完全不同的两种东西。

String中的字符是不能在原位置改变的，要改变必须改变并保存到新的String里，或者保存到char 数组里再修改

import java.io.*;
import java.util.*;
public class Main
{
    public static void main(String[] args) 
    {
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        String st = "abcdefg";
        System.out.println(st.charAt(0)); // st.charAt(i)就相当于st[i].
        char [] ch;
        ch = st.toCharArray(); // 字符串转换为字符数组.
        for (int i = 0; i < ch.length; i++){
            ch[i] += 1;//字符数组可以像C++   一样操作
        }
        System.out.println(ch); // 输入为“bcdefgh”.
        st = st.substring(1); // 则从第1位开始copy(开头为第0位).
        System.out.println(st);
        st=st.substring(2, 4);  //从第2位copy到第4位（不包括第4位）
        System.out.println(st);//输出“de”
    }
}

 JAVA输入输出优化

用Scanner输入就像cin那样比较慢，当数据量一大会超时的，此时不得不用StreamTokenizer   和  PrintWriter

import java.io.*;

public class Main {
        public static void main(String[] args) throws IOException
                // in.nextTokenizer可能抛出这个异常
        {
                StreamTokenizer in = new StreamTokenizer(new BufferedReader(
                                        new InputStreamReader(System.in)));
                // 这句是io流包装来包装去，记住就好；
                PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
                int a, b;
                while (in.nextToken() != StreamTokenizer.TT_EOF)
                        // 用in.nextToken()读下一个标记，StreamTokenizer.TT_EOF这个是个参数，就是EOF
                {
                        a = (int) in.nval;
                        // 读进来的是double型的，所以要转成int
                        in.nextToken();
                        // 读入b值（a的值是在while循环中读入的）
                        b = (int) in.nval;
                        out.println(a + b);
                }
                out.flush();
                // 刷新缓冲区，必须的，不然a+b会留在缓冲区
        }
}

JAVA里一些常用的函数；

Arrays.sort(a);//排序，a是数组名，即地址

Arrays.binarySearch(a,x);//二分查找

System.out.println(a.add(b).stripTrailingZeros().toPlainString());  //去掉末尾的0 并转换成无科学计数法的字符串输出              

//stripTrailingZeros()这个方法是用来去掉末尾的0的。

//toPlainString()这个方法是使字符串大数变成普通的数字字符组成的字符串，
//如果不使用这个方法很可能数字变成了科学计数法，带E的那种。

BigInteger.valueOf(1);//把1强制转换成大数类

cin.hasNextBigInteger();//输入大数!=EOF

s.equals("/");//判断字符串是否相等，与C++十分不同

.toPlainString.repalceAll(^0, "")去掉科学计数法和最前面的0.