public class Dog {
    private String name;
    private int age;

    public Dog(){
        this.name = null;
        this.age = 0;
    }

    public Dog(String name, int age){
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "{\"Dog\":{"
                + "                        \"name\":\"" + name + "\""
                + ",                         \"age\":\"" + age + "\""
                + "}}";
    }
}

public class Test {
    public Unsafe getUnsafe() {
        try {
            final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
            unsafeField.setAccessible(true);
            // the unsafe instance
            return (Unsafe) unsafeField.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static void main(String[] args)throws Exception {
        Test test = new Test();
        Unsafe unsafe = test.getUnsafe();
        Dog dog = new Dog();
        // 获取name属性偏移量
        long nameOffset = unsafe.objectFieldOffset(Dog.class.getDeclaredField("name"));
        unsafe.putObject(dog, nameOffset, "旺财");
        //获取age属性偏移量
        long ageOffset = unsafe.objectFieldOffset(Dog.class.getDeclaredField("age"));
        unsafe.putInt(dog, ageOffset,3);
        System.out.println(dog.toString());
    }
}

public class Test1 {
    public Unsafe getUnsafe() {
        try {
            final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
            unsafeField.setAccessible(true);
            // the unsafe instance
            return (Unsafe) unsafeField.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static void main(String[] args)throws Exception {
        Test1 test = new Test1();
        Unsafe unsafe = test.getUnsafe();
        //帮助理解concurrentHashmap
        Dog[] dogs = new Dog[3];
        //获取数组中第一个元素的偏移量
        long dogBase = unsafe.arrayBaseOffset(Dog[].class);
        //获取数组中一个元素的大小
        int ts = unsafe.arrayIndexScale(Dog[].class);
        int dogShift = 31 - Integer.numberOfLeadingZeros(ts);
        unsafe.putOrderedObject(dogs, dogBase, new Dog("旺财",3));
        unsafe.putOrderedObject(dogs, (long)(1 << dogShift) + dogBase, new Dog("小强",4));
        unsafe.putOrderedObject(dogs, ts*2 + dogBase, new Dog("富贵", 5));
        for(int i = 0 ; i < dogs.length ; i++){
            System.out.println(dogs[i].toString());
        }
    }
}

public static void main(String[] args) {
   int aHundredMillion = 10000000;

   Map<Integer, Integer> map = new HashMap<>();

   long s1 = System.currentTimeMillis();
   for (int i = 0; i < aHundredMillion; i++) {
       map.put(i, i);
   }
   long s2 = System.currentTimeMillis();

   System.out.println("未初始化容量，耗时 ： " + (s2 - s1));


   Map<Integer, Integer> map1 = new HashMap<>(aHundredMillion / 2);

   long s5 = System.currentTimeMillis();
   for (int i = 0; i < aHundredMillion; i++) {
       map1.put(i, i);
   }
   long s6 = System.currentTimeMillis();

   System.out.println("初始化容量5000000，耗时 ： " + (s6 - s5));


   Map<Integer, Integer> map2 = new HashMap<>(aHundredMillion);

   long s3 = System.currentTimeMillis();
   for (int i = 0; i < aHundredMillion; i++) {
       map2.put(i, i);
   }
   long s4 = System.currentTimeMillis();

   System.out.println("初始化容量为10000000，耗时 ： " + (s4 - s3));
}

未初始化容量，耗时 ： 14419
初始化容量5000000，耗时 ： 11916
初始化容量为10000000，耗时 ： 7984

public class Sort {
    public void swap(int[] array,int i,int j){
        if(i<array.length&&j<array.length){
            int data=array[i];
            array[i]=array[j];
            array[j]=data;
        }
    }
}
/**
 * 冒泡排序
 */
public class BubbleSort extends Sort{
    /**
     * 冒泡排序
     */
    public void bubbleSort(int[] array){
        if(array.length<2){
            return;
        }
        int i,j;
        for(i=0;i<array.length-1;i++){
            for(j=array.length-1;j>i;j--){
                if(array[j]<array[j-1]){
                    swap(array,j,j-1);
                }
            }
        }
    }
    /**
     * 优化的冒泡排序
     */
    public void bubbleSort2(int[] array){
        if(array.length<2){
            return;
        }
        int i,j;
        boolean flag=true;
        for(i=0 ; i<array.length-1 && flag ; i++){
            flag=false;
            for(j=array.length-1;j>i;j--){
                if(array[j]<array[j-1]){
                    swap(array,j,j-1);
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] array={9,1,5,8,3,7,4,6,2};
        System.out.println(Arrays.toString(array));
        BubbleSort bubbleSort=new BubbleSort();
        bubbleSort.bubbleSort(array);
        System.out.println(Arrays.toString(array));
        int[] array2={2,1,3,4,5,6,7,8,9};
        System.out.println(Arrays.toString(array2));
        bubbleSort.bubbleSort2(array2);
        System.out.println(Arrays.toString(array2));
    }
}