08 String类、static、Math类、Arrays类

于 2021-05-13 17:32:25 发布
阅读量392 收藏
点赞数
分类专栏： # JavaSE基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41447498/article/details/116758626
版权

目录

第1章 String类

1.1 String类概述

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如"abc" ）都可以被看作是实现此类的实例。

类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

特点：

1.字符串不变：字符串的值在创建后不能被更改。

String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

2.因为String对象是不可变的，所以它们可以被共享。

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

3."abc" 等效于 char[] data={ 'a' , 'b' , 'c' } 。

例如：
String str = "abc";
相当于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
// String底层是靠字符数组实现的。

1.2 使用步骤

查看类：

java.lang.String ：此类不需要导入。

查看构造方法：

  • public String() ：初始化新创建的 String对象，以使其表示空字符序列。
  • public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
  • public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。

构造举例：

// 无参构造
String str = new String（）；
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);

1.3 常用方法

判断功能的方法：

  • public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
  • public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

举例：

public class String_Demo01 {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "HELLO";
        
        // boolean equals(Object obj):比较字符串的内容是否相同
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // false

        //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2)); // true
        System.out.println(s1.equalsIgnoreCase(s3)); // true

    }
}

Object 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。

获取功能的方法：

  • public int length () ：返回此字符串的长度。
  • public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
  • public char charAt (int index) ：返回指定索引处的 char值。
  • public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
  • public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
  • public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

举例：

public class String_Demo02 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "helloworld";
        
        // int length():获取字符串的长度，其实也就是字符个数
        System.out.println(s.length());

        // String concat (String str):将将指定的字符串连接到该字符串的末尾.
        String s = "helloworld";
        String s2 = s.concat("**hello itheima");
        System.out.println(s2);// helloworld**hello itheima
        
        // char charAt(int index):获取指定索引处的字符
        System.out.println(s.charAt(0));
        System.out.println(s.charAt(1));
        System.out.println("‐‐‐‐‐‐‐‐");
        
        // int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
        System.out.println(s.indexOf("l"));
        System.out.println(s.indexOf("owo"));
        System.out.println(s.indexOf("ak"));
        System.out.println("‐‐‐‐‐‐‐‐");
        
        // String substring(int start):从start开始截取字符串到字符串结尾
        System.out.println(s.substring(0));
        System.out.println(s.substring(5));
        System.out.println("‐‐‐‐‐‐‐‐");
        
        // String substring(int start,int end):从start到end截取字符串。含start，不含end。
        System.out.println(s.substring(0, s.length()));
        System.out.println(s.substring(3,8));
    }
}

转换功能的方法：

  • public char[] toCharArray () ：将此字符串转换为新的字符数组。
  • public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
  • public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

举例：

public class String_Demo03 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "abcde";
        
        // char[] toCharArray():把字符串转换为字符数组
        char[] chs = s.toCharArray();
        for(int x = 0; x < chs.length; x++) {
        	System.out.println(chs[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        
        // byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes = s.getBytes();
        for(int x = 0; x < bytes.length; x++) {
        	System.out.println(bytes[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        
        // 替换字母it为大写IT
        String str = "itcast itheima";
        String replace = str.replace("it", "IT");
        System.out.println(replace); // ITcast ITheima
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
    }
}

CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

分割功能的方法：

  • public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

举例：

public class String_Demo03 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "aa|bb|cc";
        String[] strArray = s.split("|"); // ["aa","bb","cc"]
        for(int x = 0; x < strArray.length; x++) {
        	System.out.println(strArray[x]); // aa bb cc
        }
    }
}

1.4 String类的练习

拼接字符串：

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

public class StringTest1 {
    public static void main(String[] args) {
        //定义一个int类型的数组
        int[] arr = {1, 2, 3};
        
        //调用方法
        String s = arrayToString(arr);
        
        //输出结果
        System.out.println("s:" + s);
    }
    
    /*
        写方法实现把数组中的元素按照指定的格式拼接成一个字符串
        两个明确：
        返回值类型：String
        参数列表：int[] arr
    */
    public static String arrayToString(int[] arr) {
        // 创建字符串s
        String s = new String("[");
        
        // 遍历数组，并拼接字符串
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length ‐ 1) {
            	s = s.concat(arr[x] + "]");
            } else {
            	s = s.concat(arr[x] + "#");
            }
        }
        return s;
    }
}

统计字符个数：

键盘录入一个字符，统计字符串中大小写字母及数字字符个数。

public class StringTest2 {
    public static void main(String[] args) {
        //键盘录入一个字符串数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串数据：");
        String s = sc.nextLine();
        
        //定义三个统计变量，初始化值都是0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        
        //遍历字符串，得到每一个字符
        for (int x = 0; x < s.length(); x++) {
            char ch = s.charAt(x);
            //拿字符进行判断
            if (ch >= 'A' && ch <= 'Z') {
            	bigCount++;
            } else if (ch >= 'a' && ch <= 'z') {
            	smallCount++;
            } else if (ch >= '0' && ch <= '9') {
            	numberCount++;
            } else {
            	System.out.println("该字符"+ch+"非法");
            }
        }
        
        //输出结果
        System.out.println("大写字符："+bigCount+"个");
        System.out.println("小写字符："+smallCount+"个");
        System.out.println("数字字符："+numberCount+"个");
    }
}

第2章 static关键字

2.1 概述

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

2.2 定义和使用格式

类变量：使用 static 关键字修饰的成员变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

定义格式：

static 数据类型 变量名；

举例：

static int numberID；

比如说，基础班新班开班，学员报到。现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为1，以此类推。学号必须是唯一的，连续的，并且与班级的人数相符，这样以便知道，要分配给下一名新同学的学号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。

所以，我们可以这样定义一个静态变量numberOfStudent，代码如下：

public class Student {
    private String name;
    private int age;
    // 学生的id
    private int sid;
    // 类变量，记录学生数量，分配学号
    public static int numberOfStudent = 0;
    
    public Student(String name, int age){
        this.name = name;
        this.age = age;
        // 通过 numberOfStudent 给学生分配学号
        this.sid = ++numberOfStudent;
    }
    
    // 打印属性值
    public void show() {
    	System.out.println("Student : name=" + name + ", age=" + age + ", sid=" + sid );
    }
}

public class StuDemo {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        s1.show(); // Student : name=张三, age=23, sid=1
        s2.show(); // Student : name=李四, age=24, sid=2
    }
}

类方法：使用 static 关键字修饰的成员方法，习惯称为静态方法。静态方法在声明中有static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

定义格式：

修饰符 static 返回值类型 方法名 (参数列表){
	// 执行语句
}

举例：在Student类中定义静态方法

public static void showNum() {
	System.out.println("num:" + numberOfStudent);
}

静态方法调用的注意事项：

  1. 静态方法可以直接访问类变量和静态方法。
  2. 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
  3. 静态方法中，不能使用this关键字。

Tips：静态方法只能访问静态成员。

调用格式：

被 static 修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式：

// 访问类变量
类名.类变量名；

// 调用静态方法
类名.静态方法名(参数)；

举例：

public class StuDemo2 {
    public static void main(String[] args) {
        // 访问类变量
        System.out.println(Student.numberOfStudent);
        // 调用静态方法
        Student.showNum();
    }
}

2.3 静态原理图解

static 修饰的内容：

  • 是随着类的加载而加载的，且只加载一次。
  • 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
  • 它优先于对象存在，所以，可以被所有对象共享。

在这里插入图片描述

2.4 静态代码块

静态代码块：定义在成员位置，使用static修饰的代码块{ }。

  • 位置：类中方法外。
  • 执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
  • 作用：给类变量进行初始化赋值。

格式：

public class ClassName{
    static {
    	// 执行语句
    }
}

举例：

public class Game {
    public static int number;
    public static ArrayList<String> list;
    
    static {
        // 给类变量赋值
        number = 2;
        list = new ArrayList<String>();
        // 添加元素到集合中
        list.add("张三");
        list.add("李四");
}

static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。下面将介绍两个工具类，来体现static 方法的便利。

第3章 Math类

3.1 概述

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

3.2 基本运算的方法

  • public static double abs(double a) ：返回 double 值的绝对值。
double d1 = Math.abs(‐5); //d1：5
double d2 = Math.abs(5); //d2：5
  • public static double ceil(double a) ：返回大于等于参数的最小的整数。
double d1 = Math.ceil(3.3); //d1：4.0
double d2 = Math.ceil(-3.3); //d2：‐3.0
double d3 = Math.ceil(5.1); //d3：6.0
  • public static double floor(double a) ：返回小于等于参数最大的整数。
double d1 = Math.floor(3.3); //d1：3.0
double d2 = Math.floor(-3.3); //d2：‐4.0
double d3 = Math.floor(5.1); //d3：5.0
  • public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
long d1 = Math.round(5.5); //d1：6
long d2 = Math.round(5.4); //d2：5

3.3 练习

请使用Math 相关的API，计算在 -10.8 到5.9 之间，绝对值大于6 或者小于2.1 的整数有多少个？

public class MathTest {
    public static void main(String[] args) {
        // 定义最小值
        double min = ‐10.8;
        // 定义最大值
        double max = 5.9;
        // 定义变量计数
        int count = 0;
        
        // 范围内循环，初始值为大于最小值的第一个整数
        for (double i = Math.ceil(min); i <= max; i++) {
            // 获取绝对值并判断
            if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
                // 计数
                count++;
            }
        }
        System.out.println("个数为: " + count + " 个");
    }
}

第4章 Arrays类

4.1 概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

4.2 操作数组的方法

  • public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
public static void main(String[] args) {
    // 定义int 数组
    int[] arr = {2,34,35,4,657,8,69,9};
    // 打印数组,输出地址值
    System.out.println(arr); // [I@2ac1fdc4
    
    // 数组内容转为字符串
    String s = Arrays.toString(arr);
    // 打印字符串,输出内容
    System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9]
}
  • public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
public static void main(String[] args) {
    // 定义int 数组
    int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
    System.out.println("排序前:"+ Arrays.toString(arr)); // 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6,2]
    
    // 升序排序
    Arrays.sort(arr);
    System.out.println("排序后:"+ Arrays.toString(arr));// 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46,
    48]
}

4.3 练习

请使用Arrays 相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。

public class ArraysTest {
    public static void main(String[] args) {
        // 定义随机的字符串
        String line = "ysKUreaytWTRHsgdSoidq";
        // 转换为字符数组
        char[] chars = line.toCharArray();
        
        // 升序排序
        Arrays.sort(chars);
        // 反向遍历打印
        for (int i = chars.length‐1; i >= 0 ; i‐‐) {
        	System.out.print(chars[i]+" "); // y y t s s r q o i g e d d a W U T S R K H
        }
    }
}
ashore3000
关注
专栏目录
接口、 多态
m0_48960643的博客
07-06 1214
接口、 多态
08【String类、static、Arrays类、Math类】1
08-04
【String类】 Java中的`String`类是用于表示文本数据的类，它位于`java.lang`包下，是所有Java程序的基础。`String`对象是不可变的，这意味着一旦创建了一个`String`对象，就不能改变它的内容。这是因为字符串在Java...
【String类、static关键字、Arrays类、 Math类】
丢失了名字的琥珀川
09-16 277
前言 在计算机科学中，算法的时间复杂度是一个函数，它定性描述了该算法的运行时间。这是一个关于代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。 衡量代码的好坏包括两个非常重要的指标 运行时间(算法执行时间) 占用空间（算法所需要占用的存储空间） 度量算法 用常数1取代运行时间中的所有加法常数 在修改后的运行次数函数中，只保...
接口 多态
weixin_42943720的博客
08-30 199
接口 接口；是Java语言的一种引用类型，是方法的集合。接口的内部主要就是封转了方 法。抽象方法1.7jdk。 静态方法和默认方法1.8jdk。私有方法1.9jkd。接口，用inerface来进行修饰，他会产生class 文件，但主要的它不是一个类，只不过是一个引用类型的方法。 引用数据类型；数据， 类，接口。 接口的使用；他不能够被用来创建对象，他可以用被实现 用implemen...
接口 多态
wyq15004350208的博客
08-12 313
一、接口     (1)接口的定义:因为继承只能单继承，我们为了实现多继承，所以我们需要使用接口来实现多继承。                             接口实际上是一种规范，连接接口的类或接口必须满足本接口的内容。    (2)接口的特点:               ①接口使用interface关键字，而不是class。接口也是特殊的抽象类。              ...
接口 多态
weixin_30535043的博客
05-18 162
接口 Interface 比抽象类更抽象的类，只描述所该具备的方法，没有方法体，由接口的实现类(相当于子类)去实现。 ①接口里只能是抽象方法 ② 接口中无法定义普通成员变量 定义格式： public interface 接口名 { 抽象方法1; 抽象方法2; 抽象方法3; } 特点: l 接口中的方法均为公共访问的抽象方法 　　2 无法定义普通的成员变量 类...
08.【String类、static、Arrays类、Math类】.zip
01-31
Java编程语言中，`String`类、`static`关键字、`Arrays`类和`Math`类是四个核心概念，它们在日常开发中扮演着至关重要的角色。下面将逐一详细阐述这些知识点。 首先，`String`类是Java中最常用的数据类型之一，它...
接口多态
我的标题
07-12 2368
接口多态 什么是多态 多态是指一个对外接口，多种实现方式，即一个接口使用不同实例执行不同的操作 ，它分为两种——方法重写（运行时多态） 简单来说，多态是具有表现多种形态的能力的特征 向同一父类的不同子类对象发送同一条消息，行为不同。 实现多态的步骤 1、子类重写父类的方法 2、编写方法时，参数使用父类对象，并调用父类定义的方法 3、运行时，根据实际创建的对象类型动态决定使用哪个方法 抽象类和抽象方...
接口的多态
cql_yao10k的博客
12-04 370
多态：必须得有继承，而且父类的指针指向子类的对象就叫多态接口：接口也叫类，不过它不是用class类修饰类名的，而是用interface关键字来修饰类名的，它没有构造方法，有属性，有普通方法，不过这个普通方法在编译器中是用abstract关键字修饰的抽象类，并且这个抽象方法只能被用作某个类的实现重写，而这个类就叫这个接口的实现类。接口的多态：顾名思义就是接口这种类的多态，特殊的多态。接口引用类型的变量
接口的多态实现
03-23
接口多态的实现，引用，对于初学者是一份比较好的课程文件
接口、多态
huangyh技术栈
08-15 308
吃饭,睡觉,走路是人本来就应该具备的功能。但是有些功能是一部分人才会的比如打麻将，斗地主，游泳等。如果将打麻将，斗地主定义到人类里面的话，所有人都会打麻将了。这样显然不合适，为了体现事物 的扩展性Java 中就提供了接口来定义这些额外功能。 class 类名 {         成员变量         成员方法     }     类中会放成员变量和成员方法  什么是接口:接口也是...
Java接口与多态
milan_kudera的博客
09-27 100
Java接口与多态 接口 接口概述与实现 接口，是Java语言中的一种引用类型，是方法的集合，与类相比（内部封装了成员方法、成员变量、构造方法和成员方法），那么接口内部主要是封装了方法，包括抽象方法，默认方法和静态方法，私有方法。 与类不同的是，接口使用interface关键字。但是同样接口文件也是被编译为.class文件。 引用数据类型：数组，类，接口。 接口不能创建对象，但是可以被实现（implements）。如果一个类implements了接口，那么必须要实现接口中所有的抽象方法，创建该类对象，就
多态、接口
谢伯剑的博客
09-26 679
多态总结： 1）使用父类类型的 引用指向子类的对象。 该引用只能调用父类中定义的方法，不能调用子类中独有的方法。 如果子类中重写了父类中的一个方法，那么在调用该方法的时候，将会调用子类中的方法。 在多态中，子类可以调用父类中的所有方法。 多态主要体现为重载和重写。相同的行为不同的实现方式 多态主要应用为多态参数和多态集合 如果一个方法中有父类作为参数类型，就意味着可以给
接口实现多态
weixin_34357267的博客
03-22 293
1.什么事接口 01.接口就是为了约束方法的格式(参数和返回值类型)而存在的 02.接口可以实现多继承，弥补单继承的缺陷。 　03.接口可以看成是一个特殊的抽象类，通过反编译看源码可知 04.接口中方法不用访问修饰符，因为CLR会自动添加，并且不能有方法体 05.如果一个类实现了某个接口，就得实现该接口中所有的方法 06.接口要谨慎使用...
Java String类、static与Arrays、Math详解
"本资料详细介绍了Java编程中的String类、static关键字、Arrays类以及Math类。涵盖了String类的概述、特点、构造方法和常用方法，static关键字的作用，Arrays类对数组的操作，以及Math类的数学运算功能。" String类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值