Java抱佛脚做练习（一）

最新推荐文章于 2022-07-16 07:57:59 发布

何亚告

最新推荐文章于 2022-07-16 07:57:59 发布

阅读量1.3k

点赞数 2

分类专栏：菜鸟日常 java 文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_44229840/article/details/106504983

版权

菜鸟日常同时被 2 个专栏收录

30 篇文章 4 订阅

订阅专栏

java

6 篇文章 0 订阅

订阅专栏

1.创建两个线程，与主线程交替运行,输出1-60的数字，并显示每个线程的名称

public class Test6 implements Runnable {
    @Override
    public void run() {
        for(int i=1;i<61;i++){
            System.out.println(Thread.currentThread().getName()+"--------"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Test6 td = new Test6();
        Thread t1 = new Thread(td,"线程1");
        Thread t2 = new Thread(td,"线程2");
        t1.start();
        t2.start();
        for(int i=1;i<61;i++) {
            System.out.println(Thread.currentThread().getName() + "-"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Thread.currentThread():
(参考：https://www.cnblogs.com/FlyAway2013/p/7527916.html）
Thread.currentThread() 返回的是一个实例。只不过呢，这个实例确实比较特殊。这个实例是当前Thread 的引用。

Thread.currentThread()与this的区别
在线程的run 方法内部， Thread.currentThread()与this 其实是一个意思（除非你手动执行run方法，而不是通过启动线程的方式）。不过呢，其他的某些方法或场合，却可能出现不一致。
一般来说，Thread.currentThread() 用于不方便使用this 的场合。 Thread.currentThread() 明确表明了它所针对的对象是当前线程！不是this！当然，如果碰巧this 就是当前线程，那也是没毛病的。

Thread.sleep()
(参考：https://blog.csdn.net/Weixiaohuai/article/details/83994146）

Thread.sleep()是Thread类的一个静态方法，使当前线程休眠，进入阻塞状态（暂停执行），如果线程在睡眠状态被中断，将会抛出IterruptedException中断异常。。主要方法如下：
sleep(long millis) 线程睡眠 millis 毫秒
sleep(long millis, int nanos) 线程睡眠 millis 毫秒 + nanos 纳秒

Thread.start()
(参考：https://baijiahao.baidu.com/s?id=1624067920453033349&wfr=spider&for=pc）

1.Java中的start()方法是什么？线程类的start()方法可以用来启动线程；该方法会在内部调用Runnable接口的run()方法，以在单独的线程中执行run()方法中指定的代码。start()方法启动线程执行以下任务：
1.1 它统计了一个新线程
1.2线程从New State移动到Runnable状态。
1.3 当线程有机会执行时，它的目标run()方法将运行。
2.Java中的run()方法是什么？线程类的run()方法是Runnable接口的一个抽象方法，由java虚拟机直接调用的，不会创建的新线程。

2.使用多线程，模拟龟兔赛跑的场景
（感觉跟第一题大同小异，不过多线程应该就考这么难）
（参考：https://blog.csdn.net/weixin_43895377/article/details/89923825）

class RabbitAndTurtle extends Thread {
     public int distance = 100;
     static boolean flag = true;
     public int predistance = 0;
     @Override
     public void run() {
         double ran = Math.random();
         String name = Thread.currentThread().getName();
        while (flag){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            if (name.equals("乌龟")) {
                if (Math.random() < 1) {
                    predistance += 1;
                    System.out.println(name + "我跑了：" + predistance + "米");
                    if (predistance == 100) {
                        System.out.println("=================乌龟赢了=================");
                        flag = false;
                        break;
                    }
                }
                try {
                    sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (name.equals("兔子")) {
                if (Math.random() < 0.3) {
                    predistance += 2;
                    System.out.println(name + "我跑了：" + predistance + "米");
                    if (predistance == 100) {
                        System.out.println("=================兔子赢了=================");
                        flag = false;
                        break;
                    }
                }
            }
            try {
                sleep(200);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
     }
 }
public class Test3 {
    public static void main(String[] args) {
        Thread rabbit = new RabbitAndTurtle();
        Thread turtle = new RabbitAndTurtle();
        rabbit.setName("兔子");
        turtle.setName("乌龟");
        rabbit.start();
        turtle.start();
    }
}

（我动手能力好弱啊明明换汤不换药的题加一点内容我就不会了）

3.有如下Student 对象，
private String name;
private int age;
private int score;
private String classNum
;其中，classNum 表示学生的班号，例如“class05”。
有如下ListList list = new ArrayList();
list.add(new Student(“Tom”, 18, 100, “class05”));
list.add(new Student(“Jerry”, 22, 70, “class04”));
list.add(new Student(“Owen”, 25, 90, “class05”));
list.add(new Student(“Jim”, 30,80 , “class05”));
list.add(new Student(“Steve”, 28, 66, “class06”));
list.add(new Student(“Kevin”, 24, 100, “class04”));
在这个list 的基础上，完成下列要求：
1）计算所有学生的平均年龄
2）计算各个班级的平均分
3）把集合类型换成HashSet,如果名字和年龄相同就认为是同一个人。

import java.util.ArrayList;
import java.util.List;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.Objects;
 class Student  implements Comparable<Student> {
     String name;
     int age;
     int score;
    String classNum;
   public Student(String name, int age, int score, String classNum){
       this.name=name;
       this.age=age;
       this.score=score;
       this.classNum=classNum;
   }
   public String toString() {
       return "Student{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", score=" + score +
               ", classNum=" + classNum +
               '}';
   }
   public int hashCode() {
       return Objects.hash(name, age);
   }
   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Student student = (Student) o;
       return age == student.age &&
             Objects.equals(name, student.name);
   }
   @Override
   public int compareTo(Student o) {
       int num=o.name.compareTo(name);
       if(num==0){
           num=age-o.age;
       }
       return num;
   }
}
  public class Test1{
    public static void main(String[] args){
        List<Student> list=new ArrayList<>();
        list.add(new Student("Tom",18,100,"class05"));
        list.add(new Student("Jerry",22,70,"class04"));
        list.add(new Student("Owen",25,90,"class05"));
        list.add(new Student("Steve",30,80,"class05"));
        list.add(new Student("Kevin",28,66,"class06"));
        list.add(new Student("Tom",18,100,"class05"));
        //第一问
        int sum=0;
        for(Student stu:list){
            sum+=stu.age;
        }
        System.out.println("平均年龄是："+sum/list.size());
        //第二问
        int sumscore04=0;
        int sumscore05=0;
        int sumscore06=0;
        int sumstu04=0;
        int sumstu05=0;
        int sumstu06=0;
        for(Student stu:list){
         if(stu.classNum.equals("class04")) {
          sumscore04+=stu.score;
          sumstu04++;
         }
         else if(stu.classNum.equals("class05")) {
          sumscore05+=stu.score;
          sumstu05++;
         }
         else if(stu.classNum.equals("class06")) {
          sumscore06+=stu.score;
          sumstu06++;
         }
        }
        System.out.println("四班平均分是："+sumscore04/sumstu04);
     System.out.println("五班平均分是："+sumscore05/sumstu05);
     System.out.println("六班平均分是："+sumscore06/sumstu06);
       //第三问
    Set<Student> set1 = new HashSet<>();
    Student s1=new Student("Tom",18,100,"class05");
    Student s2=new Student("Jerry",22,70,"class04");
    Student s3=new Student("Owen",25,90,"class05");
    Student s4=new Student("Steve",30,80,"class05");
    Student s5=new Student("Kevin",28,66,"class06");
    Student s6=new Student("Tom",18,100,"class05");
    set1.add(s1);
    set1.add(s2);
    set1.add(s3);
    set1.add(s4);
    set1.add(s5);
    set1.add(s6);
    Iterator<Student> it = set1.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
    }
  }

输出：

平均年龄是：23
四班平均分是：70
五班平均分是：92
六班平均分是：66
Student{name='Jerry', age=22, score=70, classNum=class04}
Student{name='Tom', age=18, score=100, classNum=class05}
Student{name='Steve', age=30, score=80, classNum=class05}
Student{name='Owen', age=25, score=90, classNum=class05}
Student{name='Kevin', age=28, score=66, classNum=class06}

4、import java.util.*;
public class TestList{
public static void main(String args[]){
List list = new ArrayList();
list.add(“Hello”);
list.add(“World”);
list.add(1,“Learn”);
list.add(1,“Java”);
printList(list);
}
public static void printList(List list){
System.out.println(“方式一：”);
Iterator iterator = list.iterator();
//1 要求输出 list 中所有元素的内容
（）
System.out.println("\n方式二：");
for(String obj: list){
System.out.print(obj+" “);
}
System.out.println(”\n方式三：");
for(int i = 0; i < list.size(); i++){
System.out.print(list.get(i)+" ");
}
}}
要求：I. 把//1 处的代码补充完整，要求输出 list 中所有元素的内容
II. 写出程序执行的结果

import java.util.*;
public class Test1 {
 public static void main(String args[]){
     List<String> list = new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add(1,"Learn");
     list.add(1,"Java");
     printList(list);
 }
 public static void printList(List<String> list){
        System.out.println("方式一：");
     Iterator iterator = list.iterator();
  //1 要求输出 list 中所有元素的内容
   while(iterator.hasNext()) {
    System.out.print(iterator.next()+" ");
   }
     System.out.println("\n方式二：");
     for(String obj: list){
         System.out.print(obj+" ");
     }
     System.out.println("\n方式三：");
     for(int i = 0; i < list.size(); i++){
         System.out.print(list.get(i)+" ");
     }
 }
 }

输出：

方式一：
Hello Java Learn World 
方式二：
Hello Java Learn World 
方式三：
Hello Java Learn World

5.（线程的创建）有以下代码
public class Example implements Runnable {
public void run() {
while(true) {
}
}
public static void main(String args[]) {
Example ex1 = new Example();
Example ex2 = new Example();
Example ex3 = new Example();
ex1.run();
ex2.run();
ex3.run();
}
}
选择正确答案：
A. 代码编译失败，因为ex2.run()无法获得执行
B. 代码编译成功，存在3 个可运行的线程
C. 代码编译成功，存在1 个可运行的线程
（这题不会）
问了老师，发现这题我稳稳地掉进陷阱
首先，这一题只有一个main线程，ex1.run()只是调用了run方法，线程的开启还是需要start，而且无论如何，请不要忘记main线程！
选C
（这题发现我对线程的理解还是应考，没有理解原理）

6、（线程的创建）有以下代码
class Example implements Runnable {
public static void main(String args[]) {
Thread t = new Thread(new Example());
t.start();
}
public void run(int limit) {
for (int x = 0; x<limit; x++) {
System.out.println(x);
}
}
}
选择正确答案：
A. 打印输出，从0 至limit
B. 无内容输出，因为没有明确调用run()方法。
C. 代码编译失败，因为没有正确实现Runnable 接口
D. 代码编译失败，如果声明类为抽象类，可使代码编译成功。
E. 代码编译失败，如果去掉implements Runnable，可使代码编译成功。
选C
尝试了一下，的确编译通不过，我理解的原因是，由于定义类的时候实现了Runaanle接口，但是没有实现这个接口中的方法这个方法应该是run(),是不带参的。

7、（sleep 方法）有如下代码
class Example {
public static void main(String args[]) {
Thread.sleep(3000);
System.out.println(“sleep”);
}
}
选择正确答案：
A. 编译出错
B. 运行时异常
C. 正常编译运行，输出sleep
D. 正常编译运行，但没有内容输出
选A
在用sleep总伴随着异常抛出

try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

或者

throws InterruptedException

8、（线程的创建）有如下代码
class Example extends Thread {
public void run() {
System.out.println(“Running”);
System.out.println(“Done”);
}
private void xxx() {
System.out.println(“In xxx”);
}
public static void main(String args[]){
Example ttt = new Example();
ttt.start();
ttt.xxx();
}
}
以上代码是否会打印“In xxx”？

In xxx
Running
Done

（不要忘了主函数的线程！）
（我的理解是主函数中创建从线程，start()后调用run()方法，而主函数的线程调用写在主函数中的方法，这里的.xxx()方法被主函数调用；）

9、（线程的创建）创建两个线程，要求如下：
1）一个线程输出100 个1~26，另一个线程输出100 个A~Z
2）一个线程使用集成Thread 类的写法，另一个线程使用实现Runnable 接口的写法。

class T1 extends Thread  {
 String name=Thread.currentThread().getName();
      public void run() {
        for(int i=1;i<=100;i++) {
         for(int j=1;j<=26;j++) {
          System.out.println(j);
          try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
         }
        } 
        }
      }
 class T2 implements Runnable{
  public void run(){
       for(int i=1;i<=100;i++) {
        for(char ss=65;ss<=90;ss++) {
         System.out.println((char)ss);
         try {
                     Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
        } 
  }
  }
 }
      public class Test6{
      public static void main(String[] args) {
       T1 xx=new T1();
       xx.name="线程1";
       T2 yy=new T2();
          Thread t2 = new Thread(yy,"线程2");
          xx.start();
          t2.start();     
      }
     }

（啊！我这凌乱的括号！）

（线程状态）有如下代码
class MyThread extends Thread{
public void run(){
for(int i = 0; i<100; i++){
System.out.println(“$$$”);
}
}
}public class TestMyThread{
public static void main(String args[]){
Thread t = new MyThread();
t.start();
t.start();
t.start();
}
}选择正确答案：
A. 编译出错
B. 编译正常，运行时有错
C. 编译运行都无错误，产生1 个线程
D. 编译运行都无错误，产生3 个线程

Exception in thread "main" java.lang.IllegalThreadStateException
 at java.lang.Thread.start(Unknown Source)
 at Test7.main(Test7.java:17)
$$$
$$$
$$$
$$$
$$$
$$$

（多次start()同一个线程，导致出错）

何亚告

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Java抱佛脚做练习（一）

1.创建两个线程，与主线程交替运行,输出1-60的数字，并显示每个线程的名称public class Test6 implements Runnable { @Override public void run() { for(int i=1;i<61;i++){ System.out.println(Thread.currentThread().getName()+"--------"+i); try {
复制链接

扫一扫