蓝桥杯--常用函数杂记

四舍五入

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];
				}
			}
		}
	}