Properties作为Map集合的使用、Properties作为Map集合的特有方法、Properties和IO流相结合的方法、游戏次数、设置和获取线程名称、线程优先级、线程控制、实现Runnabl

执。113

已于 2023-02-09 12:36:31 修改

阅读量773

点赞数

文章标签： java spring jvm

于 2022-10-29 20:06:28 首次发布

原文链接：https://www.bilibili.com/video/BV18J411W7cE/?p=320&spm_id_from=333.880.my_history.page.click&vd_source=591f7c6876df9fa8f96cf3ff23ab9290

版权

1、Properties作为Map集合的使用

package com.itheima_01;

/*
Properties
*/

import java.util.Properties;
import java.util.Set;

public class PropertiesDemo01 {
    public static void main(String[] args) {
        //创建集合对象
//        Properties<String,String> prop=new Properties<String,String>(); 写法错误 该类不是泛型类
        Properties prop=new Properties();

        //存储元素
        prop.put("itheima001","林青霞");
        prop.put("itheima002","张曼玉");
        prop.put("itheima003","王祖贤");

        //遍历集合
        Set<Object> keySet = prop.keySet();
        for (Object key:keySet){
            Object value = prop.get(key);
            System.out.println(key+","+value);
        }
    }
}

2、Properties作为Map集合的特有方法

package com.itheima_01;

/*
Properties作为集合的特有方法:
    Object setProperty(String key,String value):设置集合的键和值，都是string类型，底层调用Hoashtable方法put
    String getProperty( String key):使用此属性列表中指定的键搜索属性
    Set<String> stringPropertyNames():从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
*/

import java.util.Properties;
import java.util.Set;

public class PropertiesDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop=new Properties();

        //Object setProperty(String key,String value):设置集合的键和值，都是string类型，底层调用Hoashtable方法put
        prop.setProperty("itheima001","林青霞");
        /*
        Object setProperty(String key, String value) {
            return put(key, value);
        }

        Object put(Object key, Object value) {
            return map.put(key, value);
        }
         */
        prop.setProperty("itheima002","张曼玉");
        prop.setProperty("itheima003","王祖贤");

        //String getProperty( String key):使用此属性列表中指定的键搜索属性
//        System.out.println(prop.getProperty("itheima002"));
//        System.out.println(prop.getProperty("itheima0012"));

//        System.out.println(prop);

        //Set<String> stringPropertyNames():从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = prop.stringPropertyNames();
        for (String key:names){
//            System.out.println(key);
            String value = prop.getProperty(key);
            System.out.println(key+","+value);
        }
    }
}

3、Properties和IO流相结合的方法

package com.itheima_01;

/*
Properties和I0流结合的方法:
    void load( Reader reader):
        从输入字符流读取属性列表（键和元素对)

    void store(lwriter writer, String comments):
        将此属性列表（键和元素对)写入此Properties表中，以适合使用Load(Reader)方法的格式写入输出字符流
*/

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException{
        //从集合中的数据保存到文件
//        myStore();

        //把文件中的数据加载到集合
        myLoad();
        
    }

    private static void myLoad() throws IOException {
        Properties prop=new Properties();//创建集合对象

        FileReader fr=new FileReader("D:\\Java\\JavaSE\\fw.txt");
        prop.load(fr);
        fr.close();

        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop=new Properties();

        prop.setProperty("itheima001","林青霞");
        prop.setProperty("itheima002","张曼玉");
        prop.setProperty("itheima003","王祖贤");

        //void store(lwriter writer, String comments):字符串参数
        FileWriter fw=new FileWriter("D:\\Java\\JavaSE\\fw.txt");
        prop.store(fw,null);
        fw.close();

    }
}

4、游戏次数

package com.itheima_01;

/*
    需求:请写程序实现猜数字小游戏只能试玩3次，如果还想玩，提示:游戏试玩已结束，想玩请充值(ww..itcast.cn)

    思路:
        1:写一个游戏类,里面有一个猜数字的小游戏
        2:写一个测试类，测试类中有main方法，main()方法中按照下面步骤完成
            A:从文件中读取数据到Properties集合，用Load()方法实现
                文件已经存在:game.txt
                里面有一个数据值:count=0
            B:通过Properties集合获取到玩游戏的次数
            C:判断次数是否到到3次了
                如果到了，给出提示:游戏试玩已结束，想玩请充值(www.itcast.cn)
                如果不到3次:
                    玩游戏
                    次数+1，重新写回文件，用Properties的store()方法实现
*/

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class PropertiesText {
    public static void main(String[] args) throws IOException{
        //从文件中读取数据到Properties集合，用load()方法实现
        Properties prop=new Properties();

        FileReader fr=new FileReader("D:\\Java\\JavaSE\\game.txt");
        prop.load(fr);
        fr.close();

        //通过Properties集合获取到玩游戏的次数
        String count = prop.getProperty("count");
        int number=Integer.parseInt(count);

        //判断次数是否到达3次了
        if (number>=3){
            //如果到了，给出提示:游戏试玩已结束，想玩请充值(www.itcast.cn)
            System.out.println("游戏试玩已结束，想玩请充值(www.itcast.cn)");
        }else {
            //玩游戏
            GuessNumber.start();

            //次数+1，重新写回文件，用Properties的store()方法实现
            number++;
            prop.setProperty("count",String.valueOf(number));
            FileWriter fw=new FileWriter("D:\\Java\\JavaSE\\game.txt");//修改过的数据写回文件
            prop.store(fw,null);
            fw.close();
        }

    }
}

package com.itheima_01;

import java.util.Random;
import java.util.Scanner;

public class GuessNumber {
    private GuessNumber() {
    }

    public static void start(){//static修饰，可以通过类名访问
        //要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
        Random r=new Random();
        int number=r.nextInt(100)+1;

        while (true){
            //使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
            Scanner sc=new Scanner(System.in);

            System.out.println("请输入你要猜的数字：");
            int guessNumber= sc.nextInt();

            //比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if...else...if...格式，根据不同情况进行猜测结果显示
            if (guessNumber>number){
                System.out.println("你猜的数字"+guessNumber+"大了");
            } else if (guessNumber<number) {
                System.out.println("你猜的数字"+guessNumber+"小了");
            }else {
                System.out.println("恭喜你猜中了");
                break;
            }
        }
    }
}

5、继承Thread类的方式实现多线程

（1）为什么要重写run0方法?
因为run()是用来封装被线程执行的代码

（2）run)方法和start)方法的区别?
run():封装线程执行的代码，直接调用，相当于普通方法的调用start():启动线程;然后由JVM调用此线程的run(方法

package com.itheima_01;

/*
方式1:继承Thread类
    1:定义一个类MyThread继承Thread类
    2:在MyThread类中重写run()方法
    3:创建MyThread类的对象
    4:启动线程
*/

public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1=new MyThread();//创建对象
        MyThread my2=new MyThread();

//        my1.run();
//        my2.run(); 没有启动线程

        //void start ()导致此线程开始执行;Java虚拟机调用此线程的run方法
        my1.start();
        my2.start();
    }
}

package com.itheima_01;

/*
方式1:继承Thread类
    1:定义一个类MyThread继承Thread类
    2:在MyThread类中重写run()方法
    3:创建MyThread类的对象
    4:启动线程
*/

public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1=new MyThread();//创建对象
        MyThread my2=new MyThread();

//        my1.run();
//        my2.run(); 没有启动线程

        //void start ()导致此线程开始执行;Java虚拟机调用此线程的run方法
        my1.start();
        my2.start();
    }
}

6、设置和获取线程名称

（1）Thread类中设置和获取线程名称的方法
void setName(Stringname):将此线程的名称更改为等于参数

nameString getName0:返回此线程的名称
通过构造方法也可以设置线程名称

（2）如何获取main(方法所在的线程名称?
public static Thread currentThread):返回对当前正在执行的线程对象的引用

package com.itheima_01;

/*
Thread类中获取和设置线程名称的方法
    void setName(String name):将此线程的名称更改为等于参数
    nameString getName():返回此线程的名称
*/

public class MyThreadDemo {
    public static void main(String[] args) {
//        MyThread my1=new MyThread();//无参构造方法创建线程对象
//        MyThread my2=new MyThread();
//
//        //void setName(String name):将此线程的名称更改为等于参数
//        my1.setName("高铁");
//        my2.setName("飞机");
//

        //thread (String name)
//        MyThread my1=new MyThread("高铁");//无参构造方法创建线程对象
//        MyThread my2=new MyThread("飞机");
//
//        my1.start();
//        my2.start();

        //static Thread currentThread ()）返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());

    }
}

package com.itheima_01;

public class MyThread extends Thread{//子类无参构造方法默认访问父类无参构造方法

    public MyThread(){}

    public MyThread(String name){
        super(name);//传递
    }


    public void run(){
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

/*
private String name;

thread类的无参构造方法
public Thread() {
    this(null, null, "Thread-" + nextThreadNum(), 0);
}

public Thread(String name) {
    this(null, null, name, 0);
}

public Thread(ThreadGroup group, Runnable target, String name,
              long stackSize) {
    this(group, target, name, stackSize, null, true);
}

private Thread(ThreadGroup g, Runnable target, String name,
               long stackSize, AccessControlContext acc,
               boolean inheritThreadLocals){
    this.name = name;
}

public final synchronized void setName(String name) {
    this.name = name;
}

public final String getName() {
    return name;
}

private static int threadInitNumber; //0,1,2
private static synchronized int nextThreadNum() {
    return threadInitNumber++; //0,1,...
}
 */

7、线程优先级

（1）线程有两种调度模型
        分时调度模型:所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
        抢占式调度模型:优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些
        Java使用的是抢占式调度模型
（2）假如计算机只有一个CPU，那么CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的
（3）Thread类中设置和获取线程优先级的方法
        public final int getPriority():返回此线程的优先级
        public final void setPriority(int newPriority):更改此线程的优先级线程默认优先级是5;线程优先级的范围是:1-10
        线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

package com.itheima_01;

/*
Thread类中设置和获取线程优先级的方法
    public final void setPriority(int newPriority):更改此线程的优先级
    public final int getPriority():返回此线程的优先级
*/

public class ThreadPriorityDemo {
    public static void main(String[] args) {
        ThreadPriority tp1=new ThreadPriority();
        ThreadPriority tp2=new ThreadPriority();
        ThreadPriority tp3=new ThreadPriority();

        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");

        //public final int getPriority():返回此线程的优先级
//        System.out.println(tp1.getPriority());//5
//        System.out.println(tp2.getPriority());//5
//        System.out.println(tp3.getPriority());//5

        //public final void setPriority(int newPriority):更改此线程的优先级
//        tp1.setPriority(10000); //IllegalArgumentException
//        System.out.println(Thread.MAX_PRIORITY);//10最高
//        System.out.println(Thread.MIN_PRIORITY);//1最低
//        System.out.println(Thread.NORM_PRIORITY);//5默认

        //设置正确优先级
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);

        tp1.start();
        tp2.start();
        tp3.start();

    }
}

package com.itheima_01;

public class ThreadPriority extends Thread{

    public void run(){//重写方法
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

8、线程控制

（1）

package com.itheima_01;

public class ThreadDaemon extends Thread{
    public void run(){//重写方法
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);//获取线程名称
        }
    }
}

package com.itheima_01;

/*
void setDaemon (boolean on):将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
 */

public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1=new ThreadDaemon();
        ThreadDaemon td2=new ThreadDaemon();

        td1.setName("张飞");
        td2.setName("关羽");

        //设置主线程为刘备
        Thread.currentThread().setName("刘备");

        //主线程运行完毕，守护线程随即停止

        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);

        td1.start();
        td2.start();

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

}

（2）

package com.itheima_01;

public class TreadJoin extends Thread{
    public void run(){//重写方法
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);//获取线程名称
        }
    }
}

package com.itheima_01;

/*
void join()；等待这个线程死亡
 */
public class TreadJoinDemo {
    public static void main(String[] args) {
        TreadJoin tj1=new TreadJoin();
        TreadJoin tj2=new TreadJoin();
        TreadJoin tj3=new TreadJoin();

        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");

        tj1.start();
        try {
            tj1.join();//捕获异常
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        tj2.start();
        tj3.start();

    }
}

（3）

package com.itheima_01;

public class ThreadSleep extends Thread{
    public void run(){//重写方法
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);//获取线程名称
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

package com.itheima_01;

/*
static void sleep(long millis):使当前正在执行的线程停留（暂停执行）指定的毫秒数
*/

public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep tp1=new ThreadSleep();
        ThreadSleep tp2=new ThreadSleep();
        ThreadSleep tp3=new ThreadSleep();

        tp1.setName("曹操");
        tp2.setName("刘备");
        tp3.setName("孙权");

        tp1.start();
        tp2.start();
        tp3.start();

    }
}

9、实现Runnable接口的方式实现多线程

（1）方式2:实现Runnable接口
定义一个类MyRunnable实现Runnable接口

        在MyRunnable类中重写run(方法
        创建MyRunnable类的对象
        创建Thread类的对象，把MyRunnable对象作为构造方法的参数

启动线程
（2）多线程的实现方案有两种
继承Thread类

        实现Runnable接口
（3）相比继承Thread类，实现Runnable接口的好处
        避免了Java单继承的局限性
        适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离,
较好的体现了面向对象的设计思想

package com.itheima_01;

/*
方式2:实现Runnable接口
    1:定义一个类MyRunnable实现Runnable接口
    2:在MyRunnable类中重写run()方法
    3:创建MyRunnable类的对象
    4:创建Thread类的对象，把MyRunnable对象作为构造方法的参数
    5:启动线程
 */
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my=new MyRunnable();

        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread (Runnable target)
//        Thread t1=new Thread(my);
//        Thread t2=new Thread(my);
        //Thread (Runnable target,String name)

        Thread t1=new Thread(my,"高铁");
        Thread t2=new Thread(my,"飞机");

        //启动线程
        t1.start();
        t2.start();
    }
}

package com.itheima_01;

public class MyRunnable implements Runnable{
    public void run(){
        for (int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

10、卖票

package com.itheima_01;

//定义一个类SellTicket实现Runnable接口，里面定义一个成员变量n private int tickets = 100;
public class SellTicket implements Runnable{
    private int tickets=100;

    //在SellTicket类中重写run()方法实现卖票，代码步骤如下

    public void run(){
//        A;判断票数大于e。就卖票。并告知是哪个窗口卖的
//        B;卖了票之后，总票数要减1
//        C:票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
        while (true) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");//获取线程名称
                tickets--;
            }
        }
    }
}

package com.itheima_01;

/*
需求:
    某电影院目前正在上映国产大片，共有1ee张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
思路:
    1:定义一个类SellTicket实现Runnable接口，里面定义一个成员变量n private int tickets = 100;
    2:在SellTicket类中重写run()方法实现卖票，代码步骤如下
        A;判断票数大于e。就卖票。并告知是哪个窗口卖的
        B;卖了票之后，总票数要减1
        C:票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
    3:定义一个测试类SeLLTicketDemo，里面有main方法，代码步骤如下
        A:创建SeLLTichet类的对象
        B:创建三个Thread类的对象，把sellTicket对象作为构造方法的参数，并给出对应的窗口名称
        C:启动线程
 */
public class SellTicketDemo {
    public static void main(String[] args) {
        //创建SeLLTichet类的对象
        SellTicket st=new SellTicket();

        //创建三个Thread类的对象，把sellTicket对象作为构造方法的参数，并给出对应的窗口名称
        Thread t1=new Thread(st,"窗口1");
        Thread t2=new Thread(st,"窗口2");
        Thread t3=new Thread(st,"窗口3");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

执。113

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Properties作为Map集合的使用、Properties作为Map集合的特有方法、Properties和IO流相结合的方法、游戏次数、设置和获取线程名称、线程优先级、线程控制、实现Runnabl

Properties作为Map集合的使用、Properties作为Map集合的特有方法、Properties和IO流相结合的方法、游戏次数、设置和获取线程名称、线程优先、实现Runnable接口的方式实现多线程、卖票
复制链接

扫一扫