java的一些最最最最基本的东西，纯粹是为了保存

1、方法签名

　　指的是方法名和参数类型

2、java类初始化数据的方法

• 构造函数
• 声明变量时赋值
• 静态块

3、List转数组

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

　　list.add("aa");

　　list.add("bb");

　　String[] array = new String[list.size()];

　　array = list.toArray(array);

4、数组转List

• ArrayList<Element> arrayList = new ArrayList<Element>(Arrays.asList(array));
• List<Element> list = Arrays.asList(array);

　　　这不是最好的，因为asList()返回的列表的大小是固定的。事实上，返回的列表不是 java.util.ArrayList，而是定义在java.util.Arrays中一个私有静态类。我们知道ArrayList的实现本质上是一个数组，而asList()返回的列表是由原始数组支持的固定大小的列表。这种情况下，如果添加或删除列表中的元素，程序会抛出异常UnsupportedOperationException。

• Element[] array = {new Element(1), new Element(2)};

　　　List<element> list = new ArrayList<element>(array.length);

　　　Collections.addAll(list, array);

5、java安全删除list中的元素　

for (Iterator<AccountParam> iterator = accountParams.iterator(); iterator.hasNext();)
{
    boolean validateResult = this.beforInsertRecordValidate(iterator.next());

    if (!validateResult)
    {
        iterator.remove();
    }
}

Iterator iterator = accountParams.iterator();
while (iterator.hasNext())
{
    boolean validateResult = this.beforInsertRecordValidate(iterator.next());
}

6、在静态方法中new 一个内部类对象和new 一个外部类对象的区别

• 内部类从属于一个对象，外部类是个独立的类。
• main 是一个静态方法，不是类的成员
• 只能在类对象之中，调用内部类

因此，只能在类的成员方法中定义内部类（常用），或者用：{类的对象}.new {内部类}（），来定义内部内。

7、关于static{}

　　在程序的一次执行过程中，static{}语句块中的内容只被执行一次，因为在虚拟机的生命周期中一个类只被加载一次；又因为static{}是伴随类加载执行的，所以，不管你new多少次对象实　　　　       例，static{}都只执行一次。

　　static{}语句块的执行次序

• 当一个类中有多个static{}的时候，按照static{}的定义顺序，从前往后执行；
• 先执行完static{}语句块的内容，才会执行调用语句；
• 如果静态变量在定义的时候就赋给了初值(如 static int X=100)，那么赋值操作也是在类加载的时候完成的，并且当一个类中既有static{}又有static变量的时候，同样遵循“先定义先执行”的原则；

8、类加载的含义

• 在虚拟机的生命周期中一个类只被加载一次。
• 类加载的原则：延迟加载，能少加载就少加载，因为虚拟机的空间是有限的。
• 类加载的时机：

　　　　第一次创建对象要加载类.

　　　　调用静态方法时要加载类,访问静态属性时会加载类。

　　　　加载子类时必定会先加载父类。

　　　　创建对象引用不加载类.

　　　　子类调用父类的静态方法时

　　　　　　当子类没有覆盖父类的静态方法时，只加载父类，不加载子类

　　　　　　当子类有覆盖父类的静态方法时，既加载父类，又加载子类

　　　　访问静态常量，如果编译器可以计算出常量的值，则不会加载类,例如:public static final int a =123;否则会加载类,例如:public static final int a = math.PI。

9、java list对象排序

• 对象实现Comparable<>接口

1 @Override
2 public int compareTo(User o) {
3 　　int i = this.getAge() - o.getAge();//先按照年龄排序
4 　　if(i == 0){
5 　　　　return this.score - o.getScore();//如果年龄相等了再用分数进行排序
6 　　}
7 　　return i;
}

• 对象不实现Comparable接口

 Collections.sort(students, new Comparator<Students>() {
 　　@Override
 　　public int compare(Students o1, Students o2) {
 　　　　int i = o1.getScore() - o2.getScore();
 　　　　if(i == 0){
 　　　　　　return o1.getAge() - o2.getAge();
 　　　　}
 　　　　return i;
 　　}
}