day08 String类、Static关键字、Arrays类、Math类

2020年2月9日

目录

• 1. String类
  • 1.1 概述
  • 1.2 特点
  • 1.3 使用步骤
  • 1.4 常用方法
    • 1.4.1 判断功能的方法
    • 1.4.2 获取功能的方法
    • 1.4.3转换功能的方法
    • 1.4.4分割功能的方法
  • 1.5 String类的练习
    • 1.5.1 拼接字符串
    • 1.5.2 统计字符个数
• 2. static关键字
  • 概述
  • 2.1 定义和使用格式
  • 2.2 静态原理
  • 2.3 静态代码块
• 3. Arrays类
  • 3.1 操作数组的方法
  • 3.2 练习
• 4. Math类
  • 4.1 概述
  • 4.2 基本运算方法
  • 4.3 练习

1. String类

1.1 概述

java.lang.String类代表字符串,java程序中所有的字符串文字(例如abc)都可以被看作是实现此类的实例

1.2 特点

1. 字符串的值创建后不能被更改,因为String对象是不可变的，所以它可以被共享。
2. String底层是靠字符数组实现的

1.3 使用步骤

• 此类不需要导入
• 构造方法：

1. public String()
2. public String(char[] value)
3. public String(byte[] bytes)：通过平台的默认字符集解码当前参数中的字节数组来构造新的String

1.4 常用方法

1.4.1 判断功能的方法

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

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

1.4.2 获取功能的方法

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

1.4.3转换功能的方法

• public char[] toCharArray()
• public byte[] getBytes()
• public String replace(CharSequence target,CharSequence replacement)

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

1.4.4分割功能的方法

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

1.5 String类的练习

1.5.1 拼接字符串

/*
定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。
格式参照如下：[word1#word2#word3}
思路：
1.首先准备int数组{1,2,3}
2.定义一个方法，用来将数组变成字符串
三要素
返回值类型：
方法名称：fromArrayToString
参数列表：int[]
3.格式[word1#word2#word2]
用到for循环、字符串拼接，每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个
4.调用方法，得到返回值，打印结果字符串
 */
public class Demo08StringConcat {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        String result = fromArraytoString(array);
        System.out.println(result);
    }

    public static String fromArraytoString(int[] array) {
        String str = "[";
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                str = str + "word" + array[i] + "]";
            } else {
                str = str + "word" + array[i] + "#";
            }
        }
        return str;
    }
}

1.5.2 统计字符个数

import java.util.Scanner;

/*
键盘输入一个字符串，并且统计其中各种字符出现的次数
种类有：大写字母、小写字母、数字、其他
思路：
1.输入，Scanner
2.字符串，String str=sc.next（）
3.定义四个变量，代表四种字符出现的次数
4.需要一个字、一个字地检查，String-->char[]，方法是toCharArray（）
5.遍历char[]，判断种类
 */
public class Demo09StringCount {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String input = sc.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++;//char可以直接判断大小
            } 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关键字

概述

可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是只属于某个对象，可以不靠创建对象来调用

2.1 定义和使用格式

• 类变量

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

• 静态方法

用static修饰的成员方法称为类方法，习惯成为静态方法，使用类名来调用，不需要创建类的对象

注意事项：

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

2.2 静态原理

static修饰的内容：

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

2.3 静态代码块

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

• 位置：类中方法外
• 执行：随着类的加载而执行且执行唯一的一次，优于main方法和构造方法的执行

/*
静态代码块的格式是：
public class 类名称{
    static{
        //静态代码块的内容
    }
}
特点：当第一次用到本类时，静态代码块执行唯一的一次
静态内容总是优先于非静态，所以静态代码块比构造方法先执行

静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值。
 */
public class Person {
    static {
        System.out.println("静态代码块执行！");
    }
    public Person(){
        System.out.println("构造方法执行！");
    }
}

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

3. Arrays类

java.util.Arrays此类包含用来操作数组的各种方法，所有方法均为静态方法

3.1 操作数组的方法

• public static String toString(int[] a):返回指定数组内容的字符串表示形式
• public static void sort(int[] a):对指定的int型数组按数字升序进行排序

3.2 练习

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

import java.util.Arrays;

public class Demo02ArraysPrint {
    public static void main(String[] args) {
        String str = "sghoahioHOIHgshogaKGKGKIngio";
        char[] charArray = str.toCharArray();
        Arrays.sort(charArray);
        for (int i = charArray.length - 1; i >= 0; i--) {
            System.out.print(charArray[i] + " ");
        }
    }
}

4. Math类

4.1 概述

java.lang.Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根、三角函数。

4.2 基本运算方法

• public static double abs(double a):返回double值的绝对值
• public static double ceil(double a):返回大于等于参数的最小整数
• public static double floor(double a):返回小于等于参数的最大整数
• public static long round(double a):返回最接近参数的long（相当于四舍五入）

4.3 练习

import java.util.ArrayList;

/*
计算在-10.8到5.9之间，绝对值大于6或小于2.1的整数有多少个？
1.创建一个数组，存储这些整数，用abs对整数进行筛选
 */
public class Demo02MathPractise {
    public static void main(String[] args) {
//        ArrayList<Double> list=new ArrayList<>();
//        double num=Math.ceil(-10.8);
//        while (num<5.9){
//            if (Math.abs(num)>6||Math.abs(num)<2.1){
//                list.add(num);
//                System.out.print(num+" ");
//            }
//            num++;
//        }
//        System.out.println("这样的整数有"+list.size()+"个");
        double min = -10.8;
        double max = 5.9;
        int count = 0;
        for (int num = (int) min; num < 5.9; num++) {
            int abs = Math.abs(num);
            if (abs > 6 || abs < 2.1) {
                System.out.println(num);
                count++;
            }
        }
        System.out.println("总共有" + count);
    }
}