Java语言入门||02_面向对象与常用类||day08_String类，static，Arrays类，Math类

第一章 String类

1.1 字符串的概述和特点

java.lang.String类代表字符串
API当中说：Java程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。
- ++其实就是说：程序当中所有的双引号字符串，都是String类的对象。++（++就是没有new，也照样是++）
String的特点：
1. 字符串的内容永不可变【重点】(—常量)
2. 正是因为字符串不可改变，所以字符串是可以共享使用的
3. 字符串效果上相当于char[]字符数组，但是底层原理是byte[]字节数组

注：byte是数据的最小存储单位

1.2 字符串的构造方法和直接创建

创建字符串的常见3+1种方法
1. 三种构造方法：
  - public String()：创建一个空白字符串，不含有任何内容
  - public String(char[] array)：根据字符数组的内容，来创建对应的字符串
  - public String(byte[] array)：根据字节数组的内容，来创建对应的字符串
2. 一种直接创建：
  - String str = “hello”; //右边直接用双引号

注：直接写上双引号，就是字符串对象（JVM帮new了）

    //使用空参构造
    String str1 = new String();  //小括号留空，说明字符串什么内容都没有
    System.out.println("第一个字符串：" + str1);

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

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

    //直接创建
    String str4 = "hello";
    System.out.println("第四个字符串：" + str4);

1.3 字符串的常量池

字符串常量池：程序当中++直接写上的双引号字符串++，++就在字符串常量池中++（从1.7开始在堆当中）

注：对于基本数据类型来说：==是进行数值的比较
注：对于引用数据类型来说：==是进行地址值的比较
注：整数相除不做四舍五入，直接向下取整。
- ++12345 / 10 = 1234++不是1235

1.4 字符串的比较相关方法

==是进行对象的++地址值++比较，如果确实需要字符串的内容比较，可以使用两个方法：

public boolean equals(Object obj)：参数可以是任意对象,只有参数是一个字符串并且内容相同的才给true，否则false
- 任何对象都能用Object接收
- equals方法具有对称性：也就是a.equals(b)和b.equals(a)效果一样
- 如果比较双方一个常量一个变量，推荐把常量字符串写在前面（++“abc”.equals(b)++,如果常量放后面，前面是个null就会空指针异常）
public boolean equalsIgnoreCase(String str)：++忽略大小写，进行内容比较++(只区分英文字母大小写)

    String str1 = "yes";
    String str2 = "yes";
    char[] charArray = {'y', 'e', 's'};
    String str3 = new String(charArray);

    System.out.println(str1.equals(str2));
    System.out.println(str1.equals(str3));
    System.out.println(str3.equals("yes"));
    System.out.println("yes".equals(str3));

    String str4 = "Yes";
    System.out.println(str4.equals(str1));
    System.out.println("===============");

    String str5 = null;
    System.out.println("abc".equals(str5)); //false
    //System.out.println(str5.equals("abc"));   //空指针异常
    System.out.println("===============");

    String str6 = "Java";
    String str7 = "java";
    System.out.println(str6.equals(str7));
    System.out.println(str6.equalsIgnoreCase(str7));

1.5 字符串的获取相关方法

String中与获取相关的方法

public int length()：获取字符串当中含有的字符个数，拿到字符串长度
- 注：数组length没有括号，字符串length()有
public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串（用+也行）
public char charAt(int index)：++获取指定++索引位置的++单个字符++（索引从0开始）
public int indexOf(String str)：查找参数字符串在本字符串当中++首次出现的索引的位置++，如果++没有返回-1++

    //获取字符串长度
    int len = "jflasjfjaskfjiasighasnhoias".length();
    System.out.println("字符串的长度是：" + len);
    //拼接字符串
    String str1 = "Hello";
    String str2 = "World";
    String str3 = str1.concat(str2);
    System.out.println(str1);
    System.out.println(str2);
    System.out.println(str3);
    //获取指定索引位置的单个字符
    char ch = "Hello".charAt(1);
    System.out.println("第1个索引位置的字符是：" + ch);
    //查找参数字符串在本来字符串当中出现的第一次索引位置
    String original = "HelloWorld";
    int index = original.indexOf("llo");
    System.out.println("第一次索引值是：" + index);
    int index1 = original.indexOf("lle");
    System.out.println("第二次索引值是：" + index1);

1.6 字符串的截取相关方法

字符串的截取方法
1. public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
2. public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串
  - 注：[begin, end)：包含左边，不包含右边.
- 注：++substring中的s小写++
```
    String str1 = "HelloWorld";
    String str2 = str1.substring(5);
    System.out.println(str1);
    System.out.println(str2);
    System.out.println("==========");
    String str3 = str1.substring(4, 7);
    System.out.println(str3);
```

注：
- 下面这种写法，字符串内容仍然没有改变
- 有两个字符串:“Hello”,“Java”
- strA当中保存的是地址值
- 本来地址是Hello的0X666
- 变成后来的Java的0X999
```
    String strA = "Hello";
    System.out.println(strA);
    strA = "Java";
    System.out.println(strA);
```

1.7 字符串的转换相关方法

String当中与转换相关的方法

public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获取当前字符串底层的字节数组(“abc”–>97 98 99)
public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串
- CharSequence意思就是说可以接收字符串类型

            //转换成字符数组
    char[] chars = "Hello".toCharArray();
    System.out.println(chars[0]);
    System.out.println(chars.length);
    //转换成字节数组
    byte[] bytes = "abc".getBytes();
    //遍历
    /*for (int i = 0; i < bytes.length; i++) {
        System.out.println(bytes[i]);
    }*/
    for(byte by : bytes){
        System.out.print(by + " ");
    }
    System.out.println("==========");
    String str1 = "How do you do?";
    String str2 = str1.replace("o", "*");
    System.out.println(str1);
    System.out.println(str2);
    System.out.println("==========");
    String lang1 = "会不会玩？你大爷的!,你大爷的!,你大爷的!!!";
    String lang2 = lang1.replace("你大爷的!", "****");
    System.out.println(lang1);
    System.out.println(lang2);

1.8 字符串的分割相关方法

分割字符串的方法

public String[] split(String regex)：按照参数的规则，将字符串切分成若干部分
- ++注：切割出来就算是d一个也是字符串++
- 注：".“切不了要写成”\\."(两个反斜杠)，数组长度0，循环为空
- 注：++split方法的参数其实是一个‘正则表达式’，++

    String str1 = "aaa,bbb,ccc";
    String[] array1 = str1.split(",");
    /*for (int i = 0; i < array1.length; i++) {
        System.out.println(array1[i]);
    }*/
    for(String ary : array1){
        System.out.println(ary);
    }
    System.out.println("=======");
    String str2 = "aaa.bbb.ccc";
    String[] array2 = str2.split(".");
    int len = array2.length;    //数组长度不加（），且等于0
    System.out.println(len);
    for(String ary : array2){   //空
        System.out.println(ary);
    }
    //"."前加\\
    String str3 = "aaa.bbb.ccc";
    String[] array3 = str3.split("\\.");
    for(String ary : array3){   //空
        System.out.println(ary);
    }

1.9 练习一：按指定格式拼接字符串

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

思路：

定义一个int数组：内容1,2,3
定义一个方法，用来将数组变成字符串
- 三要素：
- 返回值类型：String
- 方法名称：fromArrayToString
- 参数列表：int[]
格式：[word1#word2#word3]会用到：
1. for循环
2. String拼接
3. 每个数组元素之前都有一个word字样
4. 分隔使用的是#
5. 区分一下是不是最后一个
调用方法，得到返回值，并打印结果字符串

    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        String result = formArrayToString(array);
        System.out.println(result);
    }

    public static String formArrayToString(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;
    }

1.10 练习二：统计输入的字符串中各个字符的个数

要求:键盘输入一个字符串，并且统计其中各个字符出现的次数
- 种类：大写字母，小写字母，数字，其他

思路：

既然用到键盘输入：Scanner
键盘输入的是字符串：String str = sc.next();
定义四个变量，分别代表四种字符各自出现的次数
需要对字符串一个字，一个字检查，String–>char[],方法就是++toCharArray()++
变量char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。
打印输出四个变量，分别代表四种字符出现次数

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = 0;
        int letterS = 0;
        int letterB = 0;
        int other = 0;
        System.out.print("请输入一串字符串：");
        String str = sc.next();
        char[] charA = str.toCharArray();   //将字符串转成数组
        for (int i = 0; i < charA.length; i++) {
            if(charA[i] >= '0' && charA[i] <= '9'){
                num++;
            }else if(charA[i] >= 'a' && charA[i] <= 'z'){
                letterS++;
            }else if(charA[i] >= 'A' && charA[i] <= 'Z'){
                letterB++;
            }else{
                other++;
            }
        }
        System.out.println("数字：" + num + "小写字母：" + letterS + "大写字母：" + letterB + "其他：" + other);
    }

第二章静态static关键字

2.1 静态static关键字概述

一旦用了static关键字，那么这样的内容不再属于对象自己，而是属于类的，所以凡是本类的对象，都共享同一份

注：只在类当中保存唯一一份，那所有本类对象共享同一份
注：对于姓名，年龄，学号来说，每个对象都有自己独立的数据，但是对于教师来说，这应该是多个对象共享同一个数据才对。

2.2 静态static关键字修饰成员变量

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。

注：动态学号计数(例子):创建一个new对象就加一
注：++推荐用类名来调用成员变量或者成员方法++——>会误以为这是成员变量或成员方法
- one.room = “101教室”; 可以，不推荐
- Student.room = “101教室”; 可以，推荐

    生成一个Student类:Student.java
    public class Student {
        private int id; //学号
        private String name;
        private int age;
        static String room;
        private static int idCounter = 0;   //学号计数器，每当new了一个新对象的时候，计数器++
    
        //无参
        public Student(){
            this.id = ++idCounter;
        }
        //全参
        public Student(String name, int age){
            this.name = name;
            this.age = age;
            this.id = ++idCounter;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName(){
            return name;
        }
        public void setName(String name){
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    //创建一个对象：Demo01StaticField.java
    public static void main(String[] args) {
        Student one = new Student("郭靖", 19);
        one.room = "101教室";
        System.out.println("姓名：" + one.getName()
                + "年龄：" + one.getAge() + "教室:" + one.room
                + "学号：" + one.getId());
        Student two = new Student("黄蓉", 16);
        System.out.println("姓名：" + two.getName()
                + "年龄：" + two.getAge() + "教室:" + one.room
                + "学号：" + two.getId());
    }

2.3 静态static关键字修饰成员方法

一旦使用static修饰成员方法，那么这就成为了静态方法。++静态方法不属于对象，而是属于类的。++
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
- 对于++成员方法++来说，++首先创建对象++，++然后才能使用没有static关键字的内容++
- 对于++静态方法++来说，++可以通过对象名进行调用，也可以直接通过类名称调用++
  - obj.methodStatic(); 正确，不推荐(obj对象名)
  - MyClass.methodStatic(); 正确，推荐(MyClass类名)
  - 对象名.静态方法的写法，在编译之后也会被javac翻译成：类名称.静态方法
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
与2.2的总结：
- 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用
  - 静态变量：类名称.静态变量;
  - 静态方法：类名称.静态方法();

注：对于本类当中的静态方法，可以省略类名称
- myMethod();
- Demo02StaticMethod.myMethod(); //完全等效
注：静态不能直接访问非静态
- 因为在内存当中是++先++有的静态内容，++后++有的非静态内容
- “++先人不知道后人，后人知道先人++”
注：静态方法当中不能用this关键字
- this代表当前对象，通过谁调用的方法，谁就是当前对象（但是静态和对象无关）

    生成一个类：MyClass.java
    public class MyClass {
        int num;    //成员变量
        static int numStatic;   //静态变量
        //成员方法
        public void method(){
            System.out.println("这是一个成员方法");
            //成员方法可以访问成员变量
            System.out.println(num);
            //成员方法可以访问静态变量
            System.out.println(numStatic);
        }
        //静态方法
        public static void methodStatic(){
            System.out.println("这是一个静态方法");
            //静态方法不能访问成员变量
            //System.out.println(num);
            //静态方法可以访问静态变量
            System.out.println(numStatic);
            //静态方法当中不能使用this关键字
            //System.out.println(this);
        }
    }
    创建一个对象：Demo02StaticMethod
    public class Demo02StaticMethod {
        public static void main(String[] args) {
            MyClass obj = new MyClass();    //首先创建对象
            //然后才能使用没有static关键字的内容
            obj.method();
            //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称调用
            obj.methodStatic(); //可以，不推荐
            MyClass.methodStatic(); //可以，推荐
    
            myMethod();
        }
    
        public static void myMethod(){
            System.out.println("自己的方法！");
        }
    }

2.4 静态static的内存图

注：根据类名称访问静态成员变量的时候，全程和对象就没有关系，只和类有关系
注：就算你写的对象名.静态变量–>编译时候也会被javac翻译成：类名称.静态方法

2.5 静态代码块

注：直接用大括号括起来的都叫代码块

静态代码块的格式（在类中）：

    public class 类名称 {
        //静态代码块的内容
    }

特点：当第一次用到本类时，静态代码块执行唯一的一次
- 构造方法在每次使用到本类时，都会执行一次
静态代码块的典型用途：
- 用来一次性的对静态成员变量进行赋值
- JDBC相关环境下

    //生成一个类：Person.java
    public class Person {
        static {
            System.out.println("静态代码块执行!");
        }
    
        public Person(){
            System.out.println("构造方法执行！");
        }
    }
    //创建一个对象：Demo04Static.java
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }

结果：
- 静态代码块执行!
- 构造方法执行！
- 构造方法执行！
注：++静态内容总是优先于非静态++，所以静态代码块比构造方法先执行

第三章 Arrays类

3.1 ++数组++工具类Arrays

java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作
- ++因为静态方法不用new，直接通过类名称就能点(’.’)，所以很方便，快捷++
常用的两个方法：
1. public static String toString(++数组++)：将参数数组变成字符串
  - 按照默认格式：[元素1，元素2，元素3…]++++
2. public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序
  - ++因为是void所以直接把原来数组排序++
  - 如果是++数值++，sort默认按照升序，从小到大
  - 如果是++字符串++，sort默认按照字母升序，从小到大
  - 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持（今后学习++）++
  - 必须是一个数组才可以使用Arrays.sort方法

    public static void main(String[] args) {
        int[] intArray = {1, 2, 4, 5};
        //将int数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); //[1, 2, 4, 5]
        System.out.println("===========");
        int[] array1 = {1, 2, 10, 3, 5};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));
        /*System.out.print("[");
        for(int i = 0; i < array1.length; i++){
            if(i == array1.length - 1){
                System.out.print(array1[i] + "]");
            }else{
                System.out.print(array1[i] + " ");
            }
        }*/
        /*for(int ary : array1){
            System.out.print(ary + " ");
        }*/
        String[] array2 = {"123", "ccc", "bbb"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }

3.2 Arrays类练习：字符串倒序排列

要求：请使用Arrays相关的API（也就是相关的方法），将一个随机字符串中的所有字符升序排列，并倒序打印

注：倒序遍历的快捷键——>array.forr（array是数组名）

    public static void main(String[] args) {
        String str = "jdfjfjieafnalgjifejnsaa";
        //如何进行升序排列：sort
        //必须是一个数组，才能用Arrays.sort方法
        //String -->数组，用toCharArray()
        char[] array = str.toCharArray();

        Arrays.sort(array); //对字符数组进行升序排列

        //==需要倒序遍历==
        for (int i = array.length - 1; i >= 0; i--) {
            System.out.print(array[i] + " ");
        }
    }

第四章 Math类

4.1 ++数学++工具类Math

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
常用的方法：
1. public static double abs(double num)：获取绝对值（有多种重载）
2. public static double ceil(double num)：向上取整
  - 12.1–>13.0
3. public static double floor(double num)：向下取整
  - 12.9–>12.0
4. public static long round(double num)：四舍五入
  - 12.4–>12
  - 12.5–>12
5. public static double sqrt(double num)：正平方根
  - 4 -->2.0
6. public static double pow(double num1, double num2)：返回第一个参数的第二个参数次幂的值。
  - (2, 2)–>4.0
Math.PI(念“π”)：代表近似的圆周率常量。（就是一个double值）

注：两个整数相除不做四舍五入：12345 / 10 = 1234
注：保留两位小数：String.format("%.2f", 变量名);
- double num = 12.325;
- System.out.println(String.format("%.2f", num)); //12.33
注：转换为字符串形式：String.valueof();

    public static void main(String[] args) {
        //绝对值abs
        System.out.println(Math.abs(3.12));
        System.out.println(Math.abs(0));
        System.out.println(Math.abs(-3.12));    //3.12
        System.out.println("========");
        //向上取整ceil
        System.out.println(Math.ceil(12.1));    //13.0
        System.out.println("========");
        //向下取整floor
        System.out.println(Math.floor(12.9));   //12.0
        System.out.println(Math.floor(21)); //21.0
        System.out.println("========");
        //四舍五入round
        System.out.println(Math.round(12.4));   //12
        System.out.println(Math.round(12.5));   //13
        System.out.println("========");
        //平方pow
        System.out.println(Math.pow(2, 2)); //4.0
        System.out.println("========");
        //平方根sqrt
        System.out.println(Math.sqrt(4));   //2.0
        System.out.println("========");
        //算圆的面积（半径：2）
        double radius = 2.325;
        //System.out.println(String.format("%.2f", radius));
        System.out.println("圆的面积是：" + String.format("%.2f", (Math.PI * Math.pow(radius, 2))));
    }

4.2 Math练习一：小学数学

要求：计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
分析：
1. 确定了范围：for循环
2. 起点位置-10.8换成-10的两种方法：
  1. 可以使用Math.ceil方法，向上（向正方法）取整
  2. 强转成int，就会自动舍弃所有小数位
3. 每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的
4. 如何拿到绝对值：Math.abs方法
5. 一旦发现了一个数字，需要让计数器++进行统计

注：如果使用Math.ceil方法，-10.8可以变成10.0。++double也是可以进行++的++

    public static void main(String[] args) {
        int count = 0;  //符合要求的数量
        double min = -10.9;
        double max = 5.9;
        ArrayList<Integer> listA = new ArrayList<>();
        //这样处理，变量i就是区间之内所有的整数
        for(int i = (int)min; i < max; i++){
            int abs = Math.abs(i);  //绝对值
            if(abs > 6 || abs < 2.1){
                count++;
                listA.add(abs);
            }
        }
        System.out.println("符合要求的总共有：" + count);   //符合要求的总共有：9
        System.out.println("分别是：");
        System.out.println(listA);  //[10, 9, 8, 7, 2, 1, 0, 1, 2]
    }

狂野小白兔

发布了42 篇原创文章 · 获赞 6 · 访问量 1142

私信关注

Java语言入门||02_面向对象与常用类||day08_String类，static，Arrays类，Math类

第一章 String类

1.1 字符串的概述和特点

1.2 字符串的构造方法和直接创建

1.3 字符串的常量池

1.4 字符串的比较相关方法

1.5 字符串的获取相关方法

1.6 字符串的截取相关方法

1.7 字符串的转换相关方法

1.8 字符串的分割相关方法

1.9 练习一：按指定格式拼接字符串

1.10 练习二：统计输入的字符串中各个字符的个数

第二章 静态static关键字

2.1 静态static关键字概述

2.2 静态static关键字修饰成员变量

2.3 静态static关键字修饰成员方法

2.4 静态static的内存图

2.5 静态代码块

第三章 Arrays类

3.1 ++数组++工具类Arrays

3.2 Arrays类练习：字符串倒序排列

第四章 Math类

4.1 ++数学++工具类Math

4.2 Math练习一：小学数学

猜你喜欢

第二章静态static关键字