注释

首先要说的就是注释,在机考中一定要写注释,不然会扣分。
CTRL + /单行注释//...
CTRL + SHIFT + /多行注释/*...*/
ALT + SHIFT + J添加Javadoc注释

输入输出

输入

JDK 1.5.0新增的Scanner类为输入提供了良好的基础。
一般用法为:

import 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 速度会快一些
  • 读一个整数: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()

输出

  • 一般可以直接用:

    • System.out.print():不换行
    • System.out.println():换行(line new)

    例如:

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

  • 对于输出浮点数保留几位小数的问题,可以使用DecimalFormat

    import java.text.*;
    // 这里 0 指一位数字,# 指除 0 以外的数字(用来省略末尾的0)
    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));

大数字

BigIntegerBigDecimal 是在java.math包中已有的

  • BigInteger表示整数
  • BigDecimal表示浮点数(使用前得先设置 DecimalFormat 类,为大数字设置保留几位小数)

例如:

(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) 即可。

数组

声明数组

方法一:

int a[] = null; //声明一维数组
//int[] a = null; 也行,个人习惯
a = new int[10];//分配内存给一维数组

方法二:

int[] a = new int[10];  //声明数组的同时分配内存

遍历数组

例如:

//一维数组
String[] str = new String[3];
str[0]="张三";
str[1]="李四";
str[2]="王五";

for循环

数组元素下标的合法区间:[0, length-1]。
我们可以用for循环通过下标来遍历数组中的元素,遍历时可以读取元素的值或者修改元素的值。

例如:

// for形式遍历数组
for(int i=0;i<str.length;i++) {
System.out.println("一维数组:for:"+str[i]);
}

for-each

增强for循环for-each是JDK1.5新增加的功能,专门用于读取数组或集合中所有的元素,即 对数组进行遍历。
格式:对象遍历集合数组

for(类 对象: 集合数组) {
//操作
}

例如:

// 增强for-each形式,用变量s遍历所有数组
for(String s:str) {
System.out.println("一维数组增强:for:"+s);
}

数组排序

通常情况下我们可以使用Array.sort()来对数组进行排序。

例如,我们要对数组排序:

int[] ints={1,4,7,2,5,8,3,6,9};

全体升序

Array.sort(int[] a)直接对数组进行升序排序
例如:

System.out.println("升序排序:");
Arrays.sort(score);
System.out.println(Arrays.toString(score)); //这里我偷了个懒。。把他变成字符串输出了

程序运行结果:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

部分升序

Array.sort(int[] a , int fromIndex, int toIndex)对数组的从fromIndex到toIndex([from, to))进行升序排序。(前闭后开

例如:

System.out.println("\n部分升序排序:");
int[] ints2 = {1,4,7,2,5,8,3,6,9}; //对数组的[2,6)位进行排序
Arrays.sort(ints2, 2, 6); //输出
for (int i=0;i<ints2.length;i++)
{
System.out.print(ints2[i]+" ");
}

程序运行结果:

部分升序排序:
9 8 4 5 6 7 3 2 1

降序

因为sort()方法默认为升序排序,所以要实现降序排序的话,要新建一个比较器Comparator,从而实现自定义比较。

Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法
int compare(Object o1, Object o2)返回一个基本类型的整型

  • 如果要按照升序排序,则

    • o1小于o2,返回-1负数
    • 相等,返回0
    • o1大于o2,返回1正数
  • 如果要按照降序排序,则
    • o1小于o2,返回1(正数)
    • 相等,返回0
    • o1大于o2,返回-1(负数)

看到这里,可能有人就懵了,凭什么升序是这样安排的,降序是那样安排的呢??

例如:

System.out.println("\n降序排序:");
//要实现降序排序,得通过包装类型数组,基本类型数组是不行的
Integer[] integers = {1,4,7,2,5,8,3,6,9};
Arrays.sort(integers, new Comparator<Integer>()
{
public int compare(Integer o1, Integer o2)
{
// if(o1 < o2) {
// return 1;
// }else if(o1 > o2) {
// return -1;
// }else {
// return 0;
// } return o2-o1; //与“小于取正,等于取0,大于取负”相同效果
}
}); //输出
for (Integer integer:integers)
{
System.out.print(integer+" ");
}

程序运行结果:

降序排序:
9 8 7 6 5 4 3 2 1

字符串

String类用来存储字符串。
例如:

String a = "Hello"; 

字符串连接

可以直接用+号,如

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

字符串查找

String提供了两种查找字符串的方法,即 indexOf()lastIndexOf() 方法。

  • indexOf(String s)用于返回参数字符串 s 在指定字符串中首次出现的索引位置
    当调用字符串的indexOf()方法时,会从当前字符串的开始位置搜索 s 的位置。

    • 如果没有检索到字符串 s,该方法返回-1
    String str ="We are students";
    int size = str.indexOf("a"); // 变量 size 的值是 3
  • lastIndexOf(String str)用于返回字符串最后一次出现的索引位置。
    当调用字符串的lastIndexOf()方法时,会从当前字符串的开始位置检索参数字符串 str,并将最后一次出现 str 的索引位置返回。

    • 如果没有检索到字符串 str,该方法返回-1
    • 如果lastIndexOf()方法中的参数是空字符串"",则返回的结果与 length 方法的返回结果相同。

获取指定索引位置的字符

使用charAt()方法可将指定索引处的字符返回。

String str = "Hello world";
char mychar = str.charAt(5); // mychar 的结果是 w

获取子字符串

通过String类substring()方法可对字符串进行截取。

  • substring(int beginIndex)从begin开始,到结尾结束

    String str = "Hello world";
    String substr = str.substring(3); //获取字符串,此时 substr 值为 lo world
  • substring(int beginIndex, int endIndex)begin和end区间是前闭后开的,[begin, end)

    • beginIndex:开始截取子字符串的索引位置
    • endIndex:子字符串在整个字符串中的结束位置
    String str = "Hello world";
    String substr = str.substring(0,3); //substr 的值为 Hel

去除空格

trim()方法返回字符串的副本,清除了左右两端的空格

String str = "        hello           ";
System.out.println(str.trim());
//程序运行结果:hello

字符串替换

replace(String oldChar,String newChar)方法可实现将指定的字符或字符串替换成新的字符或字符串。

  • oldChar:要替换的字符或字符串
  • newChar:用于替换原来字符串的内容
String str= "address";
String newstr = str.replace("a", "A");// newstr 的值为 Address

判断字符串是否相等(切不可使用==)

  • equals(String otherstr)
    如果两个字符串具有相同的字符和长度,则使用equals()方法比较时,返回 true。

  • equalsIgnoreCase(String otherstr)

equals()与==的区别:

  • ==:

    • 如果作用于基本数据类型的变量(如 byte,short,char,int,long,float,double,boolean),则直接比较其存储的“值”是否相等
    • 如果作用于引用类型的变量(如 String类),则比较的是所指向的对象的地址(即 是否指向同一个对象)。
  • equals()方法:是基类Object中的方法,因此对于所有的继承于Object的类都会有该方法。在Object类中,equals()方法是用来比较两个对象的引用是否相等,即 是否指向同一个对象。

是不是感觉equals()在Object类中跟==好像是一样的描述啊??没错,就是一样的,不是我写错了!

Java中Object类是所有类的父类,它里面定义了equals()方法:

public boolean equals(Object obj) {
return (this == obj);
}

若object1.equals(object2)为true,则表示equals1和equals2实际上是引用同一个对象。

按字典顺序比较两个字符串

compareTo()方法为按字典顺序比较两个字符串,该比较基于字符串中各个字符的 Unicode 值,按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。

  • 如果按字典顺序此 String 对象位于参数字符串之前,则比较结果为一个负整数
  • 如果按字典顺序此 String 对象位于参数字符串之后,则比较结果为一个正整数
  • 如果这两个字符串相等,则结果为0.

字母大小写转换

  • 字符串的toLowerCase()方法可将字符串中的所有字符从大写字母改写为小写字母,
  • toLowerCaseUpperCase()方法可将字符串中的小写字母改写为大写字母。
str.toLowerCase();
str.toUpperCase();

字符串分割

使用split()方法可以使字符串按指定的分隔字符或字符串对内容进行分割,并将分割后的结果作为字符串数组返回。

str.split(String regex);:regex为分割字符串的分割符,也可以使用正则表达式。

String str = "hello world";
String[] s = str.split(" ");
for(int i=0; i<s.length; i++) {
System.out.println(s[i]);
}

程序运行结果:

hello
world

字符串变数字

用对应类的parse方法即可,如

String t = "123";
Integer.parseInt(t);

switch case 语句

当我们遇到多个if语句的时候,可以尝试用switch来简化整个代码。

语法格式:

switch(expression){
case value:
// 语句
break; // 可选
case value:
// 语句
break; // 可选
case value:
case value:
// 语句(前两个判断的公共语句)
break;
//你可以有任意数量的case语句
default: // 默认(可选)
// 语句
}

语句规则:

  • 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 语句

  • switch 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': // 如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。
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);
}
}

程序运行结果:

良好
你的等级是 C

调用递归(或其他动态方法)

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

其他注意的事项

  • Java 是面向对象的语言,思考方法需要变换一下,里面的函数统称为方法,不要搞错。
  • Java 里的数组有些变动,多维数组的内部其实都是指针,所以 Java 不支持 fill 多维数组

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

  • 下面在 java.util 包里 Arrays类的几个方法可替代 C/C++里的 memset、qsort/sort

    int[] a = {9,8,7,6,5,4,3,2,1};
    Arrays.sort(a) //java 自带的优化后的快速排序
    Arrays.fill(a, 3); //用3填充数组,结果为3,3,3,3,3,3,3,3,3
05-19 14:20
查看更多