复习

1.单例模式
https://www.runoob.com/design-pattern/singleton-pattern.html
静态内部类里不是hoder方法是方法不是静态代码块，不会加载类的同事主动调用方法
2.数组集合
https://www.cnblogs.com/tangyijing/p/7788171.html
https://blog.youkuaiyun.com/zhangqunshuai/article/details/80660974
数组

public class ArraysSort {
    public static void main(String[] args) {

        int[] arrays = {4, 55, 5, 584};
//交换排序
        for (int i = 0; i < arrays.length-1; i++ )
        {
            for (int j = i+1; j < arrays.length; j++ )
            {
                if (arrays[i] >arrays[ j ] )
                {
                    int temp = arrays[i];
                    arrays[i] = arrays[ j ];
                    arrays[ j ] = temp;
                }
            }
        }
        for (int k = 0; k <arrays.length ; k++) {
            System.out.println(arrays[k]);

        }
        //数组没有foreach方法
    }
}

list

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

public class LIst {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        List<String> asList = Arrays.asList("15", "name", "gender");
        list.add(5);
        list.add(1,2);
        list.add(1,7);
        System.out.println(asList.get(0));
        System.out.println(list.get(0));
        list.remove(1);
        list.forEach(x -> System.out.println(x));

    }
}

map

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Map {
    public static void main(String[] args) {
        HashMap<Object, Object> hashMap = new HashMap<>();
        hashMap.put("gender","nan");
        hashMap.put("age","415");

        System.out.println(hashMap.get("age"));
        //将map中的数据拿来放在set中
        Set<java.util.Map.Entry<Object, Object>> entryset = hashMap.entrySet();
        Iterator<java.util.Map.Entry<Object, Object>> iterator = entryset.iterator();
        while (iterator.hasNext()) {
            java.util.Map.Entry<Object, Object> next = iterator.next();

            System.out.println( next.getKey());
            System.out.println(next.getValue());

        }
    }
}

3.工厂模式
https://www.runoob.com/design-pattern/factory-pattern.html
shapeType.equalsIgnoreCase(“CIRCLE”)这句话的意思是忽略大小写看shapeType与"CIRCLE"是否相同返回boolean
4.volatile指令重排序
https://blog.youkuaiyun.com/chao430/article/details/90105165
5.java stream
https://blog.youkuaiyun.com/lucasmaluping/article/details/100134566
还有java8的新特性，现在先不看，有时间再说

import java.io.*;

public class stream {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\aaa.txt");
        FileInputStream stream = new FileInputStream(file);

        System.out.println(stream.read());

        FileReader fileReader = new FileReader(file);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String line = bufferedReader.readLine();
        System.out.println(line);
    }
}

6.多线程
里面有线程池
https://www.cnblogs.com/jmsjh/p/7762034.html

```java
package Thread;

public class ExtendsThread extends Thread {

//定义指定线程名称的构造方法

   /* public ExtendsThread(String name) {

//调用父类的String参数的构造方法，指定线程的名称

        super(name);

    }*/

    /**

     * 重写run方法，完成该线程执行的逻辑

     */

    @Override

    public void run() {

        for (int i = 0; i < 10; i++) {

            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}

package Thread;

public class ImplemetsRunnable implements Runnable{

    @Override
    public void run() {

        for (int i = 0; i <10 ; i++) {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package Thread;

public class MainThread {
    static class Demo{

        String name;

        Demo(String name){

            this.name = name;

        }

        void show() {

            for (int i=1;i<=10000 ;i++ ) {

                System.out.println("name="+name+",i="+i);

            }

        }

    }



    static class ThreadDemo {

        public static void main(String[] args) {

            Demo d = new Demo("小强");

            Demo d2 = new Demo("旺财");

            d.show();

            d2.show();

            System.out.println("Hello World!");

        }

    }
}

package Thread;
//线程的匿名内部类使用
public class niming {
    public static void main(String[] args) {
     /*   重写Thread中的run方法
     new Thread() {

            public void run() {

                for (int x = 0; x < 40; x++) {

                    System.out.println(Thread.currentThread().getName()

                            + "...X...." + x);

                }

            }

        }.start();
    }*/

    //使用匿名内部类的方式实现Runnable接口，并重写run方法
        Runnable r = new Runnable() {

            public void run() {

                for (int x = 0; x < 40; x++) {

                    System.out.println(Thread.currentThread().getName()

                            + "...Y...." + x);

                }

            }

        };

        new Thread(r).start();

    }
}

package Thread;

public class thread {
    public static void main(String[] args) throws InterruptedException {
        //这个这样写是因为ExtendsThread中写了构造方法指定线程名称
        //指定了的名称就叫指定的名字，未指定的名称就叫Thread-0，Thread-1
        /*ExtendsThread t1 = new ExtendsThread("t1");
        ExtendsThread t2 = new ExtendsThread("t2");*/
        ExtendsThread t1 = new ExtendsThread();
        ExtendsThread t2 = new ExtendsThread();
        //相当于在新线程中调用run方法，也就是开启器了一个新线程
//            t1.start();
        //run的是主线程
//            t2.run();
        t2.start();

        Thread t3 = new Thread(new ImplemetsRunnable());
        Thread t4 = new Thread(new ImplemetsRunnable());
        t3.start();
        t4.start();

    }
}