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());
        }

    }
}