191224

Author: 657122411

src/com/blankj/study/base/Node.java

@@ -4,6 +4,11 @@ public class Node {
     private String data;
     private Node next;
 
+    public Node( ) {
+        super();
+        this.data = "";
+    }
+
     public Node(String data) {
         super();
         this.data = data;

src/com/blankj/study/corejava/Test01.java

@@ -0,0 +1,20 @@
+package com.blankj.study.corejava;
+//静态导入
+import javafx.beans.binding.ObjectExpression;
+
+import static java.lang.Math.sqrt;
+
+public class Test01 {
+    public static void main(String[] args) {
+        System.out.println(sqrt(4));
+        //数值类型转换
+        Object o1 = (1D+1);
+        Object o2 = (2F+2);
+        Object o3 = (3L+3);
+        Object o4 = ('A'+'A');
+        System.out.println("顺序dfli");
+
+        String ans = String.join("long","我","是","龙");
+        System.out.println(ans);
+    }
+}

src/com/blankj/study/corejava/Test02.java

@@ -0,0 +1,21 @@
+package com.blankj.study.corejava;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class Test02 {
+    public static void main(String[] args) {
+        ArrayList<Integer> list = new ArrayList<>();
+        list.ensureCapacity(1);
+        System.out.println(list.size());
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        Integer[] arr = new Integer[list.size()];
+        list.toArray(arr);
+        System.out.println(Arrays.toString(arr));
+
+        Integer i = list.remove(1);
+        System.out.println(i);
+    }
+}

src/com/blankj/study/corejava/Test03.java

@@ -0,0 +1,27 @@
+package com.blankj.study.corejava;
+
+/**
+ * 枚举类
+ */
+enum Size{
+    //example
+    SMALL("s"),
+    MEDIUM("m"),
+    LARGE("l"),
+    EXTRA_LARGE("xl");
+
+    private Size(String abbreviation){
+        this.abbreviation = abbreviation;
+    }
+
+    private String abbreviation;
+    public String getAbbreviation(){
+        return abbreviation;
+    }
+}
+
+public class Test03 {
+    public static void main(String[] args) {
+
+    }
+}

src/com/blankj/study/corejava/Test04.java

@@ -0,0 +1,43 @@
+package com.blankj.study.corejava;
+
+public class Test04 {
+    public volatile static int i = 0;
+
+    public static class AddThread extends Thread {
+        @Override
+        public void run() {
+            for (i = 0; i < 1000000000; i++) ;
+        }
+    }
+
+    static Acount instance = new Acount();
+    static int a = 0;
+    public static class Acount implements Runnable{
+        @Override
+        public void run(){
+            for(int j = 0;j<100000000;j++){
+                synchronized (instance){
+                    a++;
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        AddThread addThread = new AddThread();
+        long start = System.currentTimeMillis();
+        addThread.start();
+        //等待线程结束 归来 默认参数为0，无限等待其执行时间，否则指定有限时间等待
+        addThread.join(1);
+        long end = System.currentTimeMillis();
+        System.out.println(end - start);
+
+        Thread t1 = new Thread(instance);
+        Thread t2 = new Thread(instance);
+        t1.start();t2.start();
+        t1.join();t2.join();
+        System.out.println(a);
+
+
+    }
+}

src/com/blankj/study/corejava/Test05.java

@@ -0,0 +1,26 @@
+package com.blankj.study.corejava;
+
+import com.blankj.study.base.Node;
+
+public class Test05 {
+    public static final int initData = 666;
+
+    //常量 静态变量 类信息置于方法区 (Test05.class 与node指针)
+    public static Node node = new Node();
+
+    //每一个方法对应一个栈帧内存区域(cpmpute()栈帧)
+    public int compute(){
+        //局部变量表存放在栈
+        int a = 1;
+        int b = 2;
+        //操作数栈
+        int c = (a+b)*10;
+        return c;
+    }
+
+    public static void main(String[] args) {
+        //对象置于堆，在main()栈帧中存放局部变量表 test指向它
+        Test05 test = new Test05();
+        test.compute();
+    }
+}

src/com/blankj/study/singleton/LazySingleton.java

@@ -1,20 +1,54 @@
 package com.blankj.study.singleton;
 
 
-// 懒汉单例 线程安全
+/** 懒汉单例 线程安全
+ * @author Administrator
+ */
 public class LazySingleton {
+    /**
+     * 屏蔽外部构造实例的途径
+     */
     private LazySingleton() {
     }
 
+    /**
+     * static修饰属于类的变量 volatile禁止指令重排 初始null懒加载机制
+     */
     private static volatile LazySingleton instance = null;
 
     public static LazySingleton getInstance() {
         if (instance == null) {
+            //加锁线程同步
             synchronized (LazySingleton.class) {
-                if (instance == null)
+                //双重检验，可能有多个线程进入到这里待执行
+                if (instance == null){
                     instance = new LazySingleton();
+                }
             }
         }
         return instance;
     }
+
+    public static void main(String[] args) {
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LazySingleton lazySingleton = LazySingleton.getInstance();
+                System.out.println(lazySingleton);
+            }
+        }).start();
+
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LazySingleton lazySingleton = LazySingleton.getInstance();
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                System.out.println(lazySingleton);
+            }
+        }).start();
+    }
 }