Java学习7-字符串-静态static-Arrays-Math

1. 字符串

1.1 字符串概述和特点

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

package Demo09;

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

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

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

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

第一个字符串：
第2个字符串：ABC
第3个字符串：abc
第4个字符串：hello

Process finished with exit code 0

 1.3 字符串常量池

package Demo09;
/*
字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。
对于基本类型来说，== 是进行数值的比较。
对于引用类型来说，== 是进行【地址值】的比较
 */
public class Demo02StringPool {
    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(str2 == str3); // false
    }
}

 true
false
false

Process finished with exit code 0

 1.4 字符串的比较相关方法

package Demo09;

public class Demo03StringEquals {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {'H','e','l','l','o'};
        String str3 = new String(charArray);
        System.out.println(str1.equals(str2));
        System.out.println(str2.equals(str3));
        System.out.println(str3.equals("Hello"));
        String str4 = "hello";
        System.out.println(str1.equals(str4)); // false
        System.out.println("=============");

        String str5 = null;
        System.out.println("abc".equals(str5)); // 推荐：false
//        System.out.println(str5.equals("abc")); // 不推荐：报错，空指针异常NullPointerException
        System.out.println("============");

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB)); // false，区分大小写
        System.out.println(strA.equalsIgnoreCase(strB)); // true，不区分大小写
        
        // 注意：只有英文字母区分大小写
        System.out.println("abc一123".equalsIgnoreCase("abc壹123")); // false
    }
}

true
true
true
false
=============
false
============
false
true
false

Process finished with exit code 0

1.4 字符串获取的相关方法

package Demo09;

public class Demo04StringGet {
    public static void main(String[] args) {
        // 获取字符串的长度
        int length = "jaihfysvfhahdlajis".length();
        System.out.println("字符串的长度是：" + length);
        // 拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println("===============");
        // 获取指定索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("1号索引位置的字符是：" + ch);
        System.out.println("===============");
        System.out.println("HelloWorld".indexOf("abc")); // -1
    }
}

 字符串的长度是：18
Hello
World
HelloWorld
===============
1号索引位置的字符是：e
===============
-1

Process finished with exit code 0

1.5 字符串截取的方法

 

1.6 字符串的转换相关方法

package Demo09;

public class Demo05StringConvert {
    public static void main(String[] args) {
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);
        System.out.println(chars.length);
        System.out.println("=============");
        // 转换成字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        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);
    }
}

 H
5
=============
97
98
99
============
How do you do?
H*w d* y*u d*?
============
会不会玩儿呀！你大爷的！你大爷的！你大爷的！！！
会不会玩儿呀！***！***！***！！！

Process finished with exit code 0

1.7 字符串的分割方法

package Demo09;

import com.sun.source.doctree.BlockTagTree;

public class Demo06StringSplit {
    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("."); // 0
        String[] array3 = str3.split("\\."); // 3
        System.out.println(array3.length);
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
    }
}

 aaa
bbb
ccc
==============
aaa
bbb
ccc
==============
3
aaa
bbb
ccc

Process finished with exit code 0

1.8 练习1-按照指定格式拼接字符串

 

package Demo09;

public class Demo07StringPractice1 {
    public static void main(String[] args) {
        int[] intArray = {1,2,3};
        String str = fromArraytoString(intArray);
        System.out.println(str);
    }
    public static String fromArraytoString(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;
    }
}

 [word1#word2#word3]

1.9 练习2-统计输入的字符串中各种字符的个数

package Demo09;

import java.util.Scanner;

public class Demo08StringCount {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String str = sc.next();
        int countUpper = 0;
        int countLower = 0;
        int countNum = 0;
        int countOther = 0;
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if ('A' <= chars[i] && chars[i] <= 'Z'){
                countUpper++;
            }else if ('a' <= chars[i] && chars[i] <= 'z'){
                countLower++;
            }else if ('0' <= chars[i] && chars[i] <= '9'){
                countNum++;
            }else {
                countOther++;
            }
        }
        System.out.println("大写字母个数：" + countUpper);
        System.out.println("小写字母个数：" + countLower);
        System.out.println("数字个数：" + countNum);
        System.out.println("其他字符个数：" + countOther);
    }
}

 请输入字符串：
大小abcAB123
大写字母个数：2
小写字母个数：3
数字个数：3
其他字符个数：2

Process finished with exit code 0

2. 静态static

2.1 静态static关键字概述

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

package Demo10;

public class Student {
    private String name;
    private int age;
    private static int idCounter = 0; //学号计数器，每当new了一个新对象时，计数器++
    static String room;

    public Student() {
        this.idCounter = ++idCounter;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.idCounter = ++idCounter;
    }

    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;
    }

//    public static String getRoom() {
//        return room;
//    }
//
//    public static void setRoom(String room) {
//        Student.room = room;
//    }
}

package Demo10;

/*
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。
 */
public class Demo01StaticField {
    public static void main(String[] args) {
        Student one = new Student("陈姐",19);
        Student two = new Student("刘妹",17);
        one.room = "512教室";
        System.out.println("姓名：" + one.getName() + "，年龄：" + one.getAge() + "，所在教室：" + one.room);
        System.out.println("姓名：" + two.getName() + "，年龄：" + two.getAge() + "，所在教室：" + two.room);
    }
}

 姓名：陈姐，年龄：19，所在教室：512教室
姓名：刘妹，年龄：17，所在教室：512教室

Process finished with exit code 0

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

package Demo10;

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(numStatic);
        // 静态不能直接访问非静态【重点】
//        System.out.println(num); // 错误写法
        // 静态方法中不能使用this关键字
//        System.out.println(this); // 错误写法
    }
}

package Demo10;
/*
一旦使用static修饰成员方法，那么这就达成了静态方法。静态方法不属于对象，而是属于类的

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
注意事项：
1. 静态只能直接访问静态，不能直接访问非静态。
原因：因为在内存当中是【先】有静态的内容，【后】有非静态的内容。
“先人不知道后人，但是后人知道先人”
2. 静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
 */
public class Demo02StaticMethod {
    public static void main(String[] args) {
        MyClass obj = new MyClass(); // 首先创建对象
        // 然后才能使用没有static关键字的内容
        obj.method();
        // 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
        obj.methodStatic(); // 正确，不推荐，这种写法在编译之后也会被javac翻译称”类名称.静态方法名"
        MyClass.methodStatic(); // 正确，推荐

        // 对于本类当中的静态方法，可以省略类名称
        myMethod();
        Demo02StaticMethod.myMethod(); // 完全等效
    }

    public static void myMethod(){
        System.out.println("自己的方法！");
    }
}

这是一个普通的成员方法。
0
0
这是一个静态方法。
0
这是一个静态方法。
0
自己的方法！
自己的方法！

Process finished with exit code 0

 2.4 静态static的内存图

2.5 静态代码块

package Demo10;

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

package Demo10;
/*
静态代码块的格式：
public class 类名称{
    static {
        // 静态代码块内容
    }
}
特点：当第一次用到本类时，静态代码块执行唯一一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值
 */
public class Demo03Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}

3. Arrays

3.1 数组工具类Arrays介绍

package Demo11;

import java.util.Arrays;

public class Demo01Arrays {
    public static void main(String[] args) {
        int[] intArray = {10,20,30};
        // 将int[]数组按照默认格式变成字符串
        String inStr = Arrays.toString(intArray);
        System.out.println(inStr); // [10, 20, 30]

        int[] array1 = {2,1,3,10,6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]

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

[10, 20, 30]

[1, 2, 3, 6, 10]

[aaa, bbb, ccc]

 3.2 Arrays练习-字符串倒序排列

package Demo11;

import java.util.Arrays;
import java.util.Scanner;

/*
使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印
 */
public class Demo02ArraysTest {
    public static void main(String[] args) {
        System.out.println("请输入一串字符：");
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        char[] chars = str.toCharArray();

        Arrays.sort(chars);
        // 用chars.forr进行倒序快捷写for语句；用chars.fori进行正序写for语句
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }
    }
}

 请输入一串字符：
cba
c
b
a

4. Math

4.1 数学工具类-Math

 

 

4.2 Math练习-小学数学真题

package Demo11;

public class Demo03MathPractice {
    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++){
            if(Math.abs(i) > 6 || Math.abs(i) < 2.1) {
                System.out.println(i);
                count++;
            }
        }
        System.out.println("范围内的整数个数为：" + count);
    }
}

 -10
-9
-8
-7
-2
-1
0
1
2
范围内的整数个数为：9