Java_字符串、静态Static、Arrays数组工具类

贪心的柠檬

已于 2022-03-01 17:16:48 修改

阅读量701

点赞数

分类专栏： Java从入门到入土文章标签： java 开发语言后端

于 2022-03-01 11:35:21 首次发布

本文链接：https://blog.csdn.net/qq_42627691/article/details/123201923

版权

Java从入门到入土专栏收录该内容

11 篇文章 1 订阅

订阅专栏

Java_字符串、静态Static、Arrays数组工具类

1.字符串

（1）特点：

字符串的内容不可变
字符串可以共享使用
字符串低层原理是byte[]字节数组

（2）字符串的三种构造方法：

public String()：创建一个空白字符串，不含有任何内容
public String(char[ ] array)：根据字符数组的内容，来创建对应的字符串
public String(byte[ ] array)：根据字节数组的内容，来创建对应的字符串

public class test{
    public static void main(String[] args){
        //使用空参构造
        String str1=new String();
        System.out.println("第一个字符串："+str1);
        System.out.println("================");

        //根据字符数组构造
        char[] charArray={'A','B','c'};
        String str2=new String(charArray);
        System.out.println("第二个字符串："+str2);
        System.out.println("================");

        //根据字节数组构造
        byte[] byteArray={97,98,99};
        String str3=new String(byteArray);
        System.out.println("第三个字符串："+str3);
        System.out.println("================");
    }
}

（3）直接创建
注意：直接写上双引号，就是字符串对象

public class test{
    public static void main(String[] args){
        //直接创建
        String str1="Abcd";
        System.out.println(str1);
    }
}

（4）字符串的常量池（堆）

对于引用类型来说，==进行的是地址值的比较
对于基本类型来说，==进行的是数值的比较
双引号直接写的字符串在常量池中，new的不在常量池中

public class test{
    public static void main(String[] args){
        String str1="abc";
        String str2="abc";

        char[] charArray={'a','b','c'};
        String str3=new String(charArray);

        System.out.println(str1==str2);//true
        System.out.println(str1==str3);//false
        System.out.println(str3==str2);//false
    }
}

代码分析：

在这里插入图片描述
（5）字符串中的内容比较方法一

equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样
如果比较双方一个常量一个变量，推荐把常量字符串写在前面

public class test{
    public static void main(String[] args){
        String str1="abc";
        String str2="abc";

        char[] charArray={'a','b','c'};
        String str3=new String(charArray);

        System.out.println(str1.equals(str2));//true
        System.out.println(str1.equals(str3));//true
        System.out.println(str3.equals("abc"));//true
        System.out.println("abc".equals(str3));//true
    }
}

（6）字符串中的内容比较方法二

equalsIgnoreCase()方法忽略大小写，直接进行内容的比较

public class test{
        public static void main(String[] args){
            String str1="abc";
    
            char[] charArray={'a','b','c'};
            String str2=new String(charArray);

            System.out.println(str1.equalsIgnoreCase("Abc"));//true
            System.out.println(str2.equalsIgnoreCase("Abc"));//true
            System.out.println("Abc".equalsIgnoreCase(str2));//true
        }
    }

（7）字符串获取的相关方法

length()：获取字符串长度
concat()：拼接字符串
charAt()：获取指定位置的字符（从0开始）
indexOf()：查找参数字符串在本字符串中首次出现的索引位置，如果没有则返回-1

public class test{
    public static void main(String[] args){
        //获取字符串长度
        String str0="hjjxhchjcahjcnaj";
        int length=str0.length();
        System.out.println(length);//16
        System.out.println("================");

        // 拼接字符串
        String str1="hello";
        String str2="world";
        String str3=str1.concat(str2);
        System.out.println(str3);//helloworld
        System.out.println("================");

        //获取指定位置的字符
        String str4="hello";
        char ch=str4.charAt(3);
        System.out.println(ch);//l
        System.out.println("================");

        //查找参数字符串在本字符串中首次出现的索引位置，如果没有则返回-1
        String str5="hellohello";
        int index1=str5.indexOf("ello");
        System.out.println(index1);//1
        System.out.println("================");
        int index2=str5.indexOf("abc");
        System.out.println(index2);//-1
    }
}

（8）字符串的截取方法

substring(int index)：从参数位置一直截取到字符串末尾
substring(int begin,int end)：从begin开始截取，到end结束；左闭右开区间

public class test{
    public static void main(String[] args){
        //从参数位置一直截取到字符串末尾
        String str1="helloworld";
        String str2=str1.substring(5);
        System.out.println(str2);//world

        //从begin开始截取，到end结束；左闭右开区间
        String str3="helloworld";
        String str4=str3.substring(4,7);//world
        System.out.println(str4);//owo
    }
}

（9）字符串的转换相关方法

toCharArray()：将字符串拆分成字符数组
getBytes()：获得字符串底层的字节数组
replace(oldString,newString)：将所有出现的老字符串，替换成新的字符串

public class test{
    public static void main(String[] args){
        //将字符串拆分成字符数组
        String str1="helloworld";
        char[] str2=str1.toCharArray();
        for(int i=0;i<str1.length();i++){
                System.out.println(str2[i]);
        }
        System.out.println("================");
        
        //获得字符串底层的字节数组
        byte[] bytes=str1.getBytes();
        for(int i=0;i<str1.length();i++){
                System.out.println(bytes[i]);
        }
        System.out.println("================");

        // 将所有出现的老字符串，替换成新的字符串
        String str3=str1.replace("o", "*");
        System.out.println(str3);
    }
}

（10）字符串的分割方法

split()：按照参数规则，将字符串切分成若干部分
如果按照英文句点".“进行切分，必须写成”\."

public class test{
    public static void main(String[] args){
        //字符串的分割方法
        String str1="aaa,bbb,ccc";
        String[] Array1=str1.split(",");
        for(int i=0;i<Array1.length;i++){
                System.out.println(Array1[i]);
        }
        System.out.println("================");

        String str2="aaa bbb ccc";
        String[] Array2=str2.split(" ");
        for(int i=0;i<Array2.length;i++){
                System.out.println(Array2[i]);
        }
        System.out.println("================");

        String str3="aaa.bbb.ccc";
        String[] Array3=str3.split("\\.");
        for(int i=0;i<Array3.length;i++){
                System.out.println(Array3[i]);
        }
    }
}

（11）练习

示例一：定义一个方法，把数组[1,2,3,4]按照指定格式拼接成一个字符串，参照格式如下：[word1#word2#word3#word4]

public class test{
    public static void main(String[] args){
        int[] array={1,2,3,4};
        String str=fromArrayToChar(array);
        System.out.println(str);
    }
    public static String fromArrayToChar(int[] array){
            String str="[";
            for(int i=0;i<array.length;i++){
                    if(i==array.length-1){
                            str+="word"+array[i]+"]";
                    }else{
                            str+="word"+array[i]+"#";
                    }
            }
            return str;
    }
}

示例二：统计输入的字符串中各种字符的个数

public class test{
    public static void main(String[] args){
        Scanner src=new Scanner(System.in);
        System.out.println("请输入字符串：");
        String input=src.next();

        int countUpper=0;//大写字母
        int countLower=0;//小写字母
        int countNumber=0;//数字
        int countother=0;//其他

        char[] charArray=input.toCharArray();
        for(int i=0;i<charArray.length;i++){
                char ch=charArray[i];
                if('A'<=ch&&ch<='Z'){
                        countUpper++;
                }else if('a'<=ch&&ch<='z'){
                        countLower++;
                }else if('0'<=ch&&ch<='9'){
                        countNumber++;
                }else{
                        countother++;
                }
        }

        System.out.println("大写字母个数："+countUpper);
        System.out.println("小写字母个数："+countLower);
        System.out.println("数字个数："+countNumber);
        System.out.println("其他个数："+countother);

    }
}

2.static关键字

（1）如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享一份数据
（2）一旦使用static关键字修饰成员方法，那就成为了静态方法，静态方法不属于对象，而是属于类的
（3）如果没有static关键字，那么必须先创建对象，然后通过对象来调用
（4）如果有static关键字，那么不需要先创建对象，直接通过类名称来进行调用来调用
（5）无论是成员变量，还是成员方法，如果有了static，都推荐使用类名称进行调用

静态变量：类名称.静态变量
静态方法：类名称.静态方法（）

（6）注意事项

静态不能直接访问非静态
静态方法中不能使用this

public class student{
    //普通成员方法 
    public void method() {
        System.out.println("普通成员方法");
    }

    //静态方法
    public static void methodStatic() {
        System.out.println("静态方法");
    }
}

public class test{
    public static void main(String[] args){
        student stu1=new student();
        stu1.method();//普通成员方法

        student.methodStatic();//普通成员方法
    }
}

（7）static关键字的内存图

根据类名称访问静态成员变量时，全程和对象无关，只与类有关系
代码部分：

public class test{
    public static void main(String[] args){
        student.room="101教室";
        student one=new student("郭靖",20);
        System.out.println("姓名 "+one.getName()+",年龄 "+one.getAge()+",班级 "+student.room);
        
        student two=new student("黄蓉",18);
        System.out.println("姓名 "+two.getName()+",年龄 "+two.getAge()+",班级 "+student.room);
    }
}

代码分析

在这里插入图片描述
（8）静态代码块

用途：一次性的对静态成员变量进行赋值
特点：当第一次用到本类时，静态代码块执行唯一的一次
注意：静态代码块总是优先于非静态
格式：

public class 类名称{
    static{
        静态代码块;
    }
}

public class student{
    //静态代码块
    static{
        System.out.println("静态代码块");
    }
    
    //构造方法
    public student(){
        System.out.println("构造方法");
    }
}

public class test{
    public static void main(String[] args){
        student one=new student();
        System.out.println("============");
        student two=new student();

    }
}
// 静态代码块
// 构造方法
// ============
// 构造方法

3.数组工具类Arrays

（1）toString(数组)：将参数数组变成字符串
（2）sort（数组）：默认按升序
（3）注意：

如果是数组，sort按照升序从小到大
如果是字符串，sort默认按照字母升序

public class test{
    public static void main(String[] args){
        //将参数数组变成字符串
        int[] array1={1,4,73};
        String str1=Arrays.toString(array1);
        System.out.println(str1);//[1, 4, 73]

        int[] array2={52,77,21,23,32};
        //排序
        Arrays.sort(array2);
        //将参数数组变成字符串
        System.out.println(Arrays.toString(array2));//[21, 23, 32, 52, 77]

        String[] array3={"aaa","ddd","ccc"};
        Arrays.sort(array3);
        System.out.println(Arrays.toString(array3));//[aaa, ccc, ddd]
    }
}

（4）练习：将一个随机字符串中的所有字符升序排列，并倒序打印

public class test{
    public static void main(String[] args){
        //随机字符串
        String str="hagcaiaduiqiu5668";

        //将字符串--->数组
        char[] ch=str.toCharArray();

        //升序排列
        Arrays.sort(ch);

        //正序打印
        for(int i=0;i<ch.length;i++){
            System.out.print(ch[i]);
        }

        System.out.println();
        System.out.println("=================");

        //倒序打印
        for(int i=ch.length-1;i>=0;i--){
            System.out.print(ch[i]);
        }
    }
}
//5668aaacdghiiiquu
//=================
//uuqiiihgdcaaa8665

4.数学工具类Math

（1）abs()：获取绝对值
（2）ceil()：向上取整
（3）floor()：向下取整
（4）round()：四舍五入

示例一：

public class test{
    public static void main(String[] args){
        //获取绝对值
        System.out.println(Math.abs(1.3));//1.3
        System.out.println(Math.abs(0));//0
        System.out.println(Math.abs(-1.3));//1.3
        System.out.println("=================");

        //向上取整
        System.out.println(Math.ceil(3.1));//4.0
        System.out.println(Math.ceil(3.9));//4.0
        System.out.println(Math.ceil(3.0));//3.0
        System.out.println("=================");

        //向下取整
        System.out.println(Math.floor(6.9));//6.0
        System.out.println(Math.floor(6.1));//6.0
        System.out.println(Math.floor(6.0));//6.0
        System.out.println("=================");

        //四舍五入
        System.out.println(Math.round(5.9));//6
        System.out.println(Math.round(5.3));//5
        System.out.println("=================");
    }
}

示例二：计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

public class test{
    public static void main(String[] args){
        //计数器
        int count=0;

        //最小值
        double min=-10.8;

        //最大值
        double max=5.9;

        //取绝对值并输出
        for(int i=(int) min;i<max;i++){
                int abs=Math.abs(i);
                if(abs>6||abs<2.1){
                        System.out.println(abs);
                        count++;
                }
        }
        System.out.println("整数有多少个： "+count);
    }
}

贪心的柠檬

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java_字符串、静态Static、Arrays数组工具类

Java_字符串、静态Static、Arrays数组工具类1.字符串（1）特点：字符串的内容不可变字符串可以共享使用字符串低层原理是byte[]字节数组（2）字符串的三种构造方法：public String()：创建一个空白字符串，不含有任何内容public String(char[ ] array)：根据字符数组的内容，来创建对应的字符串public String(byte[ ] array)：根据字节数组的内容，来创建对应的字符串public class test{
复制链接

扫一扫

专栏目录