四舍五入
Math.round(x)
返回int型
原理是在原数上加0.5后进行下取整,因此对负数进行计算可能会有误差
(下取整 Math.floor)
函数只能取到int型,需要保留小数时可以先倍乘后再除去
public static void main(String[] args) {
double x = -11.5;
System.out.println(Math.round(x));
double y = 5.123;
System.out.println(Math.round(y));
System.out.println((double)Math.round(y*10)/10);
System.out.println((double)Math.round(y*100)/100);
}
-11
5
5.1
5.12
ArrayList
List<Integer> l = new ArrayList<>();
动态数组(与Vector功能类似)
一定程度上也可以当做链表来用
public static void main(String[] args) {
List<Integer> l = new ArrayList<>();
l.add(1);//添加元素至尾
l.add(2);
l.add(3);
l.add(4);
l.add(1,5);//添加元素至指定位置,后方元素后移
System.out.println(l);
System.out.println(l.size());//返回大小
System.out.println(l.get(1));//获得指定index元素
Collections.sort(l);//引入collection类进行排序
System.out.println(l);
for(int i:l) {//遍历
System.out.print(i+" ");
}
System.out.println();
l.remove(1);//移除指定index元素
System.out.println(l);
}
[1, 5, 2, 3, 4]
5
5
[1, 2, 3, 4, 5]
1 2 3 4 5
[1, 3, 4, 5]
格式转换
二进制与int
public static void main(String[] args) {
int n = 12;
String s = Integer.toBinaryString(n);//int转二进制字符串
//或使用Integer.toString(n,2);
System.out.println(s);
int a = Integer.parseInt(s,2);//二进制字符串转int
System.out.println(a);
}
1100
12
String与int
public static void main(String[] args) {
int n = 12;
String s = String.valueOf(n);//int转String
String ss = "123";
int m = Integer.parseInt(ss);//String转int
}
哈希表
映射关系
Map<String, Integer> map = new HashMap<>();//构造
map.put(key, value);//插入元素
map.get(key);//获得key的value
map.remove(key);//删除key-value对
map.isEmpty();//判空
map.size();//返回大小
map.containsKey(key);//判断是或否存在key
map.containsValue(value);//判断是否存在value
map.keySet();//返回key值的set集合
map.values();//返回value值的collection集合,可以通过构造函数转为list
针对key值排序时,可以先通过keySet–toArray–Arrays.sort获得新的key数组,再通过get(key)来得到value
Map<Integer, Integer> map =new HashMap<>();
Object[] keys = map.keySet().toArray();
Arrays.sort(keys);
for(Object i:keys) {
map.get(i);
}
针对value排序时,通过map.entrySet()获得enteyset,再建立<Map,Entry<k,v>>类型的list,通过的构造函数转为list,使用list.sort()排序
Map<Integer, Integer> map = new HashMap<>();
//获取entryset转list
List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(map.entrySet());
list.sort(new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
//通过getValue获得value值进行排序
return o2.getValue().compareTo(o1.getValue());
}
});
for(Map.Entry<Integer, Integer> i:list) {
System.out.println(i);
}
类的排序
自定义class继承Comparable接口,根据排序需求重写compareTo方法,使用Arrays.sort()进行排序
public class Test {
static Scanner tab = new Scanner(System.in);
static class Person implements Comparable<Person>{
String name ;
int age;
int score;
public Person(String name, int age, int score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
@Override
public int compareTo(Person o) {
//name字典升序
//return this.name.compareTo(o.name);
//age升序,age相同时score升序
if(this.age == o.age)
return Integer.compare(this.score, o.score);
return Integer.compare(this.age, o.age);
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", score=" + score + "]";
}
}
public static void main(String[] args) {
Person[] p = new Person[10];
p[0] = new Person("Tom",20,98);
p[1] = new Person("John",19,99);
p[2] = new Person("Bob",18,97);
p[3] = new Person("Ailly",19,100);
p[4] = new Person("Corbon",19,98);
Arrays.sort(p,0,5);
for(Person i:p) {
if(i!=null) {
System.out.println(i);
}
}
}
}
sort降序
创建一个类继承Comparator,重写compare方法,在Arrays.sort()中传参
如果常规对int数组进行排序使用sort可以直接使用,但加入comparator参数后必须要使用int数组必须改为Integer
public class Test {
static Scanner tab = new Scanner(System.in);
static class MyCompare implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
// TODO Auto-generated method stub
if (o1 > o2)
return -1;
else if (o1 == o2)
return 0;
else
return 1;
//return o1 > o2 ? -1 :(o1==o2 ? 0 :1);
}
}
public static void main(String[] args) {
Integer a[] = { 2, 3, 5, 4, 1 };//不能直接使用int
MyCompare mc = new MyCompare();
Arrays.sort(a, mc);
for(int i:a) {
System.out.print(i+" ");
}
}
}
5 4 3 2 1
交集并集
Set<Integer> s1 = new HashSet<Integer>();
Set<Integer> s2 = new HashSet<Integer>();
s1.add(1);
s1.add(2);
s1.add(3);
s2.add(1);
s2.add(2);
s2.add(4);
s1.retainAll(s2);//交集
System.out.println(s1);
s1.addAll(s2);//并集
System.out.println(s1);
Floyd 最短路
还是先记个最好混的 ==
public static void main(String[] args) {
int n = 10;
int inf = Integer.MAX_VALUE;
int map[][] = new int[n][n];
// 初始化
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j)
map[i][j] = 0;
else
map[i][j] = inf;
}
}
//读入map...
// Floyd
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (map[i][j] > map[i][k] + map[k][j])
map[i][j] = map[i][k] + map[k][j];
}
}
}
}