day08

最新推荐文章于 2024-05-20 08:00:00 发布

搬砖的考拉

最新推荐文章于 2024-05-20 08:00:00 发布

阅读量152

点赞数 1

分类专栏：基础班文章标签： day08

本文链接：https://blog.csdn.net/weixin_44313232/article/details/86567520

版权

基础班专栏收录该内容

5 篇文章 0 订阅

订阅专栏

String:
Java程序中的所有双引号字符串，都是字符String类的对象，在java.lang包下所以不需要导包。
特点是：
1.字符串是不可变得，它们的值在创建后不能被更改。
2.虽然String的值是不可变得，但是他们能被共享。
3.字符串效果上相当于字符组(插入[]，但是底层原理是字节数组(byte[]).
常用构造方法：
方法名说明
Public String() 创建一个空白字符串对象，不含任何内容。
Public String (char[]chs) 根据字符数组的内容，来创建字符串对象。
Public String(byte[]bys) 根据字节数组的类容，俩创建字符串对象。
String s=”abc”; 直接赋值的反辐射创建字符串对象，类容就是abc
例如

public static void main(String[] args) {
    String s = new String();
    System.out.println(s);
    char[] chs={'z','b','c',};
    String s1=  new String(chs);
    System.out.println(s1);
    byte[] bys={99,98,97};
    String s2=new String(bys);
    System.out.println(s2);
     String s4="abc";
    System.out.println(s4);
}

**==的作用：
1.比较基本数据类型：比较的是具体的值；
2比较的是应用数据类型，比较的是对象地址值；
**equals方法的作用：
比较两个字符串的内容是否相同，区分大小写。
两种创建字符串对象两种方式的区别：
1.通过new创建的字符串对象，没一次new都会申请一个内存空间，虽然内容相同但是地址值不同。
2.以赋值给出的字符串，只要字符序列相同（顺序和大小写），无论在代码出现几次，jvm都只会建立一个String对象，并在字符串之中维护。

public static void main(String[] args) {
        char[]chs={'a','b','c'};
        //构造方法的方式得到对象
        String s1 = new String(chs);
        String s2 = new String(chs);
        //直接赋值的方式得到对象
         String s4="abc";
         String s5="abc";
        //比较字符串对象地址是否相同
        System.out.println(s1==s2);//false
        System.out.println(s1==s4);//false
        System.out.println(s4==s5);//ture
        //比较字符串内容是否相同
        System.out.println("******************");
        System.out.println(s1.equals(s2));//true
       System.out.println(s1.equals(s4));//true
        System.out.println(s4.equals(s5));//true
}

用户登陆案例；

public static void main(String[] args) {
    //定义字符串表示用户名和密码
    String username="asdfg";
    String passedpwd="123456";
    
    for (int i = 0; i < 3; i++) {
        //键盘录入用户名和密码
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入用户名");
        String name=sc.nextLine();
        System.out.println("请输入密码");
        String pwd=sc.nextLine();
        //拿键盘录入的用户名和密码比较
        if(name==username&&pwd==passedpwd){
            System.out.println("登陆成功");
            break;
        }else{
            if(i-2==2){
                System.out.println("请于管理员联系");
            }else{
                System.out.println("登录失败你还有"+(2-i)+"次机会");
            }
        }
    }

}

遍历字符串：

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

统计字符数：

public class StringTest03 {
public static void main(String[] args) {
//键盘录入一个字符串，用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//遍历字符串，得到每一个字符
for(int i=0; i<line.length(); i++) {
char ch = line.charAt(i);
//判断该字符属于哪种类型，然后对应类型的统计变量+1
if(ch>='A' && ch<='Z') {
bigCount++;
} else if(ch>='a' && ch<='z') {
smallCount++;
} else if(ch>='0' && ch<='9') {
numberCount++;
}
}
//输出三种类型的字符个数
System.out.println("大写字母：" + bigCount + "个");
System.out.println("小写字母：" + smallCount + "个");
System.out.println("数字：" + numberCount + "个");
}
}

字符拼接案例：

public class StringTest04{
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        String s = arraayToString(arr);
        System.out.println(s);
        //
        System.out.println(arraayToString(arr));
    }public static String arraayToString(int []arr){
        String s="";
        s+="[";
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                s+=arr[i];
            }   else{
                s+=arr[i];
                s+=",";
            }
        }
        s+="]";
        return s;
    }
}

字符串的反转:

public class StringTest05 {
public static void main(String[] args) {
//键盘录入一个字符串，用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//调用方法，用一个变量接收结果
String s = reverse(line);
//输出结果
System.out.println("s:" + s);
}
//定义一个方法，实现字符串反转
/*
两个明确：
返回值类型：String
参数：String s
*/
public static String reverse(String s) {
//在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
String ss = "";
for(int i=s.length()1; i>=0; i) {
ss += s.charAt(i);
}
return ss;
}
}

StringBuilder:
是一个不可变得字符串，这里的可变只得是StringBuilder对象中的内容是可变的。
StringBuilder类和String类的区别
·String类：内容是不可变的
·StringBuilder类：内容是可变的
方法名说明
public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象常用的构造
构造方法：

public static void main(String[] args) {
//public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
     StringBuilder s= new StringBuilder();
     System.out.println("s："+s);
     System.out.println("s.length:"+s.length());
//public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
     StringBuilder s1 = new StringBuilder("hello");
     System.out.println("s1："+s1);
     System.out.println("s1.length()"+s1.length());
 }

Stringbulider的添加和反转方法：

 StringBuilder sb = new StringBuilder();
//public StringBuilder append(任意类型)：添加数据，并返回对象本身
 //StringBuilder sb2 = sb.append("hello");
//
// System.out.println("sb:" + sb);//hello
//System.out.println("sb2:" + sb2);//hello
 //System.out.println(sb == sb2);//表示地址值相同
// sb.append("hello");
// sb.append("world");
// sb.append("java");
// sb.append(100);
//链式编程
       sb.append("hello").append("world").append("java").append(100);
        System.out.println("sb:" + sb);
//public StringBuilder reverse()：返回相反的字符序列
        sb.reverse();
        System.out.println("sb:" + sb);
    }
}

StringBuilder和String相互转换
·StringBuilder转换为String
public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
·String转换为StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder

public class StringBuilderDemo02 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        sb.append("hello");
        String s =sb.toString();
        System.out.println(s);


        String s1="hello";
        StringBuilder sb1=new StringBuilder(s1);
        System.out.println(sb1);
    }
}

字符拼接升级版：

public class StringBuilderDemo02 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        sb.append("hello");
        String s =sb.toString();
        System.out.println(s);


        String s1="hello";
        StringBuilder sb1=new StringBuilder(s1);
        System.out.println(sb1);
    }
}

字符串拼接升级案例

public class StringBuilderTest01 {
    public static void main(String[] args) {
        //定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};
        String s = arrToString(arr);
        System.out.println(s);
        System.out.println(arrToString(arr));
    }
    public static String arrToString(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] ).append(",");
            }
        }
        sb.append("]");
        String s=sb.toString();
        return s;
    }
}

字符串反转案例升级版

public class StringBuilderTest02 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line=sc.nextLine();
        String s=myReverse(line);
        System.out.println("s:"+s);
    }public static String myReverse(String s){
        return new StringBuilder(s).reverse().toString();
    }
}

搬砖的考拉

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
day08

String:Java程序中的所有双引号字符串，都是字符String类的对象，在java.lang包下所以不需要导包。特点是：1.字符串是不可变得，它们的值在创建后不能被更改。2.虽然String的值是不可变得，但是他们能被共享。3.字符串效果上相当于字符组(插入[]，但是底层原理是字节数组(byte[]).常用构造方法：方法名 ...
复制链接

扫一扫