欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java高级教程02

程序员文章站 2022-03-30 10:17:34
[TOC] 1.Java线程 1.1. 多线程和多进程 多进程:操作系统能够同时进行多个任务: 每个app(word,播放器,浏览器)可以同时运行 多线程:同一应用程序中哟多个顺序流同时执行 线程是进程中的一部分 1.2. 线程的执行过程: 主要过程: 多线程执行的抢CPU是不规律的,由虚拟机分配 ......

目录

1.java线程

1.1. 多线程和多进程

  • 多进程:操作系统能够同时进行多个任务: 每个app(word,播放器,浏览器)可以同时运行
  • 多线程:同一应用程序中哟多个顺序流同时执行
  • 线程是进程中的一部分

1.2. 线程的执行过程:

Java高级教程02

主要过程:

Java高级教程02

多线程执行的抢cpu是不规律的,由虚拟机分配

1.3. 创建线程的方法

(1). 方法1:通过run()

  • 定义一个线程类,它继承类thread并重写其中的run()方法,方法run()成为线程体
  • 由于java只支持单继承,用这种方法定义的类不能继承其他类
class threadone extends thread{
  public void run(){
    for (int i=0; i<100;i++){
      system.out.println("thread one--->" + i);
    }
  }
}

class threadtwo extends thread{
  public void run(){
    for (int i=0; i<100;i++){
      system.out.println("thread two--->" + i);
    }
  }
}

class test{
  public static void main(string[] args){
    // 生成线程类的对象
    threadone fo = new threadone();
    threadtwo ft = new threadtwo();
    // 启动线程---> 进入runnable状态---->准备抢cpu
    fo.start();
    ft.start();
  }
}

(2). 方法2: 复写runnable接口(推荐)

  • 提供一个实现接口runnable的类作为线程的目标对象,在初始化一个thread类或者thread子类的线程对象时,把目标对象传递给这个线程实体,由该目标对象提供线程体
class runnableimpl implements runnable{
  public void run(){
    for (int i=0; i<100;i++){
      system.out.println("thread two--->" + i);
    }
  }
}

class test{
  public static void main(string[] args){
    //生成一个runnable接口实现类的对象
    runnableimpl ri = new runnableimpl();
    //生成一个thread对象,并将runnable接口实现类的对象作为参数传递给该thread对象
    thread t = new thread(ri);
    // 通知thread执行
    t.start();
  }
}

1.4. 线程的简单控制

  • 中断线程
    • thread.sleep():先睡眠,然后继续进入就绪状态,准备抢cpu----记得抛出异常哦,亲
    • thread.yield():让出cpu,然后继续进入就绪状态,准备抢cpu
  • 设置线程的优先级:
    • getpriority(): 获取优先级
    • setpriority(): 设置优先级(1-10)

2. java线程同步synchronized

2.1. 多线程数据安全以及synchronized的使用

  • 多线程共用同一份数据的时候,会出问题
class mythread implements runnable{
  int i = 100;
  public void run(){
    while (true){
      // 使用synchronized构造同步代码块---this为同步锁
      synchronized(this){
        // thread.currentthread()获取当前代码正在哪个线程中运行
        system.out.println(thread.currentthread().getname() + i);
        i = i -1;
        thread.yield();
        if(i<0){
          break;
        }  
      }
    }
  }
}

class test{
  public static void main(string[] args){
    mythread mythread = new mythread();
    // 生成两个
    thread t1 = new thread(mythread);
    thread t2 = new thread(mythread);

    t1.setname("thread a");
    t2.setname("thread b");
    // t1先获得锁,运行,t2等待
    // t2然后获得锁,运行,t1等待
    t1.start();
    t2.start();
  }
}

2.2. 深入synchronized关键字

  • 同步锁不是锁的代码块,锁的是this, 只要一个对象获得同步锁,这个对象其他也含有同步锁的代码都不能执行,只能释放后才能执行
  • 没有同步锁的代码块跟同步锁无关,会继续执行,没有影响
class service {
  public void fun1(){
    synchronized(this){
      try{
        thread.sleep(3*1000)
      }
      catch(exception e){
        system.out.println(e)
      }
      system.out.println("fun1")
    }
  }
  public void fun2(){
    synchronized(this){
      system.out.println("fun2")
    }
  }
}

class mythread1 implments runnable{
  private service service;

  public mythread1(service serivce){
    this.serivce = serivce;
  }
  public void run(){
    service.fun1();
  }
}

class mythread2 implments runnable{
  private service service;

  public mythread2(service serivce){
    this.serivce = serivce;
  }
  public void run(){
    service.fun2();
  }
}

class test{
  public static void main(string[] args){
    service service = new service();

    thread t1 = new thread(new mythread1(service));
    thread t2 = new thread(new mythread2(service));
  }
}

2.3. 同步方法

  • 同步方法锁住的是this
class service {
  // 同步方法只需要在方法名前加入synchronized即可
  public synchronized void fun1(){
    
      try{
        thread.sleep(3*1000)
      }
      catch(exception e){
        system.out.println(e)
      }
      system.out.println("fun1")
    
  }
  public void fun2(){
    synchronized(this){
      system.out.println("fun2")
    }
  }
}

3. java的数组和类集框架

  • 用于储存一些列相同数据类型的容器

3.1. 数组类型

  • 数组长度一旦声明,不可更改
class test{
  public static void main(string[] args){
    // 一维数组的静态声明法
    int[] arr = {1,2,5,7,8,10};
    arr[3] = 10; // 设置数组元素为新的值
    // 打印一维数组元素
    for (int  i=0; i<arr.length; i++){
      system.out.println(arr[i]);
    }
    // 一维数组的动态声明法  
    int[] arr = new int[10];  // 初始化为0
    // 二位数组的静态声明法
    int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
    arr[1][1];  // = 5
    // 二位数组的动态声明法
    int[][] arr = new int[3][5];
    
    // 打印二位数组
    for (int i=0; i<arr.length;i++){
      for (int j=0; i<arr[i].length; i++){
        system.out.println(arr[i][j]);
      }
    }
  }
}

3.2. java的类集框架

1. 类集框架的定义和种类,以及基础结构

  • 类集框架是一组类和结构,位于java.util包中,主要用于储存和管理对象,主要分为三大类:
    • 集合(set): 对象不按照特定的方式排序,并且没有重复对象
    • 列表(list): 对象按照索引位置排序,可以有重复对象
    • 映射(dictionary): 通过键-值对储存(key-value)

类集框架的主体结构

Java高级教程02

2. arraylist列表的使用

import java.util.list;
import java.util.arraylist;


public class test{
  public static void main(string[] args){
    // arraylist的长度可以自动扩展,跟数组有区别
    // 声明arraylist只能存string类型
    arraylist<string> arraylist = new arraylist<string>();
    // 向arraylist数组添加对象
    arraylist.add("a");
    arraylist.add("b");
    // 从arraylist取对象
    string s = arraylist.get(1);
    // 打印arraylist数据
    for(int i=0; i<arraylist.size(); i++){
      string s = arraylist.get(1);
      system.out.println(s);
    }
    // 删除arraylist数据 
    arraylist(1);
  }
}

3. collection和iterator接口

  • iterator最高层---hasnext() + next()
  • collection接口是iteator的子接口
  • set是collection接口的子接口
  • hashset是set的实现类
  • iterator <-- collection <-- set <-- hashset
  • iterator <-- collection <-- list <-- arraylist

    (1) collection接口

方法 含义
boolean add(object 0) 向集合添加对象
void clear() 删除集合的所有对象
boolean isempty() 判断集合是否为空
remove(object o) 从集合中删除一个对象的引用
int size() 返回集合中元素的数组

4.set和hashset用法(collection的实现类)

import java.util.set;
import java.util.hashset;

public class test{
  public static void main(string[] args){
    hashset<string> hashset = new hashset<string>();
    set<string> set = hashset;

    boolean b1 = set.isempty();  
    
    set.add("a");
    set.add("b");
    set.add("c");
    set.add("a"); // 重复元素会忽略

    int a = set.size();
    set.remove(a);
    set.clear();

    // 集合取数据---通过迭代器iterator
    // 调用set对象的iterator方法,会生成一个迭代器对象,该对象用于遍历整个set
    iterator<string> it = set.iterator();

    while(it.hasnext()){
      //取出元素,并将指针向后面挪一位
      string s = it.next();
      system.out.println(s);
    }

  }
}

5. map和hashmap的使用方法

  • map <-- hashmap
import java.util.map;
import java.util.hashmap;

public class test{
  public static void main(string[] args){
    // 创建hashmap对象,并定义键值对类型
    hashmap<string, string> hasmap = new hashmap<string, string>();
    map<string, string> map = hasmap;

    map.put("1","a");
    map.put("2","b");
    map.put("3","c");
    map.put("3","e");   // 将会覆盖上面的键值对

    int i = map.size();

    string s = map.get("3");

    
  }
}

4. equals函数的使用方法

4.1. equals的作用

==的作用:

  • 基本数据类型: 是否相等?
  • 引用数据类型: 是否指向堆内存的同一地址?
class user{
  string name;
  int age;
}

class test{
  public static void main(string[] args){
    user u1 = new user();
    user u2 = new user();
    user u3 = u1;

    boolean b1 = u1 == u2;  // false
    boolean b2 = u1 == u3;  // true
  }
}

eqauls的复写

  • 两个对象类型相同(使用instanceof来比较)
  • 两个对象的成员变量的值完全相同
class user{
  // string是引用数据类型
  string name;
  int age;

  public user(string name, int age){
    this.name = name;
    this.age = age;
  }

  public boolean equals(object obj){
    if(this == obj){
      return true;
    }
    if(obj instanceof user){
      user u = (user)obj;
      // 这里的equals是object的
      // equals用于比较内容是否相等
      if (this.age == u.age && this.name.equals(u.name)){
        return true;
      }
      else{
        return false;
      }
    }
    else{
      return false;
    }
  }
  
}

class test{
  public static void main(string[] args){
    user u1 = new user("zahng",12);
    user u2 = new user("liu",15);
    user u3 = new user("zahng",12);
    
    boolean b1 = u1.equals(u2);  // false
    boolean b2 = u1.equals(u3); // true
  }
}