Java 基础数据结构与语法
Java
1. 输入：
格式1：Scanner sc = new Scanner (new BufferedInputStream(System.in));
格式2：Scanner sc = new Scanner (System.in);
在读入数据量大的情况下，格式1的速度会快些。
读一个整数： int n = sc.nextInt(); 相当于 scanf("%d", &n); 或 cin >> n;
读一个字符串：String s = sc.next(); 相当于 scanf("%s", s); 或 cin >> s;
读一个浮点数：double t = sc.nextDouble(); 相当于 scanf("%lf", &t); 或 cin >> t;
读一整行： String s = sc.nextLine(); 相当于 gets(s); 或 cin.getline(...);
判断是否有下一个输入可以用sc.hasNext()或sc.hasNextInt()或sc.hasNextDouble()或sc.hasNextLine()
conclusion：Java的输入输出，只要套上（BufferedXxx开头的）速度就会变得更快（更高效）
常用nextLine()吸收回车
nextInt()函数在缓冲区中遇到“空格”、“回车符”等空白字符时会将空白字符前的数据读取走，但空白字符不会被处理掉
nextLine()函数是在缓冲区中读取一行数据，这行数据以“回车符”为结束标志，nextLine()会把包括回车符在内的数据提走
有时在使用nextInt()后使用nextLine()遇到“看上去提取不到数据”的情况。
nextInt()后的nextLine()函数并非读取不到数据，因为nextInt()将“回车符”留在了缓冲区，nextLine()读取时遇到的第一个字符便是“回车符”，所以直接结束了。
nextLine（）方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。
next（）会自动消去有效字符前的空格，只返回输入的字符，不能得到带空格的字符串。
（简单点说，next我只要字，nextLine我啥都要）
2. 输出：
函数：
System.out.print();
System.out.println();
System.out.format();
System.out.printf();
3. 规格化的输出：
函数：
java.text.Format->java.text.NumberFormat->java.text.DecimalFormat
DecimalFormat是NumberFormat的一个具体子类，用来格式化十进制数字
// 这里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));
4. 字符串处理 String
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类。
5. 高精度
BigInteger和BigDecimal可以说是acmer选择java的首要原因。 函数：add, subtract, divide, mod, compareTo等，其中加减乘除模都要求是BigInteger(BigDecimal)和BigInteger(BigDecimal)之间的运算，所以需要把int(double)类型转换为BigInteger(BigDecimal)，用函数BigInteger.valueOf().
大整数BigInteger【大整数操作类】【构造方法只能是字符串】
import java.math.BigInteger;
//主要有以下方法可以使用：
BigInteger add(BigInteger other) //加
BigInteger subtract(BigInteger other) //减
BigInteger multiply(BigInteger other) //乘
BigInteger divide(BigInteger other) //除
BigInteger [] dividedandRemainder(BigInteger other) //数组第一位是商，第二位是余数 //商和余数
BigInteger pow(int other)// other次方
BigInteger mod(BigInteger other)
BigInteger gcd(BigInteger other)
int compareTo(BigInteger other) //负数则小于,0则等于,正数则大于
static BigInteger valueOf(long x)
//输出数字时直接使用 System.out.println(a) 即可
高精度BigDecimal【大小数操作类】【构造方法可以是double int string BigInteger】
BigDecimal add(BigDecimal other)
BigDecimal subtract(BigDecimal other)
BigDecimal multiply(BigDecimal other)
BigDecimal divide(BigDecimal other)
BigDecimal divide(BigDecimal divisor, int scale, BigDecimal.ROUND_HALF_UP)//除数，保留小数位数，保留方法四舍五入
BigDecimal.setScale()方法用于格式化小数点 //setScale(1)表示保留一位小数，默认用四舍五入方式
//求sqrt(x)，保留前n位数字（不是小数点后n位），n位后直接舍弃（非四舍五入）
private static BigDecimal sqrt(BigDecimal x, int n) {
BigDecimal ans = BigDecimal.ZERO;
BigDecimal eps = BigDecimal.ONE;
for (int i = 0; i < n; ++i) {
while (ans.pow(2).compareTo(x) < 0) {
ans = ans.add(eps);
}
ans = ans.subtract(eps);
eps = eps.divide(BigDecimal.TEN);
}
return ans;
}
6. 进制转换
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的进制.
7. Arrays类
数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本操作
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用
常用功能：
对数组排序：Arrays.sort() 默认升序
给数组赋值：Arrays.fill()
比较数组： Arrays.equals()
数组扩容：Arrays.copyOf()
查找两个数组第一个不匹配项：Arrays.mismatch()
查找数组元素：Arrays.binarySearch() 限定范围的是 [ ) 不限定范围的是整个数组 【二分查找 搜索 返回下标】
8.数据类型转换
int x=123；
String sx=String.valueOf(x); //相比toString()【toString()必须实现了toString才能用】可以接受Object对象
String sy="321";
int y=Integer.parseInt(sy); //Integer.parseInt(String s)将会返回int常量
//Integer.valueOf(String s)将会返回Integer类型，如果存在缓存将会返回缓存中已有的对象
key：比较两个整型是否相等用“==” 比较两个对象用的是Objects.equals()
String str="abc";
char[] s=str.toCharArray();
String ss=String.valueOf(s);
9.String常用操作
public char charAt(int index): 返回字符串中第index个字符
public int length(): 返回字符串的长度
public int indexOf(String str): 返回字符串中第一次出现str的位置
public int indexOf(String str;int fromIndex): 返回字符串从fromIndex开始第一次出现str的位置
public String substring(int beginIndex): 返回该字符串从beginIndex开始到结尾的子字符串
public String substring(int beginIndex,int endIndex): 返回该字符串从beginIndex开始到endIndex结尾的子字符串
public int compareTo(String str) :比较字符串的大小，小于则返回负数，大于返回正数，相等返回0
public boolean equals(String str): 判断字符串是否一样
public String toLowerCase(): 返回将当前字符串中所有字符转换成小写后的新串
public String toUpperCase(): 返回将当前字符串中所有字符转换成大写后的新串
public char[] toCharArray(): 将此字符串转换为新的字符数组
public String[] split(String regex): 将一个字符串按照指定的分隔符分割，返回分隔后的字符串数组
key：split()方法根据匹配给定的正则表达式来拆分字符串。
attention：正则表达式需要转义
多个分隔符，可以用 | 作为连字符
public String replace (CharSequence target,CharSequence replacement): 将于target匹配的字符串
使用replacement 字符串替换
public String replaceAll(String regex,String replacement): 使用给定的replacement 替换此字符串所有匹配
给定的正则表达式的子字符串
conclusion：String类型不可改变，如果需要改变可以使用StringBuilder
10.StringBuilder常用操作
创建StringBuilder对象： StringBuilder strb=new StringBuilder();
append():添加任意数据类型数据的字符串形式，并返回当前对象自身 字符串拼接 【增】
toString(): 返回一个于构建器或缓冲器内容相同的字符串 【for()+charAt()/toString() 遍历】
charAt(int n)：查找指定位置的元素 【查】
setCharAt(int i,char c): 将第i个代码单元设置为c（可以理解为替换）【改】
replace(int start.int end,String str)：把[start,end)位置替换为str 【改】
insert(int offset,String str) / insert(int offset,char c): 在指定位置之前插入字符(串) 【插】
delete(int startIndex,int endIndex): 删除起始位置(含)到结尾位置(不含)之间的字符串 【删】
length():获取长度
reverse()：把当前字符序列逆转
substring(int start,int end)：返回[start,end)区间的子字符串
indexOf(string str)：返回给定字符串首次出现时此字符串的索引
11.Java使用class实现结构体及其排序
Comparator (类似于c++ cmp函数的写法) (外部比较器)
Comparable (类似于c++ 重载小于号) (内部比较器)
|
Comparable |
comparator |
解释 |
|
源代码： public interface Comparable<T> { public int compareTo(T o); }
|
源代码： public interface Comparator<T> { int compare(T o1, T o2); boolean equals(Object obj); } |
1.实现方法不同，传入的参数相同，参数个数不同。但是，返回值是一样的。
|
|
实现形式： Public class Person implements comparable<Person>{ … @Override public int compareTo(T o) { return this.x-o.x; } }
|
实现方式： public class Person{ ….} public class MyComparator implements Comparator<Person> { @Override public int compare(T o1, T o2) { return o1.getx() - o2.getx(); }
} |
2.实现方式不同，前者是在本类中实现，后者是类外部实现，保障了本类代码不篡改的前提下。 |
|
测试代码： Arrays.sort(Object[] a); Collections.sort(List<T> list);
|
测试代码： Arrays.sort(T[] a, Comparator<? super T> c) Collections.sort(List<T> list, Comparator<? super T> c) |
3.测试代码方式不同，前者是一个参数直接传入数组或者集合对象， 后者是两个参数，先传入待比较数组或者集合对象，再传入比较器 |
* Comparator中的equals方法可以不实现，也可以实现。Java中，规定，接口中的方法都要实现，equals方法因为是Object类中的，是每个类都与生俱来的方法。
*两种方法各有优劣， 用Comparable 简单， 只要实现Comparable接口的对象直接就成为一个可以比较的对象，但是需要
修改源代码。用Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了， 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。
Math.random() ：[0,1)所有的小数，等概率返回一个
Math.random() * N ：[0,N)所有的小数，等概率返回一个
(int)(Math.random() * N) ：[0,N-1]所有的整数，等概率返回一个
在JDK中，整形类型是有范围的，最大值为Integer.MAX_VALUE，即2147483647，最小值为Integer.MIN_VALUE -2147483648。
对整形最大值加1，2147483648（越界了），那么此时值为多少呢？结果是-2147483648，即是Integer.MIN_VALUE。
类似的，对Integer.MIN_VALUE取反或者取绝对值呢？仍为Integer.MIN_VALUE，因为值为-2147483648，绝对值2147483648超过Integer.MAX_VALUE 2147483647。
所以就有以下结果
Integer.MAX_VALUE + 1 = Integer.MIN_VALUE
Math.abs(Integer.MIN_VALUE) = Integer.MIN_VALUE （绝对值）
Long，short，byte的结论是相同的
System.exit(int status): 参数用作状态代码；按照惯例，非零状态表示异常终止。
四舍五入保留小数：
四舍五入：保留整数 int a = b+0.5;
保留一位小数 int a=(b+0.05)*10;
double c=a/10.0;
保留二位小数 int a=(b+0.005)*100;
double c=a/100.0;
（上面的方法仅适用于正数。）
如果需要对负数进行转换，可以为这个负数加上一个足够大的正整数，使得和变成正数，然后四色五入后再减去前面加上的正整数就好
如： 对 -3.4进行四舍五入
double a = -3.4+5 = 1.6
int b = (1.6+0.5) = 2
int answer = 2 -5 = -3
这儿有个坑， 如 -3.5， 四舍五入应该是-3 而不是-4
强制保留两位小数：include<iomanip>
cout<<setiosflags(ios::fixed)<<setprecision(2)<<a<<endl;
浙公网安备 33010602011771号