投稿
  1. 首页
  2. java

实验九 Java 常用类库的应用

code • 2022-5-1 • java • 阅读 28

实验九 Java 常用类库的应用,第1张

实验九 Java 常用类库的应用

一、实验目的

1、掌握StringBuffer 与String 的区别。

2、掌握日期 *** 作类。

3、掌握比较器及其基本原理。

二、实验学时

2 学时

三、实验类型

验证性实验

四、实验需求 1、硬件

每位学生配备计算机一台

2、软件

Windows XP *** 作系统，JDK，eclipse，MySQL

3、网络无

4、工具无

五、实验理论与预备知识

1、泛型编程。

2、Java 常用类库。

六、实验内容与结果

1、定义一个StringBuffer 方法对象，然后通过append()方法向对象中添加 26 个小写字母，要求每次只添加一次，共添加 26 次，然后按照逆序的方式输出，并且可以删除前 5 个字符。

  1. public class Main{
  2.  public static void main(String[] args) {
  3.   StringBuffer sBuffer = new StringBuffer(26);
  4.   for(char i='a';i<='z';i++) {
  5.    sBuffer.append(i);
  6.   }
  7.   sBuffer.delete(0, 5);//删除前5个
  8.   sBuffer.reverse();//反转
  9.   System.out.println(sBuffer.toString());
  10.  }
  11. }

2、利用Random 类产生 5 个 1~30 之间（包括 1 和 30）的随机整数。

  1. import java.util.Random;
  3. public class Main{
  4.  public static void main(String[] args) {
  5.   Random ran = new Random();
  6.   for (int i = 0; i < 5; i++) {
  7.    System.out.println(ran.nextInt(30)+1);//ran.nextInt(30)是【0,30）；
  8.   }
  9.  }
  10. }

3、输入一个Email 地址，然后使用正则表达式验证该Email 地址是否正确。

  1. import java.util.Scanner;
  2. import java.util.regex.Matcher;
  3. import java.util.regex.Pattern;
  5. public class Main{
  6.  public static void main(String[] args) {
  7.   while(true){
  8.  Scanner sc = new Scanner(System.in);
  9.  String a=sc.nextLine();
  10.  String regex="[\w!#$%&'*+/=?^_`{|}~-]+(?:\.[\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?";
  11.  Pattern compile = Pattern.compile(regex);
  12.  Matcher matcher = compile.matcher(a);
  13.  boolean b=matcher.matches();
  14.  System.out.println(b);
  15.   }
  16.  }
  17. }

4、编写程序，用 0~1 之间的随机数来模拟扔硬币实验，统计扔 1000 次后出现正反面的次数并输出。

  1. import java.util.Random;
  3. public class Main{
  4.  public static void main(String[] args) {
  5.   int count=0;
  6.   Random ran=new Random();
  7.   for(int i=0;i<1000;i++) {
  8.    int a=ran.nextInt(2);
  9.    if(a==1) {
  10.     count++;//1正面
  11.    }else {
  12.     
  13.    }
  14.   }
  15.   int b=1000-count;
  16.   System.out.println("正面次数"+count+",反面次数"+b);
  17.  }
  18. }

5、按照“姓名：年龄：成绩|姓名：年龄：成绩”的格式定义字符串“张三：21:98|李四：22:89| 王五：20:70”，要求将每组值分别保存在 Student 对象之中，并对这些对象进行排序，排序的原则为：按照成绩由高到低排序，如果成绩相等，则按照年龄由低到高排序。

Student类：


  1. class Student implements Comparable<Student>{
  2.   private String name;
  3.   private int age;
  4.   private double score;
  5.   public Student(String name,int age,double score) {
  6.    this.name = name;
  7.    this.age = age;
  8.    this.score = score;
  9.  }
  10.  @Override
  11.  public int compareTo(Student s) {//调用sort ；会按照1大于， -1 小于 ，0等于； 默认升序排序 
  12.   if(this.score
  13.    return 1;// 分数低 1 往后排
  14.   }else if (this.score>s.score) {
  15.    return -1;// 分数高 -1往前排
  16.   }else {      
  17.     if (this.age
  18.      return -1;//年龄小 -1 往前排
  19.     }else if (this.age>s.age) {
  20.      return 1;//年龄大 1 往后排
  21.     }else {
  22.      return 0;
  23.     }
  24.     //return this.age - s.age;
  25.   }
  26.  }
  27.  @Override
  28.  public String toString() {
  29.   return "姓名：" + this.name + "、年龄：" + this.age + "、成绩：" + this.score + "\n";
  30.  }
  31.  public String getName() {
  32.   return name;
  33.  }
  34.  public void setName(String name) {
  35.   this.name = name;
  36.  }
  37.  public int getAge() {
  38.   return age;
  39.  }
  40.  public void setAge(int age) {
  41.   this.age = age;
  42.  }
  43.  public double getScore() {
  44.   return score;
  45.  }
  46.  public void setScore(double score) {
  47.   this.score = score;
  48.  }
  49.  
  50.  
  51. }

Main类:

  1. import java.util.Arrays;
  3. public class Main{
  4.  public static void main(String[] args) {
  5.   String a="张三：21：98|李四：22：98|王五：20：70";//这里全部是中文冒号;为了体现成绩相同时的排序，把李四成绩改成了98
  6.   String b[]=a.split("\|");//这个参数是正则；\|提示转义字符无效。
  7.   Student stu[] = new Student[b.length];
  8.   for(int i=0;i
  9.    String c[] = b[i].split("：");
  10.    stu[i] = new Student(c[0],Integer.parseInt(c[1]),Double.parseDouble(c[2]));   
  11.   }
  12.   Arrays.sort(stu);
  13.   for(Student element:stu)
  14.   System.out.println(element.toString());
  15.   //System.out.println(Arrays.toString(stu));
  16.  }
  17. }

Ps: (2条消息) java正则为什么要两个斜杆_Blaze Jack的博客-CSDN博客_java 字符串双斜杠

6、给定下面的 HTML 代码：

要求对内容进行拆分，拆分之后的结果是：

Face Arial Serif size +2

color red


  1. import java.util.regex.Matcher;
  2. import java.util.regex.Pattern;
  4. public class Demo {
  5.  public static void main(String[] args) {
  6.   String str = "";//"号需要用转义字符\
  7.   String regex = "\w+=\"[a-zA-Z0-9,\+]+\"";
  8.   //java正则中 得用两个\表示\  所以
  9.   //所以这个正则实际上是：\w+="[a-zA-Z0-9,\+]+"
  10.   Pattern pat = Pattern.compile(regex);
  11.   Matcher matcher = pat.matcher(str);
  12.   /*find()方法在部分匹配时和完全匹配时返回true,匹配不上返回false;
  13.          *matches()方法只有在完全匹配时返回true,匹配不上和部分匹配都返回false。
  14.          *1.如果连续调用find方法，后面的find会从前面匹配到的位置继续开始find，而不是从头开始匹配；
  15.          *2.通过reset 会设置find的位置为起始位
  16.    * group(),start(),end()所带的参数i就是正则表达式中的子表达式索引（第几个子表达式），由于刚开始对Java正则表达式中的组的概念不清晰，导致理解困难。当将“组”的概念与“子表达式”对应起来之后，理解matcher的group,start,end就完全没有障碍了。
  17.    *group 0是获取匹配的整个字符串
  18.    *group 1是第一个括号匹配的字符串
  19.          *group 2是第二个括号匹配的字符串 .....以此类推
  20.    */
  21.   while(matcher.find()) {//循环
  22.    String temp = matcher.group(0);
  23.    String result [] = temp.split("=") ;
  24.    System.out.println(result[0] + "\t" + result[1].replaceAll("\"",""));//result[0]是等号左边，result[1]是等号右边 把"号去掉
  25.    //1)replace的参数是char和CharSequence，即可以支持字符的替换，也支持字符串的替换(CharSequence即字符串序列的意思,说白了也就是字符串)；
  26.             //2)replaceAll的参数是regex，即基于正则表达式的替换，比如，可以通过replaceAll("\d", "*")把一个字符串所有的数字字符都换成星号;
  27.   }
  28.  }

 

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/757763.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-01
下一篇 2022-05-01

发表评论

登录后才能评论

评论列表（0条）

保存