java入门基础---1.7---类的使用，String类及常用方法汇总

小梁の同学

已于 2022-07-26 16:47:57 修改

阅读量157

点赞数

分类专栏： Java源码文章标签： java jvm 开发语言 idea 其他

于 2022-07-22 21:52:37 首次发布

本文链接：https://blog.csdn.net/weixin_50123823/article/details/125940570

版权

Java源码专栏收录该内容

15 篇文章 0 订阅

订阅专栏

小梁同学の

Java学习旅途

你好！这是小梁同学使用博客所记录的文章笔记，作为一个初学者的从基础到未来的记录，如果你想和我一起在Java学习路程上坚持下去，欢迎你的关注与指正。

新的将来

万丈高楼平地起，未来只能靠自己
从无到有，从零到一，学习路上没有尽头
每日一文，每日一记，跟着软件向前努力
加油！！！！！

详解代码均在以下标题后的链接中

以下所有有关代码，都是个人在上完课后自己重新敲代码之后所做笔记后上传，并非原搬直接上传，谢谢理解

十一.类的使用

1.基础类使用

1 定义类

2 创建对象

3 调用方法，实现功能

2.Java api中的类使用

1 创建对象

2 调用方法

1.字符常用类

1.String 类

//简单字符串的创建
        String a = "abcdef";
        System.out.println(a);
==================
    abcdef
    
//        new的方式
        String s = new String("abcd");
        System.out.println(s);
==================
    abcd
    
//        字节和字符数组转字符串方法的使用，构造方法
        byte[] bytes ={97,98,99,48,49};
//        字节数组转成了字符串======>文件操作
        String s1 = new String(bytes);
        System.out.println(s1);
==================
    abc01
    
//        java 过时的方法，不推荐使用
//        String s2 = new String(bytes,1);
//==================
//    bc01
    
//        字节数组转成字符串，
//        从字节数组的哪个位置开始转换，到哪个位置结束
        String s2 = new String(bytes,dffset:0,length:3);
        System.out.println(s2);
==================
    abc

        char[] arr = {'a','中','a','4','7'};
        String s3 = new String(arr);
        System.out.println(s3);
        String s4 = new String(arr,offset:0,count:3);
        System.out.println(s4);
==================
    a中a47
    a中a

2.String类中的常用方法

String a = "abcdef";
        //获取字符串长度
        System.out.println(a.length());
===============
	6
        //取出字符串中某个字符
        System.out.println(a.charAt(1));
===============
    b
        //所有字符输出
        for (int i=0;i<a.length();i++){
            System.out.println(a.charAt(i));
        }
===============
    a
	b
	c
	d
	e
	f
        //字符串转为char数组
        char[] chars = a.toCharArray();
        for (char c:chars
            ){
            System.out.println(c);
        }
===============
    a
	b
	c
	d
	e
	f
    	//字符串转为byte数组
    	byte[] bytes=a.getBytes();
            for (byte b:bytes
                 ) {
        System.out.println(b);
    	}
===============    
    97
	98
	99
	100
	101
	102

String a = "abce.defg.txt";
        //自左向右获取字符串中某个字符串的位置,没有指定的数据返回 -1
        System.out.println(a.indexOf("."));
        //返回数字对应的字符(数字或者char)的位置
        System.out.println(a.indexOf(101));
        //指定开始的位置进行数字对应字符(数字或者char)的查找
        System.out.println(a.indexOf('e', 5));
        //指定开始的位置进行数字对应字符串的查找
        System.out.println(a.indexOf(".",5));
==================
    4
	3
	6
	9
    
String a = "abce.defg.txt";
        //自右向左获取字符串中某个字符串的位置,没有指定的数据返回 -1
        System.out.println(a.lastIndexOf("."));
        //返回数字对应的字符(数字或者char)的位置
        System.out.println(a.lastIndexOf(101));
        //指定开始的位置进行数字对应字符(数字或者char)的查找
        System.out.println(a.lastIndexOf('e', 5));
        //指定开始的位置进行数字对应字符串的查找
        System.out.println(a.lastIndexOf(".",5));
        //获取到最后一个.的位置
        System.out.println(a.lastIndexOf("."));
===================
    9
	6
	3
	4
	9
    
String a = "abce.defg.txt";
    	int i = a.lastIndexOf(".");//获取到最后一个.的位置
        //截取字符串
        // 传入一个参数，截取的开始，默认截取到末尾
        System.out.println(a.substring(i+1));
        // 传入两个参数，第一个是截取的开始，第二个是截取的结尾
        // [ 0,3)（不包含结尾下标的值）
        System.out.println(a.substring(0,3));
===================
    txt
    abc
    
String a = "abce.defg.txt";
    	//判断字符串是不是以什么结束
        System.out.println(a.endsWith("txt"));
        //判断字符串是不是以什么开始
        System.out.println(a.startsWith("abc"));
===================
    true
    true
    
String a = "abcE.deFg.tXt";
		//转大写
        System.out.println(a.toUpperCase());
        //转小写
        System.out.println(a.toLowerCase());
        //判断是否是空串
        System.out.println(a.isEmpty());
        //去除前后空白的方法
        System.out.println(a.trim());
        //用指定的字符替换原来字符串中的字符
        System.out.println(a.replace('.', '*'));
===================
     ABCE.DEFG.TXT
 	 abce.defg.txt
	false
	abcE.deFg.tXt
 	 abcE*deFg*tXt
    
String a = "abcdefghedk";
		//字符串按照指定规则(e)切割成多个(3个)字符串
        String[] es = a.split("e",3);
        for (String j:es
        ) {
            System.out.println(j);
        }
===================
    abcd
	fgh
	dk

String a="abgchdxhgs";
        //把指定的字符串进行替换
        System.out.println(a.replaceAll("g","s123" ));
        //只替换第一个指定的字符串
        System.out.println(a.replaceFirst("g", "s123"));
===================
    abs123chdxhs123s
	abs123chdxhgs

3.字符串不可变（final）

字符串底层是通过final修饰的char数组进行的字符存储

String类中代码不能被更改，String不能有子类

Final修饰的char数组只能在String类中进行赋值

Final修饰的char数组，在构造方法中进行的赋值

1.字符串不可变

//t 是一个变量，任意的赋值
        String t = "abc";
        t="bcd";

2.方法调用形成的字符串

//字符串没有被更改，方法调用后，形成了新的字符串
        System.out.println("abc".toUpperCase());;

3.基本数据类型值不能变

//基本数据类型值不能变
        final int f =1;

4.引用数据类型地址不能变

//引用数据类型地址不能变
        final int[] arr = new int[10];
        for (int j = 0; j < arr.length; j++) {
            arr[j]=j;
        }

4.创建字符串的对象（两种）

1 双引号：堆区分配了空间，字符串常量池

2 new 构造方法：===》存在于堆区

创建的方式不同，地址不同

String s = "abc";
String s1 = new String("abc");
System.out.println(s==s1);
==================
    false

5."=="与“equals”

== 关系运算符：比较基本数据类型，比较的是基本数据类型的值，比较的是地址

equals方法：String类重写了Object中的equals方法，满足自己的逻辑，进行字符串中每个值的比较

String s = "abc";
String s1 = new String("abc");
System.out.println(s.equals(s1));
==================
    true

向下转型：

Animal a = new Animal();
//向下转型，先判断类型是否相同
//对象 instanceof 类型  是，结果是true，否则，结果是false
if (a instanceof Cat){
	Cat c = (Cat) a;
	System.out.println(c);
}else{
	System.out.println("类型不匹配");
}
=====================
    false

如果要进行向下转型，必须建立再向上转型的基础上

public static Animal test2(int a){
    if (a>10){
        return new Cat();
    }else{
        return new Dog();
    }
}
public static void main(String[] args) {
    //基于向上转型，进行向下转型
    Animal test=test2(10);
    if (test instanceof Cat){
        Cat c = (Cat)test;
        System.out.println(c);
    }else if (test instanceof Dog){
        Dog d = (Dog) test;
        System.out.println(d);
    }
}
=======================
    Dog{color='null'}Animal{name='null', age=0}

引出String中重写的.eqlues方法

字符串调用equals方法是，传入的参数给Object类型，向上转型

进行字符串比较，进行了向下转型

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
    //向下转型
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

6.静态方法

//其他数据类型转字符串
//String.valueOf(0);
        char[] chars = {'a','b','c'};
// 数组转字符串
        System.out.println(String.copyValueOf(chars));
======================
    abc

进行控制台数据，输入得接收，而后做判断

		Scanner input = new Scanner(System.in);
        String s = input.next();
        int num1 = 0;
        int num2 = 0;
        int num3 = 0;
//        char[] chars=s.toCharArray();
//        for (char c:chars
//             ) {
//            if (c>=48&&c<=57){
//                num1++;
//            }else if (c>=97&&c<=122||c>=65&&c<=90){
//                num2++;
//            }else {
//                num3++;
//            }
//        }
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c>=48&&c<=57){
                num1++;
            }else if (c>=97&&c<=122||c>=65&&c<=90){
                num2++;
            }else {
                num3++;
            }
        }
        System.out.println("数字："+num1);
        System.out.println("字母："+num2);
        System.out.println("符号："+num3);
=======================
    scfuii2115466*())_
	数字：7
	字母：6
	符号：5

随机数：

		String str = "0123456789zxcvbnmasdfghjklqwertyuiopZXCVBNMASDFGHJKLQWERTYUIOP";
        //随机数
        Random rand=new Random();
        String s="";
        for (int i = 0; i < 4; i++) {
            int num=rand.nextInt(str.length());
            s+=str.charAt(num);
        }
        System.out.println(s);

StringBuilder:

		StringBuilder sbr = new StringBuilder("1234");
//默认在末尾拼接
        System.out.println(sbr.append(true));
//指定位置得拼接
        System.out.println(sbr.insert(0,"&&" ));
//删除指定范围得数据[0,4)
        System.out.println(sbr.delete(0, 4));
//替换[0,3)
        System.out.println(sbr.replace(0, 3, "feoidjfkdsjflkdjfkd"));
//倒序输出
        System.out.println(sbr.reverse());
============================
    1234true
	&&1234true
	34true
	feoidjfkdsjflkdjfkdrue
	eurdkfjdklfjsdkfjdioef

StringBuilder拼接生成随机数：

		String str = "0123456789zxcvbnmasdfghjklqwertyuiopZXCVBNMASDFGHJKLQWERTYUIOP";
//随机数
        Random rand=new Random();
        StringBuilder s=new StringBuilder();
        for (int i = 0; i < 4; i++) {
            int num=rand.nextInt(str.length());
            s.append(str.charAt(num));
        }
        System.out.println(s);