java

java

方法小写 类名大写

readline-sync

多线程

进程是一个应用程序（一个进程是一个软件）
线程是一个进程中的执行场景或执行单元
一个进程可以启动多个线程

Java程序来说，在DOS命令窗口中输入：java helloworld，回车之后，先启动JVM，jvm就是一个进程，JVM会再启动一个主线程调用main方法，同时再启动一个垃圾回收站线程负责看护，回收垃圾。
现在Java程序中至少有两个线程并发，一个垃圾回收，一个main方法。

进程内存独立不共享
java中，线程，堆内存和方法区内存共享，栈内存独立，一个线程一个栈

String必须要有return
void则无，使用println返回值

方法体中的代码永远都是自上而下的顺序一次逐行执行的

多线程：
1.集成java.lang.Thread

当前线程优先级Thread.currentThread.getPriority();
MAX_PRIORITY=10;
NORM_PRIORITY=5;
MIN_PRIORITY=1;
Thread.setPriority(10);//设置当前线程为最高优先级10
优先级较高的，抢到CPU时间片相对多一些
Thread.yield();//让位。当前线程暂停一下，让给主线程
t.join//t合并到当前线程，当前线程受阻，t线程执行直到结束。内存上没有栈消失，只是时间顺序上

主线程和子线程的并行

package learn;

public class thread1 {
    public static void main(String[] args) {
        first a = new first();
        a.setName("aaa");//设置线程名字
        String aName=a.getName();//获取线程的名字,默认是0开始
        System.out.println(aName);
        a.start();//开始新的栈
        for (int i=1;i<1000;i++) {
            System.out.println("主线程----->"+i);
        }
    }
}
class first extends Thread{
    @Override
    public void run() {
       for(int i=1;i<1000;i++){
           Thread a=Thread.currentThread();
           //获得当前线程对象，当aaa执行run方法，当前线程就是aaaa；当bbb执行run方法，当前线程就是bbb
           System.out.println(a.getName()+"--->"+i);
//           System.out.println(super.getName()+"--->"+i);
//           System.out.println(this.getName()+"--->"+i);
       }
    }
}

package learn;

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

        second num1= new second();
        Thread num2= new Thread(num1);//两行等价于Thread num2 = new Thread(new (learn.second));

        num2.start();

        for (int i=1;i<1000;i++) {
            System.out.println("主线程----->"+i);
        }
    }
}
class second implements Runnable{

    @Override
    public void run() {
        for(int i=1;i<1000;i++){
            System.out.println("分支线程----->"+i);
        }
    }
}
/*采用匿名类的方式
public class learn.thread2 {
    public static void main(String[] args) {

        Thread a = new Thread(new Runnable(){
            @Override
            public void run() {
                for(int i=1;i<1000;i++){
                System.out.println("分支线程----->"+i);
        }
    }});
        t.start();;
        for (int i=1;i<1000;i++) {
            System.out.println("主线程----->"+i);
        }
    }
}
*
*
* */

集合

import java.util.Collection
集合是一个容器，一次可以容纳多个对象，不能储存基本数据类型，不能直接存储对象。
储存的是java对象的内存地址
底层有不同的数据结构，不同集合中储存元素，就是将元素放到了不同的数据结构当中
new ArrayList()创建一个集合，底层是数组
new LinkedList()链表
new TreeSet()二叉树
new HashSet()
collection存放
没有使用泛型前，可以存储Object所有子类型
使用泛型之后，只能存储某个具体类型

add(Object e):向集合里添加元素
c.add(1200)自动装箱，存储了1200对象的内存地址
c.add(new Object());
c.add(new fun());
c.add(true);

size():获取集合中元素个数
clear():清空集合
contains():判断集合中是否包含
remove():删除某个元素
isEmpty():判断集合是否为空
toArray():将集合转换为数组 Object[] objs = c.toArray();

package learn;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class first {
    public static void main(String[] args) {
        Collection c =new HashSet();//HashSet集合，无序不可重复。
        // 无序：存进去和取出来顺序不一定相同；不可重复：存储100，不能再存储100
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add(1);
        c.add(2);
        c.add(100);
        c.add(new Object());
        //对集合Collection进行遍历，迭代
        //第一步，获得集合对象的迭代器对象Iterator
        Iterator it =c.iterator();
        //通过以上获得的迭代器对象开始迭代，遍历集合.迭代器一开始没有指向第一个元素
        /*Iterator中的方法
        * boolean hasNext()如果有元素可以跌打，则返回true
        *Object next()返回迭代的下一个元素
        * */
        while(it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);
        }
    }
}

泛型

nio

lambda表达式