Java2

本学习笔记的图片和题目均来源于黑马程序员，本人小白一枚，如有错误请及时指出，感谢感谢

一.String概述
java.lang.String 类代表字符串, Java 程序中的所有字符串文字（例如“abc”）都为此类的对象

二.字符串的作用

 三.创建String对象的两种方式
（1）直接赋值
（2）使用new构造方法

public class zifuchuan {
    public static void main(String[]args){
        //1.直接赋值
        String s="abcd";
        System.out.println(s);//abcd
        //2.使用new
        //（1）空参构造
        String s1=new String();
        System.out.println("!"+s1+"!");//!!
        //(2)传递字符串
        String s2=new String("abcd");
        System.out.println(s2);//abcd
        //(3)传递一个字符数组
        char []a={'a','b','c'};
        String s3=new String(a);
        System.out.println(s3);//abc
        //(4)传递一个字节数组
        byte[]b={97,98,99,100};
        String s4=new String(b);//abcd
        System.out.println(s4);
    }
}

 

 四.Java的内存模型

jdk7以前，串池是在方法区内

 从jdk7开始就从方法区中挪到了堆内存中，但是运行机制没有变化。

 当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在。
不存在：创建新的
存在：复用

 当使用new构造方法时

每new一个字符串，都会在堆中占用一块内存，不论是否存在都会占用新的，会造成内存的浪费

 五.Java的常用方法（比较）

（1）==比的是什么

对基本数据类型比的是数值，引用数据类型比的是地址值

 

public class demo1 {
    public static void main(String[] args) {
        //基本数据类型
        String a="abc";
        String b="abc";
        System.out.println(a==b);//true，比较的是数值
        //引用数据类型
        String c=new String("abc");
        String d=new String("abc");
        System.out.println(c==d);//false,因为引用数据类型比较的是地址
        //字符串比较
        String e="abc";//记录串池中的地址值
        String f=new String("abc");//记录堆里面的地址值
        String g=new String("Abc");
        System.out.println(e==f);//false
        boolean result1=e.equals(f);
        System.out.println(result1);//true
        boolean result2=e.equals(g);
        System.out.println(result2);//false，equals比较区分大小写
        boolean result3=e.equalsIgnoreCase(g);
        System.out.println(result3);//true,equalsIgnoreCase比较不区分大小写
    }
}

（2）字符串比较

boolean equals方法(要比较的字符串)，完全一样结果才是true，否则为false
boolean equalsIgnoreCase(要比较的字符串)，忽略大小写的比较

import java.util.Scanner;
public class demo2 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String a=sc.next();//是new出来的
        String b="abc";
        if(a==b){
            System.out.println("true");
        }else{
            System.out.println("false");
        }//false，用==比较不出来
        if(a.equals(b)){
            System.out.println("true");
        }else{
            System.out.println("false");
        }//true
        //结论：只要是想比较字符串的内容，就必须要用String的两个方法equals和equalsIgnoreCase
    }
}

案列一

用户登录
需求：已知正确的用户名和密码，请用程序实现模拟用户登录。
总共给三次机会，登录之后，给出相应的提示

 

import java.util.Scanner;
public class userLogin {
    public static void main(String[] args) {
        //定义正确的用户名和密码
        String username="zhangsan";
        String password="123456";
        Scanner sc=new Scanner(System.in);
        for(int i=0;i<3;i++){
            //键盘录入
            System.out.println("请输入用户名：");
            String userName=sc.next();
            System.out.println("请输入密码：");
            String Password=sc.next();
            //比较
            if(username.equals(userName)&&password.equals(Password)){
                System.out.println("登录成功");
                break;
            }else{
                if(i==2){
                    System.out.println("账号"+userName+"已被锁定，请联系李四");
                }else{
                    System.out.println("登录失败，用户名或密码错误，您还有"+(2-i)+"次机会");
                }
            }
        }

    }
}

案例二

遍历字符串
需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串

 

import java.util.Scanner;

public class demo3 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String a=sc.next();
        //遍历
        for(int i=0;i<a.length();i++){
            char c=a.charAt(i);
            System.out.println(c);
        }
    }
}

案例三

字符串反转
定义一个方法，实现字符串反转。
键盘录入一个字符串，调用该方法后，在控制台输出结果
例如，键盘录入 abc，输出结果 cba

import java.util.Scanner;
public class demo6 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.next();//录入字符串
        String s=reverser(str);//调用方法
        System.out.println(s);
    }
    /*public static void reverser(String s) {//实现字符串反转
        char[]b=new char[s.length()];
        for(int i=0;i<s.length();i++){
           char a=s.charAt(i);
           b[i]=a;//数组内存字符串
        }
        for(int i=b.length-1;i>=0;i--){//倒着打印数组
            System.out.print(b[i]);
        }
    }*///自己想的
    public static String reverser(String s){//拼接的思想
        String result="";
        for(int i=s.length()-1;i>=0;i--){//倒着遍历
            char c=s.charAt(i);
            result=result+c;
        }return result;
    }
}

案例四

金额转换

import java.util.Scanner;

public class demo7 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入金额");
        int  money=sc.nextInt();//键盘录入
        while(true){//验证是否有效
            if(money>0&&money<9999999){
                break;
            }else{
                System.out.println("金额无效，请重新输入");
            }
        }
        //获取数字，转成中文
        String moneyStr="";
        for(;money>0;money=money/10){
            int ge=money%10;//反着拿
            String capitalNumber=getNumber(ge);
            moneyStr=capitalNumber+moneyStr;//反着拼，必须是capitalNumber在前，moneyStr在后
        }
        //补零
    int count=7-moneyStr.length();
    for(int i=0;i<count;i++){
        moneyStr="零"+moneyStr;
    }
    //加单位
        String []arr={"佰","拾","万","仟","佰","拾","元"};
        String R="";
        for(int i=0;i<arr.length;i++){
            R=R+moneyStr.charAt(i)+arr[i];//拼接
        }
        System.out.println(R);
}
    //将数字转成中文的方法
    public static String getNumber(int n) {
        String []number={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};//利用数组让数字和中文产生关系
        String result=number[n];
        return result;
    }
}

 案例五

手机号屏蔽

例如131**** 9468

 

public class demo8 {
    public static void main(String[] args) {
        String phoneNumber="12345678911";
        String strat=phoneNumber.substring(0,3);//截取前三位
        /*System.out.print(strat);
        //设置中间
        System.out.print("****");*/
        String end=phoneNumber.substring(7);//截取后四位
        //System.out.print(end);
        String result=strat+"****"+end;
        System.out.println(result);
    }
}

案例六

身份证信息查看

7-14位：出生年、月、日
17位：性别（奇数男性，偶数女性）

输入身份证号码，输出出生年月日和性别

public class demo9 {
    public static void main(String[] args) {
        String id="3212812020010112234";
        //获取年月日
        String year=id.substring(6,10);
        String month=id.substring(10,12);
        String day=id.substring(12,14);
        System.out.println("人物身份信息为：");
        System.out.println(year+"年"+month+"月"+day+"日");
        //获取性别
        int gender=id.charAt(16);
        if(gender%2==0){
            System.out.println("性别为：女");
        }else{
            System.out.println("性别为：男");
        }
    }
}

案例七

敏感词替换

 

public class demo10 {
    public static void main(String[] args) {
        String talk="玩的不错，tmd";
        //定义敏感词库
        String []arr={"tmd","sb"};
        //依次替换
        for(int i=0;i<arr.length;i++){
            talk=talk.replace(arr[i],"***");
        }
        //打印结果
        System.out.println(talk);
    }
}

案例八

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回,调用该方法，并在控制台输出结果。

例如：数组为 int［］arr =(1,2,3）;

执行方法后的输出结果为:[1,2.3]

public class demo5 {
    public static void main(String[] args) {
        int []a={1,2,3};
        System.out.println(arrToString(a));
    }
    public static String arrToString(int []arr){
        if(arr==null){//当int[]a=null时
            return "";
        }
        if(arr.length==0){
            return "[]";
        }
        String str ="[";
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                str = str +arr[i];
            }else{
                str = str +arr[i]+",";
            }
        }
        str = str +"]";
        return str;
    }
}

案例九

统计字符次数

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

import java.util.Scanner;

public class demo4 {
    public static void main(String[] args) {
        int big=0;
        int small=0;
        int number=0;
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str=sc.next();
        for(int i=0;i<str.length();i++){
            char a=str.charAt(i);
            if (a >= 'a' && a <= 'z') {//char类型的变量在参与计算时会自动提升为int，查询ASCII码表
                big++;
            }else if(a>='A'&&a<='Z'){
                small++;
            }else if(a>='0'&&a<='9'){
                number++;
            }
        }
        System.out.println("大写字母字符个数为"+big);
        System.out.println("小写字母字符个数为"+small);
        System.out.println("数字字符个数为"+number);
    }
}

六.StringBuilder概述
StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的
作用：提高字符串的操作效率

七.StringBuilder常用方法

public class demo11 {
    public static void main(String[] args) {
        //创建
        StringBuilder sb=new StringBuilder("abc");
        System.out.println(sb);//abc
        //添加元素
        sb.append("def");
        System.out.println(sb);//abcdef
        //反转,直接将容器中的数据反转
        sb.reverse();
        System.out.println(sb);//fedcba
        //获取长度
        int l=sb.length();
        System.out.println(l);//6
        //生成字符串，把stringBuilder变成字符串后，就可以使用String的方法了
        String str=sb.toString();
        System.out.println(str);//fedcba
    }
}

 因为stringBuilder是Java已经写好的类，java在底层对他做了一些特殊处理，所以打印对象不是地址值而是属性值。

链式编程：
当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法。

public class demo12 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        //添加元素
        //链式编程
        sb.append("abc").append("def").append("ghi");
        System.out.println(sb);
        String str=sb.toString();
        System.out.println(str);
    }
}

案例一

对称字符串
需求：键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
对称字符串：123321、111
非对称字符串：123123

import java.util.Scanner;

public class demo13 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.next();//输入字符串
        //链式
        String sb=new StringBuilder().append(str).reverse().toString();
        /*sb.append(str);
        sb.reverse();//反转
        System.out.println(sb);
        String SB=sb.toString();*/
        //比较
        if(str.equals(sb)){
            System.out.println("是对称字符串");
        }else{
            System.out.println("不是对称字符串");
        }
    }
}

案例二

拼接字符串
需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回。
调用该方法，并在控制台输出结果。
例如：数组为int[l arr ={1,2,3};
执行方法后的输出结果为:[1,2,3］

public class demo14 {
    public static void main(String[] args) {
        int []arr={1,2,3};
        System.out.println(arrToString(arr));
    }

    public static String arrToString(int[] arr) {
        StringBuilder sb=new StringBuilder("[");
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        return sb.append("]").toString();
    }
}

八.StringJoiner概述
StringJoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。
作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用。
在JDK8出现的

九.StringJoiner的构造方法

import java.util.StringJoiner;
public class demo15 {
    public static void main(String[] args) {
        //创建对象，指定符号
        StringJoiner sj=new StringJoiner("___");
        //添加元素
        sj.add("abc").add("def").add("ghi");
        //打印
        System.out.println(sj);//abc___def___ghi
    }
}

import java.util.StringJoiner;
public class demo16 {
    public static void main(String[] args) {
        //创建
        StringJoiner sj=new StringJoiner(",","[","]");
        //添加
        sj.add("abc").add("def").add("ghi");
        //长度
        int l=sj.length();
        System.out.println(l);//13
        //打印
        System.out.println(sj);//[abc,def,ghi]
        String str=sj.toString();
        System.out.println(str);//[abc,def,ghi]
    }
}

十.字符串原理

扩展底层原理1：字符串存储的内存原理  

直接赋值会复用字符串常量池中的new出来不会复用，而是开辟一个新的空间
扩展底层原理2：=号比较的到底是什么？
基本数据类型比较数据值
引用数据类型比较地址值
扩展底层原理3：字符串拼接的底层原理

如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串。
如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存。

（1）没有变量时

 （2）有变量时

 

字符串拼接的时候有变量参与时，在内存中创建了很多对象，浪费空间，时间也非常慢
结论：
如果很多字符串变量拼接，不要直接+。在底层会创建多个对象，浪费时间，浪费性能。

扩展底层原理4：StringBuilder提高效率原理图

所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的空间，节约内存

（1）常见面试题1

字符串拼接的时候，如果有变量：
JDK8以前：系统底层会自动创建一个StringBuilder对象，然后再调用其append方法完成拼接。拼接后，再调用其toString方法转换为String类型，而toString方法的底层是直接new了一个字符串对象。
JDK8版本：系统会预估要字符串拼接之后的总大小，把要拼接的内容都放在数组中，此时也是产生一个新的字符串。

 常见面试题2

 在编译的时候，就会将"a"+"b"+"c"拼接为"abc"

扩展底层原理5：StringBuilder源码分析
默认创建一个长度为16的字节数组，添加的内容长度小于16，直接存，
添加的内容大于16会扩容（原来的容量*2+2）

public class demo17 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        System.out.println(sb.capacity());//容量16
        System.out.println(sb.length());//长度0
        sb.append("abc");
        System.out.println(sb.capacity());//16
        System.out.println(sb.length());//3
        sb.append("abcdefghijklmnopqrstuvwxyz");
        System.out.println(sb.capacity());//34,扩容2*16+2
        System.out.println(sb.length());//29
        sb.append("abcdefghijklmnopqrstuvwxyz0123456789");
        System.out.println(sb.capacity());//70,34*2+2
        System.out.println(sb.length());//65,29+26+10=65
    }
}

小结

 案例一

转换罗马数字
键盘录入一个字符串，
要求1：长度为小于等于9
要求2：只能是数字
将内容变成罗马数字
下面是阿拉伯数字跟罗马数字的对比关系：
1 - 1、11 - 2、111 - 3、IV - 4、V - 5、V- 6、VII－ 7、Vl - 8、IX - 9
注意点:
罗马数字里面是没有0的
如果键盘录入的数字包含0，可以变成””（长度为0的字符串）

法一

import java.util.Scanner;
public class demo18 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str;
        String []arr={"","Ⅰ","Ⅱ","Ⅲ","Ⅳ","Ⅴ","Ⅵ","Ⅶ","Ⅷ","Ⅸ"};//查表法
        while(true){
            str=sc.next();//录入
            if(check(str)){//判断
                break;
            }else{
                System.out.println("当前字符串不符合规则，请重新输入");
            }
        }
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char s=str.charAt(i);
            int number=s-'0';
            sb.append(arr[number]);
        }System.out.print(sb.toString());
    }

    public static boolean check(String str) {
        //长度小于等于九
        if(str.length()>9){
            return false;
        }
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)<'0'||str.charAt(i)>'9'){
                return false;
            }
        }
        return true;
    }
}

法二

import java.util.Scanner;

public class demo19 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        System.out.println(toLuoma(str));
    }

    public static String toLuoma(String str) {
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char s=str.charAt(i);
            int a=s-'0';
            switch(a){
                case 0:sb.append("");break;
                case 1:sb.append("Ⅰ");break;
                case 2:sb.append("Ⅱ");break;
                case 3:sb.append("Ⅲ");break;
                case 4:sb.append("Ⅳ");break;
                case 5:sb.append("Ⅴ");break;
                case 6:sb.append("Ⅵ");break;
                case 7:sb.append("Ⅶ");break;
                case 8:sb.append("Ⅷ");break;
                case 9:sb.append("Ⅸ");break;
                default:break;
            }
        }
        return sb.toString();
    }
}

案例二

调整字符串
给定两个字符串A 和 B。
A的旋转操作就是将 A 最左边的字符移动到最右边。
例如,若 A ='abcde'，在移动一次之后结果就是'bcdea'。
如果在若干次调整操作之后，A 能变成B，那么返回True。
如果不能匹配成功，则返回false

要修改字符串的内容，可以有两个办法：
1.用substring进行截取，把左边的字符截取出来拼接到右侧去
2.可以把字符串先变成一个字符数组，然后调整字符数组里面的数据，最后再把字符数组变成字符串

1

public class demo20 {
    public static void main(String[] args) {
        String A="abcdef";
        String B="cdefab";
        System.out.println(transform(A,B));
    }//使用substring
    public static boolean transform(String  A,String B) {
        for(int i=0;i<A.length();i++){//循环旋转并且比较
            StringBuilder sb=new StringBuilder();
            char s=A.charAt(0);
            String str=A.substring(1);
            A=sb.append(str).append(s).toString();
            if(A.equals(B)){
                return true;
            }
        }
        return false;
    }
}

2

public class demo21 {
    public static void main(String[] args) {
        String A="abcdef";
        String B="cdefab";
        System.out.println(transform(A,B));
    }
    //使用数组
    public static boolean transform(String  A,String B) {
        for(int i=0;i<A.length();i++){//循环旋转并且比较
            char[]arr=A.toCharArray();
            char first=arr[0];
            for(int j=1;j<A.length();j++){
                arr[j-1]=arr[j];
            }
            arr[A.length()-1]=first;
            A=new String(arr);
            if(A.equals(B)){
                return true;
            }
        }
        return false;
    }
}

案例三

键盘输入任意字符串，打乱里面的内容。

import java.util.Scanner;
import java.util.Random;
public class demo22 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.next();
        char[]arr=str.toCharArray();//变成数组
        change(arr);
        String str1=new String(arr);//变成字符串
        System.out.println(str1);
    }
    //随机打乱
    public static char[] change(char []arr) {
        Random r=new Random();
        for(int i=0;i<arr.length;i++){
            int j=r.nextInt(0,arr.length);
            char temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
        }
        return arr;
    }
}

案例四

给定两个以字符串形式表示的非负整数num1和num2，返回num1和num2的乘积，它们的乘积也表示为字符串形式:
注意：需要用已有的知识完成。

import java.util.Random;
public class demo23 {
    public static void main(String[] args) {
        String num1="1234";
        String num2="123";
        int multiply=change(num1)*change(num2);
        System.out.println(change(num1));
        System.out.println(change(num2));
        System.out.println(multiply);//int型的151782
        System.out.println(nichange(multiply));//String型的151782
    }
    public static int change(String str) {
        int sum=0;
        for(int i=0;i<str.length();i++){
            char c=str.charAt(i);
            int j=c-'0';
            sum=sum*10+j;
        }
        return sum;
    }
    public static String nichange(int str) {
        StringBuilder sb=new StringBuilder();
        for(;str>0;str=str/10){
            int c=str%10;
            char j=(char)(c+'0');
            sb.append(j);
        }
        String s=sb.reverse().toString();
        return s;
    }
}

案例五

给你一个字符串s，由若干单词组成，单词前后用一些空格字符隔开，返回字符串中最后一个单词的长度。单词是指仅由字母组成，不包含任何空格字符的最大子字符串。

public class lastOne {
    public static void main(String[] args) {
        String str="Hello World";
        int sum=0;
        for(int i=str.length()-1;i>=0;i--){
            if(str.charAt(i)==' '){
                break;
            }else{
                sum+=1;
            }
        }
        System.out.println(sum);//5
    }
}