【java】基础中的杂乱总结(一)

1 构造代码块

作用:给对象进行初始化。对象一建立就运行,并且优先于构造函数执行

构造函数是给所有对象进行统一初始化,构造函数是给对应的对象初始化

package package1;

class Person{
    private String name;

    {
        System.out.println("person code run");
    }

    Person(){
        System.out.println("name="+name);
        cry();
    }

    Person(String name){
        this.name = name;
        System.out.println("name="+name);
        cry();
    }

    public void cry(){
        System.out.println("crying");
    }
}

public class Test1 {
    public static void main(String[] args){
        Person p = new Person();
        Person p1 = new Person("tom");
    }
}

结果:

person code run
name=null
crying
person code run
name=tom

2 javadoc 注释文档的制作(以数组ArrayTool为例)

package package1;

/**
 * 这是一个对数组操作的工具类事例,提供最值,排序等功能
 * @author balfish_ac
 * @version V1.1
 *
 */

public class ArrayTool {
    private ArrayTool(){}

    /**
     * 获取最大值
     * @param arr 接收int类型的数组
     * @return 返回一个该数组中最大值
     */
    public static int getMax(int[] arr){
        int max = 0;
        for(int i=1; i<arr.length; i++){
            if(arr[i] > arr[max]){
                max = i;
            }
        }
        return arr[max];
    }

    /**
     * 选择排序
     * @param arr
     */
    public static void selectSort(int[] arr){
        for(int i=0; i<arr.length-1; i++){
            for(int j=i+1; j<arr.length; j++){
                if(arr[i] > arr[j]){
                    swap(arr,i,j);
                }
            }
        }
    }

    /**
     * 冒泡排序
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        for(int i=0; i<arr.length-1; i++){
            for(int j=0; j<arr.length-i-1; j++){
                if(arr[j] > arr[i+1]){
                    swap(arr,j,j+1);
                }
            }
        }
    }
    /**
     * 位置置换
     * @param arr
     * @param a 要置换的位置
     * @param b 要置换的位置
     */
    private static void swap(int[] arr, int a, int b){
        int tmp = arr[a];
        arr[a] = arr[b];
        arr[b] = tmp;
    }

    /**
     * 打印数组中的元素
     * @param arr
     */
    public static void printArray(int[] arr){
        for(int i=0; i<arr.length; i++){

        }
    }

}

命令行:javadoc -d mydoc -author -version ArrayTool.java

myeclipse: 项目上点右键-export-java-javadoc  即可(自己选路径)

3 静态代码块 , 构造代码块 , 构造函数 的执行顺序

package package1;

class StaticCode{
    StaticCode(){
        System.out.println("b");
    }

    static{
        System.out.println("a");
    }

    {
        System.out.println("c");
    }

    StaticCode(int x){
        System.out.println("d");
    }

}

public class Test1 {
    public static void main(String[] args){
        StaticCode s = new StaticCode(1);
    }
}

运行结果:

a
c
d

静态代码块 > 构造代码块 > 构造函数

4 Person p = new Person("zhangsan",20);

这句话都做了什么事情?

(1)因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中

(2)执行该类中的static代码块,如果有的话,给Person.class类进行初始化

(3)在堆内存中开辟空间,分配内存地址

(4)在堆内存中建立对象的特有属性,并进行默认初始化

(5)对属性进行显示初始化

(6)对对象进行构造代码初始化

(7)对对象进行对应的构造函数初始化

(8)将内存地址赋给栈内存的p变量

5 内部类相关

static的内部类行为上象一个独立的类,非static的内部类在行为上类似类的属性或方法且禁止声明static的方法。
内部类可以访问外部类的所有方法与属性,但static的内部类只能访问外部类的静态属性与方法。
/*
 * 内部类的访问规则:
 * 1 内部类可以直接访问外部类中的成员,包括私有,
 *    之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式为 外部类名.this
 * 2 外部类要访问内部类,必须建立内部类对象

 */

package package1;

class Outer{
    private int x = 3;
    class Inner{
        int x = 4 ;
        void function(){
            int x = 6;
            System.out.println("Inner: "+Outer.this.x);
            System.out.println("Inner: "+x);
        }
    }

    void method(){
            Inner in = new Inner();
            in.function();
    }
}

public class Test8 {
    public static void main(String[] args){
        Outer out = new Outer();
        out.method();
        System.out.println("-------------------------");
        //直接访问内部类中的成员
        Outer.Inner in = new Outer().new Inner();
        in.function();

    }
}

运行结果:

Inner: 3
Inner: 6
-------------------------
Inner: 3
Inner: 6

6 Iterator迭代器相关

(1)Iterator迭代器只有next,hasNext,remove方法,如果要获得其他方法且(在List接口子类情况下) 可以使用子接口ListIterator

(2)迭代时不能够再访问迭代中的framework,由于迭代引用已经指向框架对象,再有操作会有同步问题

(3)在一次的Iterator的迭代过程中不要出现两次it.next(),原因见下程序

package package1;
import java.util.ArrayList;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java01");
//        al.add("java03");

        Iterator it = al.iterator();
        while(it.hasNext()){
            System.out.println(it.next() + "------" +  it.next());
        }
    }
}

运行结果:throw new NoSuchElementException(); 不是成对出现的,注释去掉可以运行通过  (正常取一次判断一次而现在是取两次才判断)

7 HashSet相关

注意Hash相关的集合框架要覆写equals和hashCode,一定要注意和Object的参数列表相同,否则不是覆写。

另外, 判重只有HashCode值相同,才会判断equals!!!

package package1;
import java.util.HashSet;
import java.util.Iterator;

/*
 * HashSet保证元素唯一性的方法是:hashCode和equals方法
 * 如果元素的HashCode值相同,才会判断equals是否为true
 */
class Person{
    private String name;
    private int age;
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public String toString(){
        return "("+name+":"+age+")";
    }

    public int hashCode(){

        System.out.println(this.name+"...hashCode");
//        return 30;    标记1
        return name.hashCode() + age * 37;   //标记2
    }

    public boolean equals(Object obj){
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        System.out.println(this.name+ "...equals..." + p.name);
        return this.name.equals(p.name)&&this.age==p.age;
    }
}

public class Test {
    public static void main(String[] args) {
        HashSet<Person> hs = new HashSet<Person>();
        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        hs.add(new Person("a2",12));

        Iterator it = hs.iterator();
        while(it.hasNext()){
            Person p = (Person) it.next();
            System.out.println(p.getName() + "::" + p.getAge());
        }
    }
}

运行结果:

采用标记1:

a1...hashCode
a2...hashCode
a2...equals...a1
a3...hashCode
a3...equals...a2
a3...equals...a1
a2...hashCode
a2...equals...a3
a2...equals...a2
a3::13
a2::12
a1::11

采用标记2:

a1...hashCode
a2...hashCode
a3...hashCode
a2...hashCode
a2...equals...a2
a1::11
a3::13
a2::12

8 Arrays工具类的asList方法

把数组变成list集合,可以使用集合的思想和方法来操作数组中的元素

注意,使用asList时,不能使用集合的增删方法,因为数组的长度是固定的

而indexOf,contains,get什么的方法都没问题

package package1;

import java.util.Arrays;
import java.util.List;

public class Testhh {
     public static void main(String[] args) {
        String[] arr = {"abc" , "cc" , "kkkk"};    

        List<String> list = Arrays.asList(arr);
        System.out.println("contains:" + list.contains("cc"));

     //    list.add("qq"); //UnsupportedOperationException
        System.out.println(list);
     }
}

运行结果:

contains:true
[abc, cc, kkkk]

(若加注释抛出异常)

9 可变参数

其实就是数组参数的简写形式,不用每一次都手动建立数组对象,只要将要操作的元素作为参数传递即可,隐式地将参数封装为数组

注意:可变参数一定在参数列表的最后,防止冲突(放前面默认把后面的参数也当做可变参数接收 )

package package1;

public class Testhh {
     public static void main(String[] args) {
        /*
         int[] arr1 = {2,3,4};
         show(arr1);

         int[] arr2 ={2,3};
         show(arr2);
         */

         show(2,3,4);
         System.out.println("--------------------------");
         show(2,3,4,5,6,7);
     }

     /*
     public static void show(int[] arr){
         System.out.println(arr);
     }
     */

     public static void show(int... arr){
         for(int i=0 ; i<arr.length ; i++){
             System.out.println(arr[i]);
         }
     }

}

运行结果:

2
3
4
--------------------------
2
3
4
5
6
7

10 静态导入

如 import java.lang.System.*;  导入所有System类的静态成员

下面以Arrays为例说明。

package package1;

import static java.util.Arrays.*;
import  java.util.*;

import java.util.Arrays;

public class Testhh {
     public static void main(String[] args) {
         int[] arr = {3 , 1 , 5};
         sort(arr);
         int index = binarySearch(arr , 1);
         System.out.println(Arrays.toString(arr));  //不可省略Arrays,与Oeject的成员方法toString冲突
         System.out.println("index=" + index);
     }

}

运行结果:

[1, 3, 5]
index=0

上一篇:【spring data jpa】spring data jpa 中的update 更新字段,如果原字段值为null不处理,不为null则在原来的值上加一段字符串


下一篇:hdu 1698:Just a Hook(线段树,区间更新)