devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java学习笔记_java ww.getsignature(ticket)

作者：weixin_40725706 | 2024-03-07 20:00:45

赞

踩

java ww.getsignature(ticket)

 

 

 

  1. package demo1;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class HelloWorld {
  6.     public static void main(String[] args) {
  7.         Scanner sc =new Scanner(System.in);
  8.         int n=sc.nextInt();
  9.         System.out.println("hellowrold"+n);
  10.  
  11.     }
  12. }

 如果case==1则执行

 

end.foi == for(int i=0;i<end;i++)

arr.fori == for(int i=0;i<arr.lenght;i++)

 

 

 

 

 

输入字符· 

  1. import java.util.Scanner;
  2. Scanner scanner = new Scanner(System.in);
  3. char c = scanner.next().charAt(0);

判断字符串是否相同 

  1. String a=new String("abc"); 
  2. String b=new String("abc");
  3.  a.equals(b);

输入字符串

  1.    Scanner in = new Scanner(System.in);
  2.  
  3.         String s = in.nextLine();

  1. package com.itheima.test;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Test1 {
  6.     public static void main(String[] args) {
  7.        /* 机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
  8.         按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。*/
  9.  
  10.         //分析：
  11.         //1.键盘录入机票原价、月份、头等舱或经济舱
  12.         Scanner sc = new Scanner(System.in);
  13.         System.out.println("请输入机票的原价");
  14.         int ticket = sc.nextInt();
  15.         System.out.println("请输入当前的月份");
  16.         int month = sc.nextInt();
  17.         System.out.println("请输入当前购买的舱位 0 头等舱 1 经济舱");
  18.         int seat = sc.nextInt();
  19.         //2.先判断月份是旺季还是淡季
  20.         //ctrl + alt + M 自动抽取方法
  21.         if (month >= 5 && month <= 10) {
  22.             //旺季 //3.继续判断当前机票是经济舱还是头等舱
  23.             //ticket = getPrice(ticket, seat, 0.9, 0.85);
  24.             ticket = getTicket(ticket, seat, 0.9, 0.85);
  25.         } else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
  26.             //淡季
  27.             //ticket = getPrice(ticket, seat, 0.7, 0.65);
  28.             ticket = getTicket(ticket, seat, 0.7, 0.65);
  29.         } else {
  30.             //表示键盘录入的月份是一个非法数据
  31.             System.out.println("键盘录入的月份不合法");
  32.         }
  33.  
  34.         System.out.println(ticket);
  35.     }
  36.  
  37.     public static int getTicket(int ticket, int seat, double v, double v2) {
  38.         if (seat == 0) {
  39.             //头等舱
  40.             ticket = (int) (ticket * v);
  41.         } else if (seat == 1) {
  42.             //经济舱
  43.             ticket = (int) (ticket * v2);
  44.         } else {
  45.             System.out.println("没有这个舱位");
  46.         }
  47.         return ticket;
  48.     }
  49.  
  50.     //1.我要干嘛？根据舱位和折扣来计算最终的票价
  51.     //2.我干这件事，需要什么才能完成？原价 舱位 头等舱的折扣 经济舱的折扣
  52.     //3.方法的调用处是否需要继续使用这个结果  需要
  53.   /*  public static int getPrice(int ticket, int seat, double v0, double v1) {
  54.         if (seat == 0) {
  55.             //头等舱
  56.             ticket = (int) (ticket * v0);
  57.         } else if (seat == 1) {
  58.             //经济舱
  59.             ticket = (int) (ticket * v1);
  60.         } else {
  61.             System.out.println("没有这个舱位");
  62.         }
  63.         return ticket;
  64.     }*/
  65. }
  1. package com.itheima.test;
  2.  
  3. import java.util.Random;
  4.  
  5. public class Test3 {
  6.     public static void main(String[] args) {
  7.      /*   需求：
  8.             定义方法实现随机产生一个5位的验证码
  9.             验证码格式：
  10.             长度为5
  11.             前四位是大写字母或者小写字母
  12.             最后一位是数字
  13.      */
  14.  
  15.         //方法：
  16.         //在以后如果我们要在一堆没有什么规律的数据中随机抽取
  17.         //可以先把这些数据放到数组当中
  18.         //再随机抽取一个索引
  19.  
  20.         //分析：
  21.         //1.大写字母和小写字母都放到数组当中
  22.         char[] chs = new char[52];
  23.         for (int i = 0; i < chs.length; i++) {
  24.             //ASCII码表
  25.             if(i <= 25){
  26.                 //添加小写字母
  27.                 chs[i] = (char)(97 + i);
  28.             }else{//27
  29.                 //添加大写字母
  30.                 // A --- 65
  31.                 chs[i] = (char)(65 + i - 26);
  32.             }
  33.         }
  34.  
  35.         //定义一个字符串类型的变量，用来记录最终的结果
  36.         String result = "";
  37.  
  38.         //2.随机抽取4次
  39.         //随机抽取数组中的索引
  40.         Random r = new Random();
  41.         for (int i = 0; i < 4; i++) {
  42.             int randomIndex = r.nextInt(chs.length);
  43.             //利用随机索引，获取对应的元素
  44.             //System.out.println(chs[randomIndex]);
  45.             result = result + chs[randomIndex];
  46.         }
  47.         //System.out.println(result);
  48.         //3.随机抽取一个数字0~9
  49.         int number = r.nextInt(10);
  50.         //生成最终的结果
  51.         result = result + number;
  52.  
  53.         //打印最终结果
  54.         System.out.println(result);
  55.  
  56.     }
  57. }

shift + f6 改一堆

  1. package com.itheima.test;
  2.  
  3. import java.util.Random;
  4.  
  5. public class Test9 {
  6.     public static void main(String[] args) {
  7.        /* 需求：
  8.         一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。
  9.         请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
  10.         打印效果如下：（随机顺序，不一定是下面的顺序）
  11.             888元的奖金被抽出
  12.             588元的奖金被抽出
  13.             10000元的奖金被抽出
  14.             1000元的奖金被抽出
  15.             2元的奖金被抽出
  16.         */
  17.  
  18.  
  19.         //分析：
  20.         //1.定义数组表示奖池
  21.         int[] arr = {2, 588, 888, 1000, 10000};
  22.         //2.定义新数组用于存储抽奖的结果
  23.         int[] newArr = new int[arr.length];
  24.         //3.抽奖
  25.         Random r = new Random();
  26.         //因为有5个奖项，所以这里要循环5次
  27.         for (int i = 0; i < 5; ) {
  28.             //获取随机索引
  29.             int randomIndex = r.nextInt(arr.length);
  30.             //获取奖项
  31.             int prize = arr[randomIndex];
  32.             //判断当前的奖项是否存在，如果存在则重新抽取，如果不存在，就表示是有效奖项
  33.             boolean flag = contains(newArr, prize);
  34.             if(!flag){
  35.                 //把当前抽取到的奖项添加到newArr当中
  36.                 newArr[i] = prize;
  37.                 //添加完毕之后，移动索引
  38.                 i++;
  39.             }
  40.         }
  41.         //4.遍历newArr
  42.         for (int i = 0; i < newArr.length; i++) {
  43.             System.out.println(newArr[i]);
  44.         }
  45.  
  46.  
  47.     }
  48.  
  49.     //判断prize在数组当中是否存在
  50.     //存在：true
  51.     //不存在：false
  52.     public static boolean contains(int[] arr,int prize){
  53.         for (int i = 0; i < arr.length; i++) {
  54.             if(arr[i] == prize){
  55.                 return true;
  56.             }
  57.         }
  58.         return false;
  59.     }
  60.  
  61.  
  62. }

  1. package com.itheima.test;
  2.  
  3. import java.util.Random;
  4.  
  5. public class Test10 {
  6.     public static void main(String[] args) {
  7.        /* 需求：
  8.         一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。
  9.         请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
  10.         打印效果如下：（随机顺序，不一定是下面的顺序）
  11.             888元的奖金被抽出
  12.             588元的奖金被抽出
  13.             10000元的奖金被抽出
  14.             1000元的奖金被抽出
  15.             2元的奖金被抽出
  16.         */
  17.  
  18.         //1.把奖池里面的所有奖项打乱顺序
  19.         int[] arr = {2, 588, 888, 1000, 10000};
  20.         Random r = new Random();
  21.         for (int i = 0; i < arr.length; i++) {
  22.             //获取随机索引
  23.             int randomIndex = r.nextInt(arr.length);
  24.             //拿着i跟随机索引randomIndex上的值进行交换
  25.             int temp = arr[i];
  26.             arr[i] = arr[randomIndex];
  27.             arr[randomIndex] = temp;
  28.         }
  29.         //2.遍历奖池,从0索引开始获取每一个奖项
  30.         for (int i = 0; i < arr.length; i++) {
  31.             System.out.println(arr[i]);
  32.         }
  33.  
  34.  
  35.     }
  36. }

  1. package com.itheima.test;
  2.  
  3. import java.util.Random;
  4. import java.util.Scanner;
  5.  
  6. public class Test11 {
  7.     public static void main(String[] args) {
  8.         //1.生成中奖号码
  9.         int[] arr = createNumber(); // 123456  7
  10.  
  11.         System.out.println("=======================");
  12.         for (int i = 0; i < arr.length; i++) {
  13.             System.out.print(arr[i] + " ");
  14.         }
  15.  
  16.         System.out.println("=======================");
  17.  
  18.  
  19.  
  20.         //2.用户输入彩票号码（红球 + 蓝球）//654321
  21.         int[] userInputArr = userInputNumber();
  22.  
  23.         //3.判断用户的中奖情况
  24.         //红球 蓝球
  25.         int redCount = 0;
  26.         int blueCount = 0;
  27.  
  28.         //判断红球
  29.         for (int i = 0; i < userInputArr.length - 1; i++) {
  30.             int redNumber = userInputArr[i];
  31.             for (int j = 0; j < arr.length - 1; j++) {
  32.                 if(redNumber == arr[j]){
  33.                     redCount++;
  34.                     //如果找到了，那么后面的数字就没有必要继续比较了
  35.                     //跳出内循环，继续判断下一个红球号码是否中奖
  36.                     break;
  37.                 }
  38.             }
  39.         }
  40.  
  41.         //判断蓝球
  42.         int blueNumber = userInputArr[userInputArr.length-1];
  43.         if(blueNumber == arr[arr.length - 1]){
  44.             blueCount++;
  45.         }
  46.  
  47.        //根据红球的个数以及蓝球的个数来判断中奖情况
  48.         if(redCount == 6 && blueCount == 1){
  49.             System.out.println("恭喜你，中奖1000万");
  50.         }else if(redCount == 6 && blueCount == 0){
  51.             System.out.println("恭喜你，中奖500万");
  52.         }else if(redCount == 5 && blueCount == 1){
  53.             System.out.println("恭喜你，中奖3000");
  54.         }else if((redCount == 5 && blueCount == 0) ||  (redCount == 4 && blueCount == 1)){
  55.             System.out.println("恭喜你，中奖200");
  56.         }else if((redCount == 4 && blueCount == 0) ||  (redCount == 3 && blueCount == 1)){
  57.             System.out.println("恭喜你，中奖10");
  58.         }else if((redCount == 2 && blueCount == 1) ||  (redCount == 1 && blueCount == 1)|| (redCount == 0 && blueCount == 1)){
  59.             System.out.println("恭喜你，中奖5");
  60.         }else{
  61.             System.out.println("谢谢参与，谢谢惠顾");
  62.         }
  63.  
  64.     }
  65.  
  66.     public static int[] userInputNumber() {
  67.         //1.创建数组用于添加用户购买的彩票号码
  68.         //6个红球 1个蓝球 数组长度：7
  69.         int[] arr = new int[7];
  70.  
  71.         //2.利用键盘录入让用输入
  72.         Scanner sc = new Scanner(System.in);
  73.         //让用户输入红球号码
  74.         for (int i = 0; i < 6; ) {
  75.             System.out.println("请输入第" + (i + 1) + "个红球号码");
  76.             int redNumber = sc.nextInt();
  77.             //redNumber  在1~33  唯一不重复
  78.             if (redNumber >= 1 && redNumber <= 33) {
  79.                 boolean flag = contains(arr, redNumber);
  80.                 if (!flag) {
  81.                     //不存在
  82.                     //有效的，可以添加到数组当中
  83.                     arr[i] = redNumber;
  84.                     i++;
  85.                 } else {
  86.                     //存在
  87.                     System.out.println("当前红球号码已经存在，请重新输入");
  88.                 }
  89.             } else {
  90.                 System.out.println("当前红球号码超出范围");
  91.             }
  92.         }
  93.  
  94.         //让用户输入篮球号码
  95.         System.out.println("请输入篮球号码");
  96.         //1~16
  97.         while (true) {
  98.             int blueNumber = sc.nextInt();
  99.             if (blueNumber >= 1 && blueNumber <= 16) {
  100.                 arr[arr.length - 1] = blueNumber;
  101.                 break;
  102.             } else {
  103.                 System.out.println("当前篮球号码超出范围");
  104.             }
  105.         }
  106.         return arr;
  107.  
  108.     }
  109.  
  110.  
  111.     public static int[] createNumber() {
  112.         //1.创建数组用于添加中奖号码
  113.         //6个红球 1个蓝球 数组长度：7
  114.         int[] arr = new int[7];
  115.  
  116.         //2.随机生成号码并添加到数组当中
  117.         //红球：不能重复的  1 2 3 4 5 6
  118.         //蓝球：可以跟红球号码重复 5
  119.  
  120.         //生成红球号码并添加到数组当中
  121.         Random r = new Random();
  122.         for (int i = 0; i < 6; ) {
  123.             //获取红球号码
  124.             int redNumber = r.nextInt(33) + 1;
  125.             boolean flag = contains(arr, redNumber);
  126.             if (!flag) {
  127.                 //把红球号码添加到数组当中
  128.                 arr[i] = redNumber;
  129.                 i++;
  130.             }
  131.         }
  132.  
  133.         //生成蓝球号码并添加到数组当中
  134.         int blueNumber = r.nextInt(16) + 1;
  135.         arr[arr.length - 1] = blueNumber;
  136.         return arr;
  137.     }
  138.  
  139.     //用于判断数组在数组中是否存在
  140.     public static boolean contains(int[] arr, int number) {
  141.         for (int i = 0; i < arr.length; i++) {
  142.             if (arr[i] == number) {
  143.                 return true;
  144.             }
  145.         }
  146.         return false;
  147.     }
  148. }

System.arraycopy(a, 2, b, 1, 3);

从a的第二个元素开始（从1开始），复制长度为3个元素到从b的第1个位置之后（从0开始）

按鼠标滚轮快塑选取

alt +fn +insert生成构造函数

 两下tab一次回车 默认构造             全选全参构造

第4个函数

使用ptg to javabean

按shift+下选择，tab跳过选择 

ctrl+p方法参数 

 

 

 ctrl+B查看

.forr倒着遍历

  1. package com.itheima.stringdemo;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class StringDemo9 {
  6.     public static void main(String[] args) {
  7.         //1.键盘录入一个金额
  8.         Scanner sc = new Scanner(System.in);
  9.         int money;
  10.         while (true) {
  11.             System.out.println("请录入一个金额");
  12.             money = sc.nextInt();
  13.             if (money >= 0 && money <= 9999999) {
  14.                 break;
  15.             } else {
  16.                 System.out.println("金额无效");
  17.             }
  18.         }
  19.  
  20.         //定义一个变量用来表示钱的大写
  21.         String moneyStr = "";
  22.  
  23.         //2.得到money里面的每一位数字,再转成中文
  24.         while (true) {//2135
  25.             //从右往左获取数据，因为右侧是数据的个位
  26.             int ge = money % 10;
  27.             String capitalNumber = getCapitalNumber(ge);
  28.             //把转换之后的大写拼接到moneyStr当中
  29.             moneyStr = capitalNumber + moneyStr;
  30.             //第一次循环 ： "伍" + "" = "伍"
  31.             //第二次循环 ： "叁" + "伍" = "叁伍"
  32.             //去掉刚刚获取的数据
  33.             money = money / 10;
  34.  
  35.             //如果数字上的每一位全部获取到了，那么money记录的就是0，此时循环结束
  36.             if (money == 0) {
  37.                 break;
  38.             }
  39.         }
  40.  
  41.         //3.在前面补0，补齐7位
  42.         int count = 7 - moneyStr.length();
  43.         for (int i = 0; i < count; i++) {
  44.             moneyStr = "零" + moneyStr;
  45.         }
  46.         System.out.println(moneyStr);//零零零贰壹叁伍
  47.  
  48.         //4.插入单位
  49.         //定义一个数组表示单位
  50.         String[] arr = {"佰","拾","万","仟","佰","拾","元"};
  51.         //               零    零   零   贰   壹   叁   伍
  52.  
  53.         //遍历moneyStr，依次得到 零    零   零   贰   壹   叁   伍
  54.         //然后把arr的单位插入进去
  55.  
  56.         String result = "";
  57.         for (int i = 0; i < moneyStr.length(); i++) {
  58.             char c = moneyStr.charAt(i);
  59.             //把大写数字和单位拼接到result当中
  60.             result = result + c + arr[i];
  61.         }
  62.  
  63.         //5.打印最终结果
  64.         System.out.println(result);
  65.  
  66.     }
  67.  
  68.  
  69.     //定义一个方法把数字变成大写的中文
  70.     //1 -- 壹
  71.     public static String getCapitalNumber(int number) {
  72.         //定义数组，让数字跟大写的中文产生一个对应关系
  73.         String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
  74.         //返回结果
  75.         return arr[number];
  76.     }
  77.  
  78. }

 

 

 

  1. package com.itheima.stringbuilderdemo;
  2.  
  3. public class StringBuilderDemo7 {
  4.     public static void main(String[] args) {
  5.         //1.定义数组
  6.         int[] arr = {1,2,3};
  7.  
  8.         //2.调用方法把数组变成字符串
  9.         String str = arrToString(arr);
  10.  
  11.         System.out.println(str);
  12.  
  13.     }
  14.  
  15.  
  16.     public static String arrToString(int[] arr){
  17.         StringBuilder sb = new StringBuilder();
  18.         sb.append("[");
  19.  
  20.         for (int i = 0; i < arr.length; i++) {
  21.             if(i == arr.length - 1){
  22.                 sb.append(arr[i]);
  23.             }else{
  24.                 sb.append(arr[i]).append(", ");
  25.             }
  26.         }
  27.         sb.append("]");
  28.  
  29.         return sb.toString();
  30.     }
  31. }

ctrl +L+T 给一段代码加循环

  1. package com.itheima.test;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Test1Case2 {
  6.     public static void main(String[] args) {
  7.        /* 键盘录入一个字符串，
  8.         要求1：长度为小于等于9
  9.         要求2：只能是数字
  10.                 将内容变成罗马数字
  11.         下面是阿拉伯数字跟罗马数字的对比关系：
  12.         Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
  13.         注意点：
  14.         罗马数字里面是没有0的
  15.         如果键盘录入的数字包含0，可以变成""(长度为0的字符串)*/
  16.  
  17.  
  18.         //1.键盘录入一个字符串
  19.         //书写Scanner的代码
  20.         Scanner sc = new Scanner(System.in);
  21.         String str;
  22.         while (true) {
  23.             System.out.println("请输入一个字符串");
  24.             str = sc.next();
  25.             //2.校验字符串是否满足规则
  26.             boolean flag = checkStr(str);
  27.             if (flag) {
  28.                 break;
  29.             } else {
  30.                 System.out.println("当前的字符串不符合规则，请重新输入");
  31.                 continue;
  32.             }
  33.         }
  34.  
  35.         //将内容变成罗马数字
  36.         //下面是阿拉伯数字跟罗马数字的对比关系：
  37.         //Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
  38.         //查表法：数字跟数据产生一个对应关系
  39.         StringBuilder sb = new StringBuilder();
  40.         for (int i = 0; i < str.length(); i++) {
  41.             char c = str.charAt(i);
  42.             String s = changeLuoMa(c);
  43.             sb.append(s);
  44.         }
  45.  
  46.         System.out.println(sb);
  47.  
  48.     }
  49.  
  50.     //利用switch进行匹配
  51.     public static String changeLuoMa(char number) {
  52.         String str = switch (number) {
  53.             case '0' -> "";
  54.             case '1' -> "Ⅰ";
  55.             case '2' -> "Ⅱ";
  56.             case '3' -> "Ⅲ";
  57.             case '4' -> "Ⅳ";
  58.             case '5' -> "Ⅴ";
  59.             case '6' -> "Ⅵ";
  60.             case '7' -> "Ⅶ";
  61.             case '8' -> "Ⅷ";
  62.             case '9' -> "Ⅸ";
  63.             default -> str = "";
  64.         };
  65.         return str;
  66.     }
  67.  
  68.  
  69.     public static boolean checkStr(String str) {//123456
  70.         //要求1：长度为小于等于9
  71.         if (str.length() > 9) {
  72.             return false;
  73.         }
  74.  
  75.         //要求2：只能是数字
  76.         for (int i = 0; i < str.length(); i++) {
  77.             char c = str.charAt(i);//0~9
  78.             if (c < '0' || c > '9') {
  79.                 return false;
  80.             }
  81.         }
  82.  
  83.         //只有当字符串里面所有的字符全都判断完毕了，我才能认为当前的字符串是符合规则
  84.         return true;
  85.     }
  86.  
  87.  
  88. }

  1. package com.itheima.test;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Test1Case1 {
  6.     public static void main(String[] args) {
  7.        /* 键盘录入一个字符串，
  8.         要求1：长度为小于等于9
  9.         要求2：只能是数字
  10.                 将内容变成罗马数字
  11.         下面是阿拉伯数字跟罗马数字的对比关系：
  12.         Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
  13.         注意点：
  14.         罗马数字里面是没有0的
  15.         如果键盘录入的数字包含0，可以变成""(长度为0的字符串)*/
  16.  
  17.  
  18.         //1.键盘录入一个字符串
  19.         //书写Scanner的代码
  20.         Scanner sc = new Scanner(System.in);
  21.         String str;
  22.         while (true) {
  23.             System.out.println("请输入一个字符串");
  24.             str = sc.next();
  25.             //2.校验字符串是否满足规则
  26.             boolean flag = checkStr(str);
  27.             if (flag) {
  28.                 break;
  29.             } else {
  30.                 System.out.println("当前的字符串不符合规则，请重新输入");
  31.                 continue;
  32.             }
  33.         }
  34.  
  35.         //将内容变成罗马数字
  36.         //下面是阿拉伯数字跟罗马数字的对比关系：
  37.         //Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
  38.         //查表法：数字跟数据产生一个对应关系
  39.         StringBuilder sb = new StringBuilder();
  40.         for (int i = 0; i < str.length(); i++) {
  41.             char c = str.charAt(i);
  42.             int number = c - 48; // 1 2 3 4 5
  43.             String s = changeLuoMa(number);
  44.             sb.append(s);
  45.         }
  46.  
  47.         System.out.println(sb);
  48.  
  49.     }
  50.  
  51.     public static String changeLuoMa(int number) {
  52.         //定义一个数组，让索引跟罗马数字产生一个对应关系
  53.         String[] arr = {"", "Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ"};
  54.         return arr[number];
  55.  
  56.     }
  57.  
  58.  
  59.     public static boolean checkStr(String str) {//123456
  60.         //要求1：长度为小于等于9
  61.         if (str.length() > 9) {
  62.             return false;
  63.         }
  64.  
  65.         //要求2：只能是数字
  66.         for (int i = 0; i < str.length(); i++) {
  67.             char c = str.charAt(i);//0~9
  68.             if (c < '0' || c > '9') {
  69.                 return false;
  70.             }
  71.         }
  72.  
  73.         //只有当字符串里面所有的字符全都判断完毕了，我才能认为当前的字符串是符合规则
  74.         return true;
  75.     }
  76.  
  77.  
  78. }

字符反转：

  1. package com.itheima.test;
  2.  
  3. public class Test2Case1 {
  4.     public static void main(String[] args) {
  5.        /* 给定两个字符串, A和B。
  6.         A的旋转操作就是将A 最左边的字符移动到最右边。
  7.         例如, 若A = 'abcde'，在移动一次之后结果就是'bcdea'
  8.         如果在若干次调整操作之后，A能变成B，那么返回True。
  9.         如果不能匹配成功，则返回false*/
  10.  
  11.         //1.定义两个字符串
  12.         String strA = "abcde";
  13.         String strB = "ABC";
  14.  
  15.  
  16.         //2.调用方法进行比较
  17.         boolean result = check(strA, strB);
  18.  
  19.         //3.输出
  20.         System.out.println(result);
  21.  
  22.  
  23.     }
  24.  
  25.     public static boolean check(String strA, String strB) {
  26.         for (int i = 0; i < strA.length(); i++) {
  27.             strA = rotate(strA);
  28.             if(strA.equals(strB)){
  29.                 return true;
  30.             }
  31.         }
  32.         //所有的情况都比较完毕了，还不一样那么直接返回false
  33.         return false;
  34.     }
  35.  
  36.  
  37.     //作用：旋转字符串，把左侧的字符移动到右侧去
  38.     //形参：旋转前的字符串
  39.     //返回值：旋转后的字符串
  40.     public static String rotate(String str) {
  41.         //套路：
  42.         //如果我们看到要修改字符串的内容
  43.         //可以有两个办法：
  44.         //1.用subString进行截取，把左边的字符截取出来拼接到右侧去
  45.         //2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。
  46.  
  47.  
  48.         //截取思路
  49.         //获取最左侧那个字符
  50.         char first = str.charAt(0);
  51.         //获取剩余的字符
  52.         String end = str.substring(1);
  53.  
  54.         return end + first;
  55.     }
  56. }
  1. package com.itheima.test;
  2.  
  3. public class Test2Case2 {
  4.     public static void main(String[] args) {
  5.        /* 给定两个字符串, A和B。
  6.         A的旋转操作就是将A 最左边的字符移动到最右边。
  7.         例如, 若A = 'abcde'，在移动一次之后结果就是'bcdea'
  8.         如果在若干次调整操作之后，A能变成B，那么返回True。
  9.         如果不能匹配成功，则返回false*/
  10.  
  11.         //1.定义两个字符串
  12.         String strA = "abcde";
  13.         String strB = "ABC";
  14.  
  15.  
  16.         //2.调用方法进行比较
  17.         boolean result = check(strA, strB);
  18.  
  19.         //3.输出
  20.         System.out.println(result);
  21.  
  22.  
  23.     }
  24.  
  25.     public static boolean check(String strA, String strB) {
  26.         for (int i = 0; i < strA.length(); i++) {
  27.             strA = rotate(strA);
  28.             if (strA.equals(strB)) {
  29.                 return true;
  30.             }
  31.         }
  32.         //所有的情况都比较完毕了，还不一样那么直接返回false
  33.         return false;
  34.     }
  35.  
  36.  
  37.     //作用：旋转字符串，把左侧的字符移动到右侧去
  38.     //形参：旋转前的字符串
  39.     //返回值：旋转后的字符串
  40.     public static String rotate(String str) {
  41.         //套路：
  42.         //如果我们看到要修改字符串的内容
  43.         //可以有两个办法：
  44.         //1.用subString进行截取，把左边的字符截取出来拼接到右侧去
  45.         //2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。
  46.  
  47.         //可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。
  48.  
  49.  
  50.         //"ABC"   ['A','B','C']  ['B','C','A']   new String(字符数组);
  51.         char[] arr = str.toCharArray();
  52.         //拿到0索引上的字符
  53.         char first = arr[0];
  54.         //把剩余的字符依次往前挪一个位置
  55.         for (int i = 1; i < arr.length; i++) {
  56.             arr[i - 1] = arr[i];
  57.         }
  58.         //把原来0索引上的字符放到最后一个索引
  59.         arr[arr.length - 1] = first;
  60.  
  61.         //利用字符数组创建一个字符串对象
  62.         String result = new String(arr);
  63.         return result;
  64.     }
  65. }

  1. package com.itheima.listdemo;
  2.  
  3.  
  4. import java.util.ArrayList;
  5.  
  6. /*
  7.     boolean add(E e)        添加
  9.     boolean remove(E e)     删除
  10.     E remove(int index)
  12.     E set(int index,E e)    修改
  14.     E get(int index)        查询
  15.     int size()              获取长度
  17.  */
  18. public class ArrayListDemo2 {
  19.     public static void main(String[] args) {
  20.  
  21.         //1.创建一个集合
  22.         ArrayList<String> list = new ArrayList<>();
  23.  
  24.         //2.添加元素
  25.         list.add("aaa");
  26.         list.add("aaa");
  27.         list.add("bbb");
  28.         list.add("ccc");
  29.  
  30.  
  31.         //3.删除元素
  32.       /*  boolean result1 = list.remove("aaa");
  33.         System.out.println(result1);
  35.         boolean result2 = list.remove("ddd");
  36.         System.out.println(result2);
  38.         String str = list.remove(2);
  39.         System.out.println(str);*/
  40.  
  41.  
  42.         //修改元素
  43.         /*String result = list.set(1, "ddd");
  44.         System.out.println(result);*/
  45.  
  46.         //查询元素
  47.        /* String s = list.get(0);
  48.         System.out.println(s);*/
  49.  
  50.         //遍历
  51.         for (int i = 0; i < list.size(); i++) {
  52.             //i 索引
  53.             //list.get(i) 元素
  54.             String str = list.get(i);
  55.             System.out.println(str);
  56.         }
  57.  
  58.  
  59.  
  60.     }
  61. }

学生对象：

  1. package com.itheima.test;
  2.  
  3. public class Student {
  4.     //1.私有化成员变量
  5.     //2.空参构造方法
  6.     //3.带全部参数的构造方法
  7.     //4.get/set方法
  8.  
  9.     private String name;
  10.     private int age;
  11.  
  12.     public Student() {
  13.     }
  14.  
  15.     public Student(String name, int age) {
  16.         this.name = name;
  17.         this.age = age;
  18.     }
  19.  
  20.  
  21.     public String getName() {
  22.         return name;
  23.     }
  24.  
  25.     public void setName(String name) {
  26.         this.name = name;
  27.     }
  28.  
  29.     public int getAge() {
  30.         return age;
  31.     }
  32.  
  33.     public void setAge(int age) {
  34.         this.age = age;
  35.     }
  36. }
  1. package com.itheima.test;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Scanner;
  5.  
  6. public class Test5 {
  7.     public static void main(String[] args) {
  8.         //1.创建集合
  9.         ArrayList<Student> list = new ArrayList<>();
  10.         //长度为0
  11.         //2.键盘录入学生的信息并添加到集合当中
  12.         Scanner sc = new Scanner(System.in);
  13.         Student s = new Student();
  14.         for (int i = 0; i < 3; i++) {
  15.             System.out.println("请输入学生的姓名");
  16.             String name = sc.next();
  17.             System.out.println("请输入学生的年龄");
  18.             int age = sc.nextInt();
  19.  
  20.             //把name和age赋值给学生对象
  21.             s.setName(name);
  22.             s.setAge(age);
  23.  
  24.             //把学生对象添加到集合当中
  25.             list.add(s);
  26.         }
  27.         //3.遍历
  28.         for (int i = 0; i < list.size(); i++) {
  29.             //i 索引 list.get(i) 元素/学生对象
  30.             Student stu = list.get(i);
  31.             System.out.println(stu.getName() + ", " + stu.getAge());
  32.         }
  33.     }
  34. }

ctrl +p 提示

查找用户：

  1. package OOPtext;
  2.  
  3. import java.util.ArrayList;
  4.  
  5. public class Text6 {
  6.     public static void main(String[] args) {
  7.         //1.创建集合
  8.         ArrayList<User> list = new ArrayList<>();
  9.  
  10.         //2.创建三个用户对象
  11.         User u1 = new User("heima001","zhangsan","123456");
  12.         User u2 = new User("heima002","lisi","12345678");
  13.         User u3 = new User("heima003","wangwu","1234qwer");
  14.  
  15.         //3.把用户对象添加到集合当中
  16.         list.add(u1);
  17.         list.add(u2);
  18.         list.add(u3);
  19.  
  20.         //4.调用方法查看id是否存在
  21.         boolean flag = contains(list, "heima0010");
  22.  
  23.         //5.打印结果
  24.         System.out.println(flag);
  25.  
  26.     }
  27.  
  28.     //1.我要干嘛？   根据id查找用户
  29.     //2.我干这件事需要什么才能完成？   list  id
  30.     //3.调用处是否需要使用方法的结果？ 返回
  31.     public static boolean contains(ArrayList<User> list, String id){
  32.        /* for (int i = 0; i < list.size(); i++) {
  33.             User u = list.get(i);
  34.             String uid = u.getId();
  35.             if(uid.equals(id)){
  36.                 //如果找到了直接返回true
  37.                 return true;
  38.             }
  39.         }
  40.         //当循环结束表示集合里面所有的元素都已经比较完毕，还没有一样的，那么返回false就可以了
  41.         return false;*/
  42.  
  43.         return getIndex(list,id) >= 0;
  44.  
  45.     }
  46.  
  47.  
  48.     public static int getIndex(ArrayList<User> list, String id) {
  49.         for (int i = 0; i < list.size(); i++) {
  50.             User u = list.get(i);
  51.             String uid = u.getId();
  52.             if(uid.equals(id)){
  53.                 return i;
  54.             }
  55.         }
  56.  
  57.         return -1;
  58.     }
  59. }

  1. package OOPtext;
  2.  
  3. public class User {
  4.     private String id;
  5.     private String username;
  6.     private String password;
  7.  
  8.  
  9.     public User() {
  10.     }
  11.  
  12.     public User(String id, String username, String password) {
  13.         this.id = id;
  14.         this.username = username;
  15.         this.password = password;
  16.     }
  17.  
  18.     public String getId() {
  19.         return id;
  20.     }
  21.  
  22.     public void setId(String id) {
  23.         this.id = id;
  24.     }
  25.  
  26.     public String getUsername() {
  27.         return username;
  28.     }
  29.  
  30.     public void setUsername(String username) {
  31.         this.username = username;
  32.     }
  33.  
  34.     public String getPassword() {
  35.         return password;
  36.     }
  37.  
  38.     public void setPassword(String password) {
  39.         this.password = password;
  40.     }
  41.  
  42. }

 手机查询：

  1. package com.itheima.test;
  2.  
  3. public class Phone {
  4.     //Phone属性：品牌，价格。
  5.     private String brand;
  6.     private int price;
  7.  
  8.     public Phone() {
  9.     }
  10.  
  11.  
  12.     public Phone(String brand, int price) {
  13.         this.brand = brand;
  14.         this.price = price;
  15.     }
  16.  
  17.     public String getBrand() {
  18.         return brand;
  19.     }
  20.  
  21.     public void setBrand(String brand) {
  22.         this.brand = brand;
  23.     }
  24.  
  25.     public int getPrice() {
  26.         return price;
  27.     }
  28.  
  29.     public void setPrice(int price) {
  30.         this.price = price;
  31.     }
  32. }
  1. package com.itheima.test;
  2.  
  3.  
  4. /*
  5. 需求：
  6.         定义Javabean类：Phone
  7.         Phone属性：品牌，价格。
  8.         main方法中定义一个集合，存入三个手机对象。
  9.         分别为：小米，1000。苹果，8000。锤子 2999。
  10.         定义一个方法，将价格低于3000的手机信息返回。
  11. */
  12.  
  13. import java.util.ArrayList;
  14.  
  15. public class Test8 {
  16.     public static void main(String[] args) {
  17.  
  18.         //1.创建集合对象
  19.         ArrayList<Phone> list = new ArrayList<>();
  20.  
  21.         //2.创建手机的对象
  22.         Phone p1 = new Phone("小米",1000);
  23.         Phone p2 = new Phone("苹果",8000);
  24.         Phone p3 = new Phone("锤子",2999);
  25.  
  26.         //3.添加数据
  27.         list.add(p1);
  28.         list.add(p2);
  29.         list.add(p3);
  30.  
  31.         //4.调用方法
  32.         ArrayList<Phone> phoneInfoList = getPhoneInfo(list);
  33.  
  34.         //5.遍历集合
  35.         for (int i = 0; i < phoneInfoList.size(); i++) {
  36.             Phone phone = phoneInfoList.get(i);
  37.             System.out.println(phone.getBrand() + ", " + phone.getPrice());
  38.         }
  39.  
  40.     }
  41.  
  42.  
  43.     //1.我要干嘛？ 查询手机信息
  44.     //2.我干这件事情，需要什么才能完成？  集合
  45.     //3.我干完了，方法的调用处是否需要继续使用结果？  返回
  46.  
  47.     //技巧：
  48.     //如果我们要返回多个数据，可以把这些数据先放到一个容器当中，再把容器返回
  49.     //集合 数组
  50.     public static ArrayList<Phone> getPhoneInfo(ArrayList<Phone> list){
  51.         //定义一个集合用于存储价格低于3000的手机对象
  52.         ArrayList<Phone> resultList = new ArrayList<>();
  53.         //遍历集合
  54.         for (int i = 0; i < list.size(); i++) {
  55.             Phone p = list.get(i);
  56.             int price = p.getPrice();
  57.             //如果当前手机的价格低于3000，那么就把手机对象添加到resultList中
  58.             if(price < 3000){
  59.                 resultList.add(p);
  60.             }
  61.         }
  62.         //返回resultList
  63.         return resultList;
  64.  
  65.     }
  66.  
  67.  
  68.  
  69. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/207286
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号