String

判断Integer是否为空（方法参数要求是String）需要先将Integer转为字符串

用valueOf()

  1. 注意不能用toString(),比如用 integerObject.toString(), 当integerObject对象为空时，会报空指针异常
  2. public static String valueOf(Object obj) {
  3.         return (obj == null) ? "null" : obj.toString();
  4.     }
  6. public String toString() {
  7.         return getClass().getName() + "@" + Integer.toHexString(hashCode());
  8.     }

包含子字符串

  1. 法一：
  2.     使用 String 类的 contains() 方法，如果找到了字符串的子字符串，就返回 true。
  3.     我们使用 toLowerCase() 方法来检查是否忽略大小写。
  6. 法二：
  7.     String 类的 indexOf() 方法是用来获取字符串中子字符串的索引，但我们也可以用它来查找子字符串。
  8.     检查子字符串的索引是否大于或等于 0，这意味着子字符串被找到了。
  9.   如果子字符串在字符串中不存在，它将返回 -1。

Java String.replace()方法“无效”的原因

  1. 原因：String不可变，cityName.replace之后cityName还是原来那个cityName，所以需要将其另赋值
  2. cityName = cityName.replace("直辖","");

返回 首字母大写 后的字符串

  1. //首字母大写，
  2.                             cityObj.put("englishCityName", area_name_en.substring(0, 1).toUpperCase() + area_name_en.substring(1));

数组

去除数组第一个元素，后续元素前移

  1. //去数组第一个元素
  2.     public static String[] delArrayFirst(String[] args){
  3.         int delLength = args.length-1;
  4.         String[] args1 = new String[delLength];
  5.       //将args数组从1往后的元素 复制到  args1数组从0往后的元素，长度为 args数组长度-1
  6.         System.arraycopy(args, 1, args1, 0, delLength);
  7.         return args1;
  8.     }

List

将一个集合的所有元素加到另一个集合

  1. 语法：
  2. arraylist.addAll(int index, Collection c)
  4. 参数说明：
  5. --index（可选参数）- 表示集合元素插入处的索引值
  6. --c - 要插入的集合元素
  7. 如果 index 没有传入实际参数，元素将追加至数组的最末尾。
  9. 返回值
  10. 如果成功插入元素，返回 true。
  12. 如果给定的集合为 null，则超出 NullPointerException 异常。
  14. 注意：如果 index 超出范围，则该方法抛出 IndexOutOfBoundsException 异常。

Map

遍历Map

  1. //key和value都获取
  2. for (Map.Entry<String,String> entry : map.entrySet()){
  3.             String key = entry.getKey();
  4.             String value = entry.getValue();
  5.         }
  6. //获取key(比entrySet性能好)
  7. for(String key : map.keySet()){
  8.     System.out.println(key);
  9. }
  10. //获取value(比entrySet性能好)
  11. for(String value : map.values()){
  12.     System.out.println(value);
  13. }

异常

try-catch语句块中变量的作用域

  • 在语句块内部定义的变量，作用域在语句块内部，外部不可见。
  • 在语句块外部定义的变量，在语句块内部可以对变量进行修改。

    方法中抛出运行是异常，后面代码是否会执行

  1. 前有异常抛出（这个异常没有被捕获），后面代码将产生编译时错误「无法访问的语句」。

    1. public static void test() throws Exception  {
    3.  throw new Exception("参数越界"); 
    4.  System.out.println("异常后"); //编译错误，「无法访问的语句」
    5. }

  2. 前有异常抛出（这个异常被try…catch所捕获），若此时catch语句中没有抛出新的异常，则这段代码能够被执行。

    1. try{
    2.          throw new Exception("参数越界"); 
    3.      }catch(Exception e) {
    4.          e.printStackTrace();
    5.      }
    6.      System.out.println("异常后");//可以执行

  3. 若在一个条件语句中抛出异常，则程序能被编译，但后面的语句不会被执行。

    1. if(true) {
    2.  throw new Exception("参数越界"); 
    3. }
    4. System.out.println("异常后"); //抛出异常，不会执行

    空指针异常

    java.lang.NullPointerException ```java

    一般报java.lang.NullPointerException的原因有以下几种：

—1、字符串变量未初始化； —2、[菜鸟雷区]接口类型的对象没有用具体的类初始化，比如： List lt; 会报错 List lt = new ArrayList(); 则不会报错了 —3、当一个对象的值为空时，你没有判断为空的情况。

  1.     -- 1、if(rb!=null);
  2.     -- 2、String类型的对象可以做如下判断
  3.             --if(rb!=null&&!"".equals(rb))
  4.             --当然还可以多做一个判断，是否不为空字符串
  5.               if(rb!=null&&!"".equals(rb.trim()))

—4、Class class; 此时，这个class被声明了类型， 默认 class = null; 这样在调用class.xxxx()的时候系统只能给你个空指针异常。

  1. 想不要空指针那么就给class做个赋值操作就好了，例如 class = new Class();
  1. <a name="HSXcW"></a>
  2. # 动态代理及反射机制
  3. <a name="muzRK"></a>
  4. ## Java 中的反射的概念？
  6. - **使用一个类，首先要加载类**：当**编译一个新类**时，会产生一个同名的**.class文件**，该文件内容保存着Class对象。类加载相当于Class对象的加载，类在**第一次使用**时才动态加载到JVM中。也可以使用Class类中的**静态方法forName(类名+包名)**这种方式来控制类的加载，该方法会返回一个Class对象。每个类都**只有**一个**Class对象**，包含类的结构信息(这个对象就像一面镜子，透过这个镜子就可以看到类的结构，**Class对象就是反射的核心**)。
  7. - **在Java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。**
  8. <a name="Z3Enq"></a>
  9. ## 反射的作用？
  11. - 动态加载类、动态获取类信息（属性、构造方法、构造器）
  12. - 动态构造对象
  13. - 动态调用类和对象的任意方法
  14. - 动态调用和处理属性
  15. - 获取泛型信息
  16. - 处理注解
  18. 首先要搞清楚为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念。<br />静态编译：在编译时确定类型，绑定对象，即通过。<br />动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了Java的灵活性，体现了多态的应用，用以降低类之间的藕合性。
  19. <a name="Rzje2"></a>
  20. ## 反射机制优缺点：
  21. **反射机制的优点**：运行期间类型的判断，Class.forName()动态加载类，提高代码灵活度。<br />比如，一个大型的软件，不可能一次就把它设计得很完美，把这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时动态地创建和编译，就可以实现该功能。<br />**反射机制的缺点**：
  23. - 性能开销：反射机制涉及动态类型的解析，所以JVM无法对这些代码进行优化，效率低很多。因此要避免在经常要执行或性能要求很高的程序中使用反射。
  24. - 安全限制：反射必须要求在一个没有安全限制的环境中运行
  25. - 内容暴露：反射允许访问私有属性和方法，增加代码维护困难。
  26. <a name="THg6D"></a>
  27. ## 反射应用案例
  28. ```java
  29. /**
  30.  * 要求：根据给定的方法名顺序来决定方法的执行顺序
  31.  * idea上的操作：改变main方法参数：Edit Configuration...->Program arguments->填写参数(ep:method2 method3 method1)
  32.  */
  33. public class Test {
  34.     public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {
  35.         //实例化对象
  36.         ReflectDemo reflectDemo = new ReflectDemo();
  37.         if (args!=null&&args.length>0){
  38.             //获取reflectDemo的Class对象
  39.             Class clazz = reflectDemo.getClass();
  40.             //通过反射获取ReflectDemo下的所有方法
  41.             Method[] methods = clazz.getMethods();
  42.             for (String str:args){
  43.                 for (int i=0;i<methods.length;i++){
  44.                     if (str.equalsIgnoreCase(methods[i].getName())){
  45.                         methods[i].invoke(reflectDemo);
  46.                     }
  47.                 }
  48.             }
  49.         }else {
  50.             reflectDemo.method1();
  51.             reflectDemo.method2();
  52.             reflectDemo.method3();
  53.         }
  54.     }
  55. }

反射应用

反射实战
反射与工厂模式实现Spring IOC
工厂模式，使用反射机制，根据全限定类名获得某个类的Class实例

  • 动态代理
  • 怎么实现动态代理