蓝桥杯常犯的错误以及经验总结（考前冲刺必看）

Posted 2023-04-09 一只可爱的小猴子

题目链接	总结
成绩统计	1. double res2 = (double)b * 100 / n; // int类型的数进行计算需要保留小数时，需要强转为double，否则会直接抹去零头，不会四舍五入 2.四舍五入函数round,头文件cmath
卡片	for (int i = 0; i < 10; i ++) cnt[i] = 2021; // 将数组初始化为某一个非0的数的时候，不能用memset，memset是字节填充，适用于初始化为最大值0x3f3f3f3f,或者初始化为0的情况
购物单	直接计算答案的题目，有大量输入计算，虽然可以通过计算机直接加，但是由于数据太多，容易出错，可以寻找一下数据的规律，写成程序，让计算机来算，可以检查数据输入的正确性，准确率会更高，并且这道题目可以根据将同一个折扣的价格先累加再×同一个折扣，这样减少输入，并且可以快速查询是否有漏乘和多乘的情况。
空间	256MB = 256 * 1024 * 1024 * 8 bit，注意 M是1024 * 1024，而不是10^6,不要搞混了
排序	每一趟冒泡排序从左到右，依次扫描，例如：第一趟冒泡排序dcba->cdba->cbda->cbad(第一趟冒泡排序总共交换了3次，依次比较相邻两个数，若逆序，则交换，将序列分成待排序和已有序的两部分，每一趟冒泡排序都能够将待排序部分中最大的那个数移动到有序部分，如果一个长度为n的完全逆序的序列，通过冒泡排序变得有序，需要**（n - 1 + 1) * (n - 1) / 2次交换**;因为第一个数移动到最后一个位置需要n - 1次交换，同理总共需要 n -1 + n - 2 + … + 1次交换。还有一个规律就是，如果一个串完全逆序，例如ihgfedcba,将这个串的第6位 d移动到第一位，串变为dihgfecba,将新的串通过冒泡排序变为有序的交换次数会减少5，并且在所有交换次数减少5的串中，这个新串是字典序最小的那个串。
跑步锻炼	日期题目常用模板:int M[13] = 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31; int getday(int y, int m) //获取某一年的某一个月有多少天   if (m != 2) return M[m];   return M[2] + (y % 400 等于 0 或 (y % 4 等于 0 && y % 100));
货物摆放	当填空题的 计算数值特别大，比如2021041820210418，像这样的数纯暴力肯定是计算不出来的，这道题目相当于找因子，只需要找出所有的因子组合，然后根据 排列组合的知识就可以得到答案，由于不可能每个数都是因子，所以可以 在电脑上先预处理一下数据先计算出部分答案，从1开始枚举输出它的因子，很快就可以就可以在众多因子种找到那个最接近并小于三次方根的答案，也就是120258，将1~120258中的因子存起来，第一个维度只有可能是这42个因子，再往后的就是重复数据（因为下一个因子的三次方大于2021041820210418），第二个维度从1开始枚举即可， 将答案存在vector中sort排序，然后存在set中进行去重即可得到答案

Java程序员常犯的10个错误

人非圣贤，孰能无过。都说Java语言是一门简单的编程语言，基于C++演化而来，剔除了很多C++中的复杂特性，但这并不能保证Java程序员不会犯错。那么对于广大的Java程序员来说，它们最常犯的10个错误是什么呢？本文通过总结出Java程序员最常犯的10大错误，可以有效地帮组Java后来者少走弯路，少加班，并写出更健壮的应用程序。

1. 数组转ArrayList

为了实现把一个数组转换成一个ArrayList，很多Java程序员会使用如下的代码：

List<String> list = Arrays.asList(arr);

Arrays.asList确实会返回一个 ArrayList对象，但是该类是 Arrays类 中一个私有静态内部类，而不是常见的 java.util.ArrayList类。这个 java.util.Arrays.ArrayList 类具有 set()，get()，contains()等方法，但是不具有任何添加或移除元素的任何方法。因为该类的大小(size)是固定的。为了创建出一个真正的 java.util.ArrayList,代码应该如下所示：

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

我们知道，ArrayList的构造方法可以接受一个 Collection 类型的对象，而我们的 java.util.Arrays.ArrayList 正好也是它的一个子类。实际上，更加高效的代码示例是：

ArrayList<String> arrayList = new ArrayList<String>(arr.length);

Collections.addAll(arrayList, arr);

2. 数组是否包含特定值

为了检查数组中是否包含某个特定值，很多Java程序员会使用如下的代码：

Set<String> set = new HashSet<String>(Arrays.asList(arr));

return set.contains(targetValue);

就功能而言，该代码是正确无误的，但在数组转List,List再转Set的过程中消耗了大量的性能。我们可以优化成如下形式：

Arrays.asList(arr).contains(targetValue);

或者，进一步优化成如下所示最高效的代码：

for(String s: arr){

   if(s.equals(targetValue))

       return true;

}

return false;

3. 在迭代时移除List中的元素

首先，看一下在迭代过程中移除List中元素的代码：

ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c",

"d"));

for (int i = 0; i < list.size(); i++) {

   list.remove(i);

}

System.out.println(list);

这个示例代码的输出结果是：

[b, d]

这个示例代码中存在一个非常严重的错误。当一个元素被移除时，该List的大小(size)就会缩减，同时也改变了索引的指向。所以，在迭代的过程中使用索引，将无法从List中正确地删除多个指定的元素。

你可能知道解决这个错误的方式之一是使用迭代器(iterator)。而且，你可能认为Java中的 foreach 语句与迭代器(iterator)是非常相似的，但实际情况并不是这样。我们考虑一下如下的示例代码：

ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c",

"d"));

for (String s : list) {

   if (s.equals("a"))

       list.remove(s);

}

这个示例代码会抛出来一个 ConcurrentModificationException。我们应该修改成如下所示：

ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c",

"d"));

Iterator<String> iter = list.iterator();

while (iter.hasNext()) {

   String s = iter.next();

   if (s.equals("a")) {

       iter.remove();

   }

}

next()方法必须在remove()方法之前被调用。在 foreach 循环中，编译器使得 remove()方法先于next()方法被调用，这就导致了 ConcurrentModificationException 异常。具体细节可以查看 ArrayList.iterator()的源码。

4. Hashtable vs HashMap

学习过数据结构的读者都知道一种非常重要的数据结构叫做 哈希表。在Java中，对应哈希表的的类是 HashMap 而不是 Hashtable。HashMap与Hashtable之间的最核心区别就是：HashMap是非同步的，Hashtable是同步的。

5. 在Collection中使用原始类型

在Java中，很容易把原始类型与无限通配类型混淆。我们举个Set相关的例子：Set就是原始类型；Set<?>就是无限通配类型。我们看一个使用在List中使用原始类型的例子：

public static void add(List list, Object o){

   list.add(o);

}

public static void main(String[] args){

   List<String> list = new ArrayList<String>();

   add(list, 10);

   String s = list.get(0);

}

这个示例代码会抛出来一个异常：

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer

cannot be cast to java.lang.String

   at ...

在Collection使用原始类型是具有很多的类型错误风险的，因为原始类型没有静态类型检查。实际上，Set、Set<?>和Set之间具有非常大的差异。

6. 访问权限

很多的Java初学者喜欢使用 public 来修饰类的成员。这样可以很方便地直接访问和存取该成员。但是，这是一种非常糟糕的编程风格，正确的设计风格应该是尽可能降低类成员的访问权限。

7. ArrayList vs LinkedList

很多的Java初学者不明白ArrayList与LinkedList之间的区别，所以，他们完全只用相对简单的ArrayList，甚至不知道JDK中还存在LinkedList。但是，在某些具体场景下，这两种List的选择会导致程序性能的巨大差异。简单而言：当应用场景中有很多的 add/remove 操作，只有少量的随机访问操作时，应该选择LinkedList;在其他的场景下，考虑使用ArrayList。

8. 可变 vs 不可变

不可变的对象具有非常多的优势，比如简单，安全等。但是，对于每一个不同的值，都需要该类的一个对象。而且，生成很多对象带来的问题就是可能导致频繁的垃圾回收。所以，在选择可变类还是不可变类时，应该综合考虑后再做抉择。

通常而言，可变对象可以避免创建大量的中间对象。一个非常经典的例子就是链接大量的短String对象为一个长的String对象。如果使用不可变String类，链接的过程将产生大量的，适合立即被垃圾回收的中间String对象，这将消耗大量的CPU性能和内存空间。此时，使用一个可变的StringBuilder或StringBuffer才是正确的。

String result="";

for(String s: arr){

   result = result + s;

}

除了上述情况，可变对象在其他场景下可能由于不可变对象。比如，传递一个可变的对象到方法内部，利用该对象可以收集多个结果，而不用在多个循环层次中跳进跳出。

9. 继承中的构造函数

上图中出现的两个编译时错误是因为：父类中没有定义默认构造函数，而子类中又调用了父类的默认构造函数。在Java中，如果一个类不定义任何构造函数，编译期将自动插入一个默认构造函数到给类中。一旦一个类定义了任何一个构造函数，编译期就不会插入任何构造函数到类中。在上面的示例中，Super类定义了一个参数类型为String的构造函数，所以该类中只有一个构造函数，不会有默认构造函数了。

&emps;在我们的子类 Sub 中，我们定义了两个构造函数：一个参数类型为String的构造函数，另一个为午餐的默认函数。由于它们都没有在函数体的第一行指定调用父类的哪一个构造函数，所以它们都需要调用父类 Super 的默认构造函数。但是，父类 Super 的默认构造函数是不存在的，所以编译器报告了这两个错误信息。

10. 字符串对象的两个构建方式

Java中的字符串对象具有两个常见的创建方式：

//1. use double quotes

String x = "abc";

//2. use constructor

String y = new String("abc");

它们之间的区别是什么呢？我们再看一下如下的代码：

String a = "abcd";

String b = "abcd";

System.out.println(a == b);  // True

System.out.println(a.equals(b)); // True

String c = new String("abcd");

String d = new String("abcd");

System.out.println(c == d);  // False

System.out.println(c.equals(d)); // True