java stream 更新 java update更新

java基础部分复习笔记

目录

• 1 输入
• 2 随机Random
• 3 Arraylist
• 4 Linkedlist
• 5 collections
• 6 Arrays类
• 7 String的使用
• 8 split
• 9 math类的使用
• 10 多态
• 11 访问成员内部类
• 12 Stringbuilder
• 13 线程与进程
• 13 线程安全

• 1 public synchronized void paytk()
• 2 synchronized(锁对象)
• 3 静态的同步方法
• 4 Lock锁
• 5 wait和notify

• 14 Java网络编程

1 输入

Scanner scanner = new Scanner(System.in);
 String a = scanner.next();//从键盘输入数据存储到int a中
 char[] chararray = a.toCharArray();   //传入char数组

2 随机Random

Random random = new Random();
int b = random.nextInt(100)+1;  //取1-100的随机数字

3 Arraylist

部分方法：
add 添加
remove 删除
get 获取
clear 清空集合中的所有元素
isEmpty 判断集合时候为空
Object[] xx = x.toArray() 吧集合中的元素，存储到数组中

ArrayList<String> list = new ArrayList<>();
        list.add("123"); //添加
        list.remove(1);  //删除

        for (int i = 0; i < list.size(); i++) { //list.fori 自动添加

        }
        for (int i = 0; i < 6; i++) {            //6.fori 自动添加

        }
        list.get(1);   //显示

4 Linkedlist

部分方法
addFirst()，将制定元素插入到列表开头
addLast() 将制定元素添加到列表的最后 == add()
push() 将元素推入此列表说表示的堆栈==assFirst
removeFirst 删除第一个
removeLast 删除最后一个
pop 删除

5 collections

collections常用功能
addAll（） 往集合中添加一些元素
shuffle（） 打乱顺序
sort（） 默认排序

6 Arrays类

int[] intArray = {10,20,30};
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);  //吧参数数组变为字符串
    //sort(数组)  数值默认升序，小-大
                //字符串默认字母升序， a-z
        int[] array = {1,43,67,23,54,100,9};
        Arrays.sort(array);
        String s = Arrays.toString(array);
        System.out.println(s);   //数值自动排序

        String[] array2 = {"aaa","bbb","ccc"};
        Arrays.sort(array2);
        String s2 = Arrays.toString(array2);
        System.out.println(s2);   //字符串自动排序

7 String的使用

相关方法的使用

1. substring(3);   //从3开始取后面的字符串
           substring(3,7);
               substring是string的一个方法，格式为：
                public String substring(int beginIndex, int endIndex)
                返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开始，一直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。
                示例： 
                "hamburger".substring(4, 8) returns "urge" "smiles".substring(1, 5) returns "mile"    toCharArray();  
    //将当前字符串拆分为字符数组作为返回值。
           getBytes();    //获得当前字符串底层的字节数组
           replace("do","are");   //将所有出现的老字符串do替换成新字符串are，返回替换后的字符串；
           sb.replace(6,10,"****");  //6-10号的的元素，用****替代
       
        for(int i = 0;i<str1.length();i++)
           {
               if(Character.isDigit(str1.charAt(i)))    //Character.isDigit()判断字符串是否包含数字
               {
                    xxxxxxxxxxxxxx
               }
           }

String c = "123456";
        String d = "7890";
        System.out.println(c.equals(d));  //比较
        String e = c.substring(3);   //从3开始取后面的字符串
        String f = c.substring(3,7);  //3-7输出
        char[] chars = c.toCharArray();   //将当前字符串拆分为字符数组作为返回值。
        byte[] bytes = c.getBytes();    //获得当前字符串底层的字节数组
        String str1 = "how do you do?";
        String g = str1.replace("do","are");   //将所有出现的老字符串do替换成新字符串are，返回e；

8 split

注意事项
按照参数规则，吧字符串划分为若干部分
//split的参数是一个正则表达式，
//如果按照英文句点".“要用”\."

String st3 = "aaa,bbb,ccc,ddd";
String[] array1 = st3.split(",");
for (int i = 0; i < array1.length; i++) {     //array1.length.fori
    System.out.println(array1[i]);              // array1[0]:aaa          array1[1]:bbb    array1[2]:ccc.
}

9 math类的使用

abs取绝对值
ceil 向上取整
floor 向下取整
round 四舍五入

double fl = Math.abs(-3.14); //3.14
        double fl2 = Math.ceil(3.14); //4
        double fl3 = Math.floor(3.14); //3
        double fl4 = Math.round(3.4); //3

10 多态

成员方法：编译看左边，运行看右边
成员变量：编译看左边，运行看左边

11 访问成员内部类

访问成员内部类：外部类.内部类 名称 = new 外部类().new 内部类()
如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
局部内部类：要是用局部变量，局部变量必须是final，不可改变。
匿名内部类：
类名或接口名 名称 = new 类名或接口名(){
重写方法;
}； //注意分号
//以上就是内部类的格式，其实这整体就相当于是new出来的一个对象
举例：

// 有名称th的类，可以使用多次里面定义的方法
          Thread th = new Thread(){
             public void run(){
                 System.out.println(getName());
             }
         };
        //没有对象名称的内部类，只能使用一次方法。
         new Thread(){
             public void run(){
                 System.out.println(getName());
             }
         }.run();

12 Stringbuilder

Stringbuilder //可以添加修改字符串
举例：

StringBuilder sb = new StringBuilder("111");
        sb.append("222");
        sb.append("333")
        System.out.println(append);
        //111222333

13 线程与进程

一个程序运行后至少有一个进程，一个进程中可以包含多个线程

进程：进入内存运行的程序
 
 线程：几个线程就可以同时执行几个任务
      一个进程中的功能，xx，xx，xx，就会开启一条应用程序到cpu的执行路径
      cup就可以通过这个路径执行功能，这个路径就是线程
      是进程中的一个执行单元
      线程多的好处：效率高，线程之间互不影响。

构造方法:
        public Thread()://分配一个新的线程对象。
        public Thread(String name）://分配一个指定名字的新的线程对象。
        public Thread(Runnable target)://分配一个带有指定目标新的线程对象。
        //常用方法:
        public String getName(）://获取当前线程名称。
        public void start()://导致此线程开始执行; Java虚拟机调用此线程的run方法。
        public void run(）://此线程要执行的任务在此处定义代码。
        public static Thread currentThread()://返回对当前正在执行的线程对象的引用。
        public Thread(Runnable target,String name) ://分配一个带有指定目标新的线程对象并指定名字。
        public static void sleep(long millis) ://使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行)。

实现步骤:1
    1.创建一个Thread类的子类
    2.在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么?)
    3.创建Thread类的子类对象
    4.调用Thread类中的方法start方法，开启新的线程，执行run方法
    void start(）使该线程开始执行;Java虚拟机调用该线程的run方法。
    多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
    java程序属于抢占式调度,那个线程的优先级高,那个线程优先执行;同一个优先级，随机选择一个执行
    结果是两个线程并发地运行﹔当前线程（main线程）和另一个线程《创建的新线程，执行其run方法)

  实现步骤2
    实现Runnable接口
    java.Lang.Runnable
    Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
    java.Lang.Thread类的柯造方法
    Thread (Runnable target）分配新的Thread对象。
    Thread ( Runnable target，string name）分配新的 Thread 对象。
    实现步骤:
    1.创建一个Runnable接口的实现类l
    2.在实现类中重写RunnabLe接口的run方法，设置线程任务
    3.创建一个RunnabLe接口的实现类对象
    4.创建Thread类对象，构造方法中传递RunnabLe接口的实现类对象
    5.调用Thread类中的start方法,开启新的线程执行run方法

 例如：

public class ThreadRunnable implements Runnable {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName());
                }

            }
        }
        public class Runnableimpl {
            public static void main(String[] args) {
                ThreadRunnable tb = new ThreadRunnable();
                Thread t = new Thread(tb);
                t.start();

                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName());
                }
            }
        }

获取线程的名称:
1.使用Thread类中的方法getName()
String getName(返回该线程的名称。
2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
static Thread currentThread(）返回对当前正在执行的线程对象的引用。

public class MyThread extends Thread{
            @Override
            public void run() {
            //主线程也可用
            System.out.println(Thread.currentThread().getName());
            }
        }

匿名内部类实现线程创建

1     new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println("bbb");
                }
            }
        }.start();

   2     new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println("卢本伟");
                }
            }
        }){

        }.start();

但是单纯的调用多线程会出现问题，例如，买票系统中3个窗口可能会同时出售一张票的可能，为了避免这个现象，可以使用互斥锁

13 线程安全

1 public synchronized void paytk()

解决线程安全问题的一种方案:使用同步代码块
格式:
synchronized(锁对象)
可能会出现线程安全向题的代码(访问了共享数据的代码)
)
注意:
1.通过代码块中的锁对象，可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用:
把同步代码块锁住，只让一个线程在同步代码块中执行

2 synchronized(锁对象)

解决线程安全问题的一种方案:
使用同步代码块
格式:
synchronized(锁对象){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}
注意:
1.通过代码块中的锁对象,可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用:
把同步代码块锁住,只让一个线程在同步代码块中执行

//第一种
public class Runnableimpl implements Runnable{
            //定义一个多线程的共享票源
            private int ticket = 100;

            //创建锁对象
            Object obj = new Object();

            //设置买票任务
            @Override
            public void run() {
                while(true){
                    //同步代码块
                    paytk();
                }
            }
            //同步方法
            public synchronized void paytk(){
                if (ticket>0){
                    //为了程序安全，设置sleep
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    ticket--;
                }
            }

        }

第二种
  public class Runnableimpl implements Runnable{
            //定义一个多线程的共享票源
            private int ticket = 100;

            //创建锁对象
            Object obj = new Object();

            //设置买票任务
            @Override
            public void run() {
                while(true){
                    //同步代码块
                    paytk();
                }
            }
            //同步方法
            public void paytk(){
                synchronized (this){
                    if (ticket>0){
                        //为了程序安全，设置sleep
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                        ticket--;
                    }
                }
            }
        }

3 静态的同步方法

锁对象是谁?
不能是this
this是创建对象之后产生的静态方法优先于对象
静态方法的锁对象是本类的cLass属性-->cLass文件对象(反射）

public class Runnableimpl implements Runnable{
            //定义一个多线程的共享票源
            静态变量
            private static int ticket = 100;

            //创建锁对象
            Object obj = new Object();

            //设置买票任务
            @Override
            public void run() {
                while(true){
                    //同步代码块
                    paytk();
                }
            }
            //静态同步方法
            public static synchronized void paytk(){
                    if (ticket>0){
                        //为了程序安全，设置sleep
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                        ticket--;
                    }
            }
        }

4 Lock锁

解决线程安全问题的三种方案:使用Lock锁
java.utiL.concurrent.Locks.Lock接口
lock实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作。
lock接口中的方法:
void lock()获取锁。
void unlock(释放锁。
java.util.concurrent.Locks.ReentrantLock impLements Lock接口
使用步骤:
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法Lock获取锁

public class Runnableimpl implements Runnable{
            //定义一个多线程的共享票源
            private static int ticket = 100;
            //在成员位置创建一个ReentrantLock对象
            Lock l = new ReentrantLock();

            //设置买票任务
            @Override
            public void run() {
                while(true){
                    //开启lock锁
                    l.lock();
                    //同步代码块
                    if (ticket>0){
                        //为了程序安全，设置sleep
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                        ticket--;
                    }
                    //关闭lock锁
                    l.unlock();
                }
            }
        }

进入到Timewaiting(计时等待)有两种方式

1.使用sleep(Long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/8Locked状态
⒉.使用wait(Long m)方法, wait方法如果在毫秒值结束之后,还没有被not ify唤醒,就会自动醒来，线程睡醒进入到RunnabLe/BLocked状态

5 wait和notify

①wait() 与 notify/notifyAll 方法必须在同步代码块中使用

②wait() 与 notify/notifyAll() 的执行过程

③中断 调用wait()方法进入等待队列的 线程

④notify 通知的顺序不能错

⑤多线程中测试某个条件的变化用 if 还是用 while？

wait() 与 notify/notifyAll 方法必须在同步代码块中使用

wait() 与 notify/notifyAll() 是Object类的方法，在执行两个方法时，要先获得锁。那么怎么获得锁呢？

在这篇：链接: JAVA多线程之Synchronized关键字–对象锁的特点.****文章中介绍了使用synchronized关键字获得锁。因此，wait()
与 notify/notifyAll()
经常与synchronized搭配使用，即在synchronized修饰的同步代码块或方法里面调用wait() 与
notify/notifyAll()方法。

例如： wait暂定线程后会释放cpu资源，等待下一个线程执行，
notify方法，会开启暂定的wait线程

14 Java网络编程

java语言通过URl类来访问网络上的资源
创建url对象的构造方法：

1	1

跟新……