21天打卡掌握java基础操作

Java安装环境变量配置-day1

参考：
https://www.runoob.com/w3cnote/windows10-java-setup.html
在这里插入图片描述
生成class文件

java21天打卡-day2

输入和输出
题目：设计一个程序，输入上次考试成绩（int）和本次考试成绩（int），然后输出成绩提高的百分比，保留两位小数位。
import java.util.Scanner;

public class HelloWorld{
public static void main(String[] args) {
//System.out.println(“HelloWorld”);
Scanner scan = new Scanner(System.in);
System.out.println(“输出上次成绩”);
float s1 = scan.nextFloat();
System.out.println(“输入本次成绩”);
float s2 = scan.nextFloat();

    System.out.println(s1 + " " + s2);
    float f = (s2 - s1) / s2 * 100;
    String status = f >= 0 ? "提高" : "降低";
    System.out.printf("本次成绩与上次成绩相比, %s了 %.2f%%", status, f);
}

}
在这里插入图片描述

Java21天打卡Day5-ifelse

在这里插入图片描述

import java.util.Scanner;

public class Day5 {
    public static void main(String[] args) {
        //输入考试成绩，如果成绩大于80，打印“优秀”，如果成绩大于60，打印“及格”，，如果成绩小于60，打印“不及格”

     Scanner scan = new Scanner(System.in);
     System.out.println("请输入考试成绩");
     float a = scan.nextFloat();
     if (a>=80){
         System.out.println("优秀");
     }
     else if (a>=60){
         System.out.println("及格");
        }
     else
         System.out.println("不及格");
    }
}

Java21天打卡Day6-switch

import java.util.Scanner;

public class Day6 {
    //switch case语句
    //题目：输入一个号码，判断该号码，是1就是一等奖，2是二等奖，3是三等奖，其他的阳光普照奖
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        System.out.println("请输入一个号码");
        int a=in.nextInt();
        switch (a){
            case 1:
                System.out.println("一等奖");
                break;
            case 2:
                System.out.println("二等奖");
                break;
            case 3:
                System.out.println("三等奖");
            default:
                System.out.println("阳光普照奖");
        }

    }
}

在这里插入图片描述

Java21天打卡Day7-循环

public class Day7 {
    //循环语句
    //while
    //do while
    //for
    //题目1：求1-100之和
    //题目2:嵌套循环：在控制台输出九九乘法表
    public static void main(String[] args){
        int sum=0;
        for(int i=1;i<=100;i++){
            sum=sum+i;
        }
        System.out.println("1-100的和是"+sum);
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+j*i+" ");//print可以输出不换行
            }
            System.out.println();//i循环结束后换行
//

        }

    }

}

在这里插入图片描述

Java21天打卡Day8-break

break和continue

break：表示跳出当前层循环
continue：表示跳出本次循环，进入下一次循环

import com.sun.org.apache.xerces.internal.util.SynchronizedSymbolTable;

public class Day8 {
    //21天Java打卡，第1期8天0815
    //
    //break和continue
    //
    //break：表示跳出当前层循环
    //continue：表示跳出本次循环，进入下一次循环
    //题目1：从1-10之中，当执行第5次时，打印“第五次执行完毕，退出循环”

    public static void main(String[] args){
        for(int i=1;i<11;i++){
            System.out.println(i);
            if(i==5){
            System.out.println("第五次执行完毕，退出循环");
            break;}

        }
    }
}

题目2: for (int i = 0; i < 10; i++) {

if (i == 3) {
continue;
}
System.out.println("num is: " + i);
}执行该代码块，打印输出内容是？输出0到9 除了3

在这里插入图片描述

java21天打卡-Day9 字符串

字符串1：
1、定义一个字符串
2、获取字符串的长度
3、字符串的拼接，在定义一个字符串，把两个字符串连起来
4、字符串大小写转换
5、去出字符串的空格

public class Day9 {
    public static void main(String[] args){
//        字符串1：
//        1、定义一个字符串
//        2、获取字符串的长度
//        3、字符串的拼接，在定义一个字符串，把两个字符串连起来
//        4、字符串大小写转换
//        5、去出字符串的空格 trim()
        String s="hello world";
        System.out.println("字符串的长度是"+s.length());
        String s2=s+"你好";
        System.out.println("拼接后的字符串是"+s2);
        System.out.println("字符串转换为大写"+s.toUpperCase());
        System.out.println("去除空格后的字符串是"+s.trim());

    }
}

java21天打卡 day10-字符串2

字符串2:
1、截取子字符串
1)取从第三个字符开始到最后
2)取第二到第四个字符
2、分割字符串

public class Day10 {
    public static void main(String[] args){
        //字符串2:
        //1、截取子字符串
        //1)取从第三个字符开始到最后 注意index是2
        //参考 http://c.biancheng.net/view/830.html
        //2)取第二到第四个字符
        //2、分割字符串
        //参考 http://c.biancheng.net/view/5807.html
        String s="hello world";
        System.out.println(s.substring(2));
        System.out.println(s.substring(1,4));
        String[] a=s.split(" ");//参数为分隔符 这里是按照空格分割
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }

    }
}

在这里插入图片描述

Java21天打卡Day11-字符串3

public class Day11 {
    public static void main(String[] args){
        //1、字符的替换
        //2、字符串的查找
        String s="hello world";
        System.out.println("l第一次出现的位置是"+s.indexOf("l"));
        String a=s.replace("l","m");
        System.out.println("替换后的字符串是"+a);
        System.out.println("原字符串是"+s);//可见原字符串没变
    }
}

在这里插入图片描述

Java21天打卡day16-类1

public class Person {
    String Name;
    int Age;
    String Sex;

    public void setName(String name) {
        Name = name;
    }

    public void setAge(int age) {
        Age = age;
    }

    public void setSex(String sex) {
        Sex = sex;
    }

    public String getName() {
        return Name;
    }

    public int getAge() {
        return Age;
    }

    public String getSex() {
        return Sex;
    }
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("zhangsan");
        p.setAge(20);
        p.setSex("男");

        System.out.print(p.getName() +","+ p.getAge()+"," + p.getSex());
    }


}

set和get方法都是类的方法
main方法也在类中。

java21天打卡Day12-IO流

IO流
构造file对象

File f=new File(“…\report.log”);
System.out.println(f.getPath()); //传参的路径 …\report.log
System.out.println(f.getAbsolutePath()); //绝对路径 E:\git\06team…\report.log
System.out.println(f.getCanonicalPath()); //和绝对路径类似，但是是规范路径 E:\git\report.log
创建和删除文件

f.createNewFile()
f.delete();
判断是否有这个文件

System.out.println(f.isFile());
遍历文件和目录

File[] fs1=f.listFiles();  //目录下所有的文件和子目录
if(fs1!=null){
        for(File f1:fs1){
            System.out.println(f1);
        }

题目1：打开本地的一个文件，并把文件内容打印出来
方法一：
try {
BufferedReader in = new BufferedReader(new FileReader(“e://report.log”));
String str;
while ((str = in.readLine()) != null) {
System.out.println(str);
}
System.out.println(str);
} catch (IOException e) {
System.out.println(e);
}
在这里插入图片描述

方法二：
InputStream input=null;
try {
input= new FileInputStream(“e://report.log”);
InputStreamReader reader = new InputStreamReader(input,“utf-8”);
int n;
while ((n = reader.read()) != -1) { // 利用while同时读取并判断
System.out.print((char)n);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (input != null) { input.close(); }

import java.io.*;

public class Day13 {
public static void main(String[] args){
String path=“C:\Users\Administrator\Desktop\helloworld.txt”;
InputStream input=null;
try {
input= new FileInputStream(path);
InputStreamReader reader = new InputStreamReader(input,“utf-8”);
int n;
while ((n = reader.read()) != -1) { // 利用while同时读取并判断
System.out.print((char)n);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (java.io.IOException e2){e2.printStackTrace();
}
// finally {
// if (input != null) { input.close(); }
// }
}
}

题目2：复制一个文件到另一个文件中

 public static void copy(String f1, String f2) throws IOException {
        File file = new File(f2);
        if(!file.exists()){
            file.createNewFile();
        }
        InputStream input=new FileInputStream(f1);
        OutputStream out=new FileOutputStream(f2);
        int n;
        while ((n=input.read())!=-1){
            out.write(n);
            System.out.println(n);
        }
        input.close();
        out.close();
    }

在这里插入图片描述
会在给的f2路径生成文件，并复制f1路径文件的内容。

java21天打卡Day13-正则表达式

java21天打卡Day13-正则表达式
20/100
发布文章
seanyang_
未选择文件
在这里插入图片描述
原来正则表达式是这样用的

在这里插入图片描述
原来正则表达式是这样用的
在这里插入图片描述

java21天打卡-day14 日期时间

import java.util.Calendar;
import java.util.Date;

public class Day14 {
    //数字和日期
    //Date
    //题目1：分别打印出当前时间所属的年月日
    //
    //Calendar类
    //题目2：计算出当前时间的年月日，时分秒，星期几，本月的第几周，本周的第几天
    //
    //题目3:计算出5天之后的日期
    public static void main(String[] args){
        Date d=new Date();
        System.out.println(d);
        System.out.println(d.getYear()+1900); //getYear()返回的年份必须加上1900
        System.out.println(d.getMonth()+1); //，getMonth()返回的月份是0~11分别表示1~12月，所以要加1
        System.out.println(d.getDate()); //而getDate()返回的日期范围是1~31，又不能加1。

        Calendar calendar = Calendar.getInstance(); // 如果不设置时间，则默认为当前时间
        calendar.setTime(new Date()); // 将系统当前时间赋值给 Calendar 对象
        System.out.println("现在时刻：" + calendar.getTime()); // 获取当前时间
        int year = calendar.get(Calendar.YEAR); // 获取当前年份
        System.out.println("现在是" + year + "年");

        int month = calendar.get(Calendar.MONTH) + 1; // 获取当前月份（月份从 0 开始，所以加 1）
        System.out.print(month + "月");

        int day = calendar.get(Calendar.DATE); // 获取日
        System.out.print(day + "日");

        int week = calendar.get(Calendar.DAY_OF_WEEK) - 1; // 获取今天星期几（以星期日为第一天）
        System.out.print("星期" + week);

        int hour = calendar.get(Calendar.HOUR_OF_DAY); // 获取当前小时数（24 小时制）
        System.out.print(hour + "时");

        int minute = calendar.get(Calendar.MINUTE); // 获取当前分钟
        System.out.print(minute + "分");

        int second = calendar.get(Calendar.SECOND); // 获取当前秒数
        System.out.print(second + "秒");

        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH); // 获取今天是本月第几天
        System.out.println("今天是本月的第 " + dayOfMonth + " 天");

        int dayOfWeekInMonth = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH); // 获取今天是本月第几周
        System.out.println("今天是本月第 " + dayOfWeekInMonth + " 周");

        Calendar c=Calendar.getInstance();
        c.add(Calendar.DAY_OF_MONTH,5);
        
    }
}

Java21天打卡-Day15 数组

import java.util.Arrays;

public class Day15 {
    //数组
    //题目1：
    //创建一个长度是8的字符串数组，使用8个长度是5的随机字符串初始化这个数组 对这个数组进行排序，按照每个字符串的首字母排序(无视大小写)
    //注1： 不能使用Arrays.sort() 要自己写
    //注2： 无视大小写，即 Axxxx 和 axxxxx 没有先后顺序

    public static void main(String[] args) {
        String []str = new String[8];
        for(int i =0;i<str.length;i++){
            str[i]= makeStr();
        }
        System.out.println("排序前"+ Arrays.toString(str));

        for (int j = 0; j < str.length; j++) {
            for (int i = 0; i < str.length - j - 1; i++) {
                char firstChar1 = str[i].charAt(0);
                char firstChar2 = str[i + 1].charAt(0);
                firstChar1 = Character.toLowerCase(firstChar1);
                firstChar2 = Character.toLowerCase(firstChar2);

                if (firstChar1 > firstChar2) {
                    String temp = str[i];
                    str[i] = str[i + 1];
                    str[i + 1] = temp;
                }
            }
        }
        System.out.println("排序后"+Arrays.toString(str));
}
    public  static String makeStr(){
        String pool = "";
        for (short i = '0'; i <= '9'; i++) {
            pool+=(char)i;
        }
        for (short i = 'a'; i <= 'z'; i++) {
            pool+=(char)i;
        }
        for (short i = 'A'; i <= 'Z'; i++) {
            pool+=(char)i;
        }
        char cs2[] = new char[5];
        for (int i = 0; i < cs2.length; i++) {
            int index = (int) (Math.random()*pool.length());
            cs2[i] =  pool.charAt( index );
        }
        String result2 = new String(cs2);
        return result2;
    }
}

java21天打卡day17-类2

构造方法是定义在java类中的一个用来初始化对象的方法，用new+构造方法，创建一个新的对象，并可以给对象中的实例进行赋值，java默认调用无参数的构造方法

public class Person {
    //构造方法
    //1、什么是构造方法（自己描述），java默认调用构造方法么？构造方式是类的一种特殊方法，用来初始化类的一个新的对象，在创建对象之后自动调用。
    //2、定义一个无参数构造方法和有参数构造方法
    //定义一个类person，创建一个无参数构造方法 ：person（）{}，并打印出结果：我是一个无参数的构造方法
    //创建一个有参数的构造方法 person（string name），对name进行赋值，最后print打印出name
    //3、在main方法里new person类，分别构造有参数和无参数的方法：print打印结果
    String Name;


    Person(){
        System.out.println("我是一个无参数的构造方法");
    }
    Person(String name){
        System.out.println(name);
    }
    public static void main(String[] args) {
        Person p = new Person();
        Person p2=new Person("张三");

    }


}

Java21天打卡day18–继承

public class Person18 {
    //继承
    //1、描述什么是继承 在已存在的类的基础上进行扩展，从而产生新的类
    //2、创建一个person类，赋予name、age、sex属性，并创建一个有参数的构造方法并赋值
    //3、创建一个方法work，print打印出结果：name是一个测试工程师
    //4、创建一个类 Engineer，继承person，调用person的work方法
    //5、在main方法里，new engineer类，对name进行赋值，并调用work方法，查看打印结果
    public String name;
    public int age;
    public String sex;

    public Person18(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;

    }

    public void work() {
        System.out.println(name + "是一个测试工程师");
    }


    public static void main(String[] args) {
        Engineer e = new Engineer("张三",25,"女");
        e.work();

    }
}

public class Engineer extends Person18 {
    public Engineer(String name, int age, String sex) {
        super(name,age, sex);
    }
}

出错的地方：
1.一个文件只能有一个类，所以子类必须新写一个文件。
2.子类的构造函数继承了父类的有参数构造函数，所以子类构造函数也要有参数。
3.初始化的时候，只能初始化全部构造函数，因为这里只有一个构造函数。

Java21天打卡day19-异常

//异常
//异常分类
//编译时异常：程序编译时的异常例子 IO异常，SQL异常
//运行时异常的区别：程序在运行时出现的异常，会自动抛出该异常
//异常处理
//
//try catch finally处理异常
//throws 和 throw 的区别
//throws是用于在方法声明抛出的异常是（Oexcetion）类型，而throw是用于抛出异常。

Java 的异常处理通过 5 个关键字来实现：try、catch、throw、throws 和 finally。try catch 语句用于捕获并处理异常，finally 语句用于在任何情况下（除特殊情况外）都必须执行的代码，throw 语句用于拋出异常，throws 语句用于声明可能会出现的异常。

try {
    // 可能发生异常的语句
} catch(ExceptionType e) {
    // 处理异常语句
}
语法的处理代码块 1 中，可以使用以下 3 个方法输出相应的异常信息。
printStackTrace() 方法：指出异常的类型、性质、栈层次及出现在程序中的位置（关于 printStackTrace 方法的使用可参考《Java的异常跟踪栈》一节）。
getMessage() 方法：输出错误的性质。
toString() 方法：给出异常的类型与性质。

//题目1：完成一个编译时异常的举例其实就是写的时候会有红线提示进行异常处理
//题目2：完成一个运行时异常的举例
public class Day19 {
public static void main(String[] args){
System.out.println(3/0);
}

}

//题目3：完成一个运行时异常捕获，获取异常信息后打印异常信息。
public class Day19 {
public static void main(String[] args){
   try{
       System.out.println(3/0);
   }catch (Exception e){
       e.printStackTrace();
       System.out.println("啊啊啊啊,出错了");//如果没有异常处理，这句是不会打印的
   }
}

}

//题目4：自定义一个异常并捕获抛出

import java.util.InputMismatchException;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        int age;
        Scanner in=new Scanner((System.in));
        System.out.println("请输入您的年龄");
        try {
            age=in.nextInt();
            if(age<0){
                throw new MyException("您输入的年龄为负数，输出错误");

            }else if(age>100){
                throw new MyException("您输入的年龄大于100，输出错误");
            }else {
                System.out.println("您的年龄是"+age);
            }

        }catch (InputMismatchException e1){
            System.out.println("您输入的年龄不是数字");
        }catch (MyException e2){
            System.out.println(e2.getMessage());
        }

    }
}

public class MyException extends Exception {
    public  MyException(){
        super();//继承父类构造函数
    }
    public MyException(String str){
        super(str);
    }

}

参考：http://c.biancheng.net/view/1051.html

参考答案：

答案：

题目1：

@Test//获取系统编译时异常,需要抛出异常或者进行异常捕获 try catch
public void getBuildException(){
    File file = new File("/dd");
    FileInputStream inputStream =new FileInputStream(file);
}


直接会有红线提示：
或者运行时会提示：
Error:(15, 39) java: 未报告的异常错误java.io.FileNotFoundException; 必须对其进行捕获或声明以便抛出

题目2:
public class ex {

    public static void getRunException() {
        int a = 1 / 0;
        System.out.println("异常已经出现了看我打印不打印");
    }

    public static void main(String[] args) {
       // getBuildException();
    }
}

运行时会出现：
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.benben.exception.ex.getRunException(ex.java:19)
	at com.benben.exception.ex.main(ex.java:24)


题目3：

@Test//获取系统运行时异常
public void getRunException() {
    try {
        int a = 1 / 0;
        System.out.println("异常已经出现了看我打印不打印");
    } catch (RuntimeException e) {
        System.out.println(e.getMessage() + "异常信息");
        System.out.println(e.toString() + "输出异常串");
        System.out.println("打印异常信息");
        e.printStackTrace();
    } finally {
        System.out.println("finally 输出了");
    }
}

题目4:
//抛出一个 自定义的异常，并由调用此方法的对象方法捕获后处理 throw
自定义的异常类：
Oexcetion.java

public class Oexcetion extends RuntimeException {

    final long serialVersionUID = -703407466939L;

    public Oexcetion() {
    }

    public Oexcetion(String msg) {
        super(msg);
    }
}

ex.java
class ex {
    public void biJia(int a, int b) throws Oexcetion {
        if (a < b) {
            throw new Oexcetion("出现自定义异常了");
        }
    }
}

java21天打卡day20-集合

集合list
ArrayList

查询速度快
线程不安全
LinkedList

增删速度快
线程不安全
Vector

线程安全
查询速度快
常用方法练习

add(value) 添加元素
get(index) 获取元素
remove(index) 删除元素
题目1:新建三个list实现类的对象
题目2:遍历List
1)迭代器
2)增强for循环

数组长度不可变化
List 是一个有序、可重复的集合
List 实现了 Collection 接口，它主要有两个常用的实现类：ArrayList 类和 LinkedList 类。
ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。
LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素

import java.util.*;

public class Day20 {
    public static void main(String[] args){
        List list1=new ArrayList();
        list1.add("1");
        list1.add("2");
        System.out.println("list1集合元素如下");
        Iterator it=list1.iterator();//迭代器？
        while(it.hasNext()){
            System.out.print(it.next()+",");
        }
        LinkedList list2=new LinkedList();
        list2.add("hello");
        list2.add("world");
        System.out.println("list2集合元素如下");
        for(int i=0;i<list2.size();i++){
            System.out.print(list2.get(i)+",");
        }
        Vector vector=new Vector();
        

    }
}

参考答案：

1)
import java.util.ArrayList;
           
           public class demo {
               public static void iterator() {
                       ArrayList arrayList = new ArrayList();
                       arrayList.add(2);
                       arrayList.add(new Object());
                       arrayList.add(new String("5"));
               
                       ;//遍历集合元素
                       Iterator iterator = arrayList.iterator();
                       while (iterator.hasNext()) {
                           System.out.println(iterator.next());
                       }
               }
               public static void main(String[] args) {
                    iterator();
               }
           }

 import java.util.ArrayList;
      
      public class demo {
          public static void LinkedList() {
              ArrayList arrayList = new ArrayList();
              arrayList.add(1);
              arrayList.add(2);
              arrayList.add(3);
              arrayList.add(14);
              for (Object list:arrayList)//这个方法厉害了
              {
                  System.out.println(list);
              }
          }
      
          public static void main(String[] args) {
              LinkedList();
          }
      }

Java21天打卡练习Day21-集合map

HashMap
TreeMap：根据KEY排序
LinkedHashMap
HashTable
创建4个map实现类的对象

Map hashMap = new HashMap();
Map linkedHashMap = new LinkedHashMap();
Map treeMap = new TreeMap();
Map hashtable = new Hashtable();

常用方法练习
put(key,value)添加元素，添加相同的key值是替换原来的value
putAll(Map) 添加新的map数据，已存在就刷新
get(key) 根据key查找元素
remove(key) 根据key删除元素
containsKey(key) 判断是否存在key值
containsValue(value) 判断是否存在value
clear() 删除所有元素
relpace(key,value1,value2) 修改value1 变成value2
isEmpty() 判断集合是否为空
size() 获取集合长度

遍历map四种方法：
http://c.biancheng.net/view/6872.html

import java.util.*;

public class Day21 {
    public static void main(String[] args){
        HashMap h=new HashMap();
        h.put("青花瓷","周杰伦");
        h.put("画","邓紫棋");
        h.put("断桥残雪","许嵩");
        Iterator it=h.keySet().iterator();//keySet是得到key的集合
        while(it.hasNext()){
            Object key=it.next();//得到hashmap的key?//不知道是什么对象就用Object?
            Object val=h.get(key);
            System.out.println("歌曲:"+key+"歌手:"+val);


        }
    }


}

参考答案：

map遍历
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
public class d {
    public static void itMap() {
        Map hashMap = new HashMap();
        hashMap.put("1",1);
        hashMap.put("2",2);
        hashMap.put("3",3);
        //普通
        Iterator<String> iterator = hashMap.keySet().iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            System.out.println(hashMap.get(key));
        }
        //entrySet最快
        Iterator<Map.Entry<String,Object>> iterator1 = hashMap.entrySet().iterator();
        while (iterator1.hasNext()) {
            Map.Entry<String, Object> entry = iterator1.next();
            System.out.println(entry.getKey());
        }

    }

    public static void main(String[] args) {去
        itMap();
    }
}

增强for循环，遍历HashMap
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
 public static void main(String[] args) {
       // LinkedList();
        //iterator();
        //itMap();
        Map<String, Integer> hashMap = new HashMap<String, Integer>();
        //Map hashMap = new HashMap();
        hashMap.put("1",1);
        hashMap.put("2",2);
        hashMap.put("3",3);
        //普通
        for (Object key : hashMap.keySet()) {
            System.out.println("key=" + key + "  value=" + hashMap.get(key));
        }
        //entrySet
        for(Map.Entry<String, Integer> entry: hashMap.entrySet()) {
            System.out.println(entry.getKey());
        }

    }
}