Java ee 从入门到放弃 day08

字符串

String

package cn.wang.practice.stringdemo;
/*
String类代表字符串，Java程序中所有的双引号字符串，都是String类的对象,
它们的值在创建后不能被更改。因为String对象是不可变的，它们可以被共享
字符串效果上相当于字符数组(char[]),但在底层原理是字节数组(byte[])
String构造方法
    public String() 创建一个空白字符串对象，不含有任何内容
    public String(char[] chs)   根据字符数组的内容，来创建字符串对象
    public String(byte[] bys)   根据字节数组的内容，来创建字符串对象
    String s = "abc";   直接复制的方式创建字符串对象，内容就是abc
    （建议使用直接赋值的方式创建字符串对象）
String对象的特点
    1.通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同
    2.以""方式给出的字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，
    JVM都只会建立一个String对象，并在字符串池中维护
字符串的比较
    使用 == 作比较
        基本类型：比较的是数据值是否相同
        引用类型：比较的是地址值是否相同
    字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫：equals()
        public boolean equals(Object anObject);将此字符串于指定对象进行比较，
        由于我们比较的是字符串对象，所以参数直接传递一个字符串
 */
public class StringClass {
    public static void main(String[] args) {
        //public String() 创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:" +s1);

        //public String(char[] chs)   根据字符数组的内容，来创建字符串对象
        char[] chs = {'a','b','c'};
        String s2 = new String(chs);
        System.out.println("s2:" +s2);

        //public String(byte[] bys)   根据字节数组的内容，来创建字符串对象
        byte[] bys = {97,98,99};
        String s3 = new String(bys);
        System.out.println("s3:" +s3);

        //String s = "abc";   直接复制的方式创建字符串对象，内容就是abc
        String s4 = "abc";
        System.out.println("s4:" +s4);

       /* 1.通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同
        2.以""方式给出的字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，
        JVM都只会建立一个String对象，并在字符串池中维护*/
        String s5 ="abc";
        System.out.println(s1 == s2);//false 比较的是地址值
        System.out.println(s4 == s5);//true 比较的是地址值
        System.out.println(s1.equals(s2));//true 比较的是内容
    }

}

用户登录

package cn.wang.practice.stringdemo;
/*
已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登陆之后，给出相应提示
 */
import java.util.Scanner;

public class UserLogin {
    public static void main(String[] args) {
        String name = "username";
        String password = "password";
        Scanner sc = new Scanner(System.in);
        s:for (; ; ) {
            System.out.println("请输入用户名：");
            String username = sc.next();
            if (username.equals(name)) {
                for (int j = 2; j >= 0; j--) {
                    System.out.println("请输入密码：");
                    String userpassword = sc.next();
                    if (userpassword.equals(password)) {
                        System.out.println(name + ",欢迎你登陆");
                    } else {
                        if (j == 0) {
                            System.out.println("今日已达上限，请明日再来");
                            break s;
                        } else {
                            System.out.println("密码输入错误，请重新输入;你还有" + j + "次机会");
                            System.out.println();
                        }
                    }
                }
            } else {
                System.out.println("用户名输入错误，请重新输入");
                System.out.println();
            }
        }
    }
}

遍历字符串

package cn.wang.practice.stringdemo;

/*
键盘输入一个字符串，遍历字符串在控制台输出
 */
import java.util.Scanner;

public class StringFori {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.nextLine();
        for (int i = 0; i < str.length(); i++) {
            System.out.println(str.charAt(i));
        }
    }
}

统计字符次数

package cn.wang.practice.stringdemo;

import java.util.Scanner;

/*
键盘录入一个字符串，统计该字符中大写字母字符，小写字母字符，数字字符出现的次数（不考虑其他字符）
 */
public class StringSum {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.nextLine();
        int sum1 = 0;
        int sum2 = 0;
        int sum3 = 0;
        for (int i = 0; i < str.length(); i++) {
            if ('A'<= str.charAt(i)&&str.charAt(i) <='Z' ){
                sum1++;
            }else if ('a'<= str.charAt(i)&&str.charAt(i) <='z'){
                sum2++;
            }else if ('0'<= str.charAt(i)&&str.charAt(i) <='9'){
                sum3++;
            }
        }
        System.out.println("字符串中大写字母出现的次数："+sum1);
        System.out.println("字符串中小写字母出现的次数："+sum2);
        System.out.println("字符串中数字出现的次数："+sum3);
    }
}

字符串拼接

package cn.wang.practice.stringdemo;
/*
定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为int[] arr = {1,2,3},执行方法后输出结果：[1,2,3]
 */
public class StringPinJie {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        System.out.println(pin(arr));
    }
    public static String pin(int[] arr){
        String str = "";
        str += "[";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length -1){
                str += arr[i];
            }else {
                str += arr[i];
                str += ",";
            }
        }
        str += "]";
        return str;
    }
}

字符串反转

package cn.wang.practice.stringdemo;

import java.util.Scanner;

/*
定义一个方法，实现字符串翻转。键盘录入一个字符串，调用该方法后，在控制台输出结果。
例如：键盘录入abc，输出结果cba
 */
public class StringReverce {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.nextLine();
        System.out.println("反转后的字符串是：" +reverce(str));
    }
    public static String reverce(String str){
        String str2 = "";
        for (int i = str.length() - 1; i>=0 ; i--) {
           str2 += str.charAt(i);
        }
        return str2;
    }
}

StringBuilder

package cn.wang.practice.stringdemo;
/*
StringBuilder是一个可变（StringBuilder对象中的内容可变）的字符串类，我们可以把它看成一个容器
String和StringBuilder的区别：
    String:内容是不可变的
    StringBuilder:内容是可变的
StringBuilder构造方法：
    public StringBuliber():创建一个空白可变的字符串对象，不含有任何内容
    public StringBuliber(String str):根据字符串内容，来创建可变字符串对象
StringBuilder的添加和反转方法：
    public StringBuliber append(任意类型):添加数据，并返回对象本身
    public StringBuliber reverse():返回相反的字符序列
 */
public class StringBuilderTest {
    public static void main(String[] args) {
        //public StringBuliber():创建一个空白可变的字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" +sb);
        System.out.println("sb.length:" +sb.length());

        //public StringBuliber(String str):根据字符串内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" +sb2);
        System.out.println("sb2.length:" +sb2.length());

        // public StringBuliber append(任意类型):添加数据，并返回对象本身
        StringBuilder sb3 = new StringBuilder();
        /*StringBuilder sb4 = sb3.append("hello");
        System.out.println("sb3:" +sb3);
        System.out.println("sb4:" +sb4);
        System.out.println(sb3==sb4);//true 返回对象本身
        sb3.append("hello");
        sb3.append("world");
        sb3.append(100);*/
        //链式编程
        sb3.append("hello").append("world").append(100);
        System.out.println("sb3:" +sb3);


        //public StringBuliber reverse():返回相反的字符序列
        sb3.reverse();
        System.out.println("sb3:" +sb3);
    }

}

StringBuilder和String相互转换

package cn.wang.practice.stringdemo;
/*
StringBuilder转化为String
    puclic String toString():通过toString()就可以实现把StringBuilder转换为String
String转化为StringBuilder
    puclic StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder

 */
public class StringAndStringBuilder {
    public static void main(String[] args) {
        //puclic String toString():通过toString()就可以实现把StringBuilder转换为String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
        String s = sb.toString();
        System.out.println("s:" +s);

        //puclic StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder
        String s1 = "hello";
        StringBuilder sb2 = new StringBuilder(s1);
        System.out.println("sb2:" +sb2);
    }
}

字符串拼接升级版

package cn.wang.practice.stringdemo;
/*
拼接字符高级版：
    定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为int[] arr = {1,2,3},执行方法后输出结果：[1,2,3]
 */
public class StringPinJies {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        System.out.println(pin(arr));
    }
    public static String pin(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i] + "," );
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

字符串反转升级版

package cn.wang.practice.stringdemo;

import java.util.Scanner;

/*
字符串反转：
定义一个方法，实现字符串翻转。键盘录入一个字符串，调用该方法后，在控制台输出结果。
例如：键盘录入abc，输出结果cba
 */
public class StringReverces {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();
        System.out.println("反转后的字符串是：" +reverce(s));
    }
    public static String reverce(String s){
        return new StringBuilder(s).reverse().toString();
    }
}

习题

第一题：分析以下需求,并用代码实现

1.定义String getStr()方法
 功能描述：
 获取长度为5的随机字符串，字符串由随机的5个大小写字母组成
2.在main方法中调用上述方法，并打印结果

第二题: 分析以下需求,并用代码实现

1.键盘录入一个字符串
2.将该字符串变成字符数组(不能使用toCharArray()方法)
3.将字符数组中的所有大写字母变成小写字母(不能使用toLowerCase()方法)
4.如果第一位和最后一位的内容不相同,则交换
5.将字符数组中索引为偶数的元素变成'~'
6.打印数组元素的内容

昨日习题答案

第一题：分析以下需求并实现

手机类Phone
属性:
	品牌brand
	价格price
行为:
	打电话call()
	发短信sendMessage()
	玩游戏playGame()
	
要求:
	1.按照以上要求定义类,属性要私有,生成空参、有参构造，setter和getter方法
	2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
	3.调用三个成员方法,打印格式如下:
		正在使用价格为998元的小米品牌的手机打电话....
		正在使用价格为998元的小米品牌的手机发短信....
		正在使用价格为998元的小米品牌的手机玩游戏....

			
/*
手机类
 */
public class Phone {
    //属性
    private String brand;
    private int price;
    
    //无参构造
    public Phone() {
    }

    //带参构造
    public Phone(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    public void call() {
        System.out.println("正在使用价格为" + price + "元的" + brand + "品牌的手机打电话....");
    }

    public void sendMessage() {
        System.out.println("正在使用价格为" + price + "元的" + brand + "品牌的手机发短信....");
    }

    public void playGame() {
        System.out.println("正在使用价格为" + price + "元的" + brand + "品牌的手机玩游戏....");
    }
    
}

/*
测试类
 */
public class PhoneDemo {
    public static void main(String[] args) {
        //无参构造方式
        Phone p = new Phone();
        p.setBrand("小米");
        p.setPrice(998);
        p.call();
        p.sendMessage();
        p.playGame();

        System.out.println("--------");
        //带参构造方式
        Phone p1 = new Phone("小米", 998);
        p1.call();
        p1.sendMessage();
        p1.playGame();

    }
}

第二题：分析以下需求并实现

1.项目经理类Manager 
	属性：
		姓名name
		工号id
		工资salary
		奖金bonus
	行为：
		工作work()
2.程序员类Coder
	属性：
		姓名name
		工号id
		工资salary
	行为：
		工作work()
要求:
	1.按照以上要求定义Manager类和Coder类,属性要私有,生成空参、有参构造，setter和getter方法
	2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
	3.调用成员方法,打印格式如下:
		工号为123基本工资为15000奖金为6000的项目经理正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....
		工号为135基本工资为10000的程序员正在努力的写着代码......

/*
1.项目经理类Manager
		属性：
			姓名name
			工号id
			工资salary
			奖金bonus
		行为：
			工作work()
 */
public class Manager {
    private String name;
    private int id;
    private int salary;
    private int bonus;

    //无参构造
    public Manager() {
    }

    //带参构造
    public Manager(String name, int id, int salary, int bonus) {
        this.name = name;
        this.id = id;
        this.salary = salary;
        this.bonus = bonus;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public int getBonus() {
        return bonus;
    }

    public void setBonus(int bonus) {
        this.bonus = bonus;
    }

    //成员方法
    public void work() {
        System.out.println("工号为" + id + "基本工资为" + salary + "奖金为" + bonus + "的" + name + "正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....");
    }
}

/*
2.程序员类Coder
		属性：
			姓名name
			工号id
			工资salary
		行为：
			工作work()
 */
public class Coder {
    private String name;
    private int id;
    private int salary;

    //无参构造
    public Coder() {
    }

    //带参构造
    public Coder(String name, int id, int salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalaary(int salary) {
        this.salary = salary;
    }

    //成员方法
    public void work() {
        System.out.println("工号为" + id + "基本工资为" + salary + "的"+name+"正在努力的写着代码......");
    }
}

/*
测试类
*/
public class Manager_CoderDemo {
    public static void main(String[] args) {
        //项目经理 无参构造
        Manager m = new Manager();
        m.setName("项目经理");
        m.setId(123);
        m.setSalary(15000);
        m.setBonus(6000);
        m.work();

        //程序员 带参构造
        Coder c = new Coder("程序员", 135, 10000);
        c.work();

    }
}

第三题：分析以下需求并实现

1.猫类Cat
	属性:
		毛的颜色color
		品种breed
	行为:
		吃饭eat()
		抓老鼠catchMouse()
2.狗类Dog
	属性:
		毛的颜色color
		品种breed
	行为:
		吃饭()
		看家lookHome()
要求:
	1.按照以上要求定义Cat类和Dog类,属性要私有,生成空参、有参构造，setter和getter方法
	2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
	3.调用成员方法,打印格式如下:
		花色的波斯猫正在吃鱼.....
		花色的波斯猫正在逮老鼠....
		黑色的藏獒正在啃骨头.....
		黑色的藏獒正在看家.....	

/*
	1.猫类Cat
		属性:
			毛的颜色color
			品种breed
		行为:
			吃饭eat()
			抓老鼠catchMouse()
 */
public class Cat {
    private String color;
    private String breed;

    public Cat() {
    }

    public Cat(String color, String breed) {
        this.color = color;
        this.breed = breed;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public void eat() {
        System.out.println("" + color + "的" + breed + "正在吃鱼.....");
    }

    public void catchMouse() {
        System.out.println(color + "的" + breed + "正在逮老鼠....");
    }
}

/*
2.狗类Dog
		属性:
			毛的颜色color
			品种breed
		行为:
			吃饭eat()
			看家lookHome()
 */
public class Dog {
    private String color;
    private String breed;

    public Dog() {
    }

    public Dog(String color, String breed) {
        this.color = color;
        this.breed = breed;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public void eat() {
        System.out.println(color + "的" + breed + "正在啃骨头.....");
    }

    public void lookHome() {
        System.out.println(color + "的" + breed + "正在看家.....");
    }
}

/*
测试类
 */
public class Cat_DogDemo {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.setColor("花色");
        c.setBreed("波斯猫");
        c.eat();
        c.catchMouse();
        System.out.println("--------");
        Dog d = new Dog("黑色", "藏獒");
        d.eat();
        d.lookHome();
    }
}