【String类、static、Arrays类、Math类】

day08【String类、static关键字、Arrays类、Math类】

今日内容

• String类

• static关键字

• Arrays类

• Math类

教学目标

• 能够使用String类的构造方法创建字符串对象

  3+1

  1. new String()
  2. new String(char[] char)
  3. new String(byte[] bytes)

• 能够明确String类的构造方法创建对象,和直接赋值创建字符串对象的区别

  • 直接使用构造方法创建的字符串普通的堆中
  • 直接使用双引号定义的字符串，字符串在常量池中

• 能够使用文档查询String类的判断方法

  1. equals【常用】
  2. equalsIgnoreCase
  3. contains
  4. startsWith 【有一个集合，存储了字符串，把开头为”张“】
  5. endsWith

• 能够使用文档查询String类的获取方法

  • length【常用】
  • concat +
  • charAt【常用】
  • indexOf
  • subString(int begin)【常用】
  • subString(int begin,int end) :包头不包尾

• 能够使用文档查询String类的转换方法

  • toCharArray【常用】
  • getBytes
  • replace
  • toLowerCase
  • toUpperCase

• 能够理解static关键字

  1. `static 静态
  2. 静态方法只能访问静态成员【静态变量，静态方法】

• 能够写出静态代码块的格式

  1. static{ }
  2. 初始化静态变量

• 能够使用Arrays类操作数组

  1. 排序 sort
  2. 转换为字符串 toString

• 能够使用Math类进行数学运算

  • abs 绝对值
  • ceil 向上取整
  • floor 向下取整
  • round 四舍五入

第一章 String类

1.1 String类概述

概述

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

类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jJmT3dgz-1575363914804)(img/字符串概述.png)]

特点

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

   //字符串时引用类型 
   //str1存的是 "abc"这个字符串在内存中的地址(地址就是一个数字)
    String str1 = "abc";
   
    //str2 存的是str1和"def"拼接后 字符串"abcdef"在内存中地址
    String str2 = str1 + "def";
   
    // 猜想:
    // 如果str1在相加后,内存中没有产生新对象,那么str1和str2指向相同对象,str1==str2 -->true
    System.out.println(str1 == str2);// false
    //实验结果并非我们猜想的那样,str1和str2存储着不同的地址,也就是str1和str2指向不同对象
   
    System.out.println(str1);// abc
    System.out.println(str2);// abcdef
   
    //字符串的值在创建后不能被更改
   

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

   String s1 = "abc";
   String s2 = "abc";
   System.out.println(s1==s2);//true
   // 内存中只有一个"abc"对象被创建，同时被s1和s2共享。
   

3. "123abc?." 等效于 char[] data={'1','2','3', 'a' , 'b' , 'c','?','.' }

   小贴士

   在1.8以前的版本,char[]是字符串内部实现原理. 当前1.9的版本已经改为byte[]

例如： 
   String str = "abc";
   
   相当于： 
   char[] data = {'a', 'b', 'c'}; //97，98，99
   
   byte[] data = {97,98,99};
   String str = new String(data);
   // String底层是靠字符数组实现的。在1.8以前的版本,这是字符串内部实现原理.

1.2 使用步骤

• 查看类

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

• 查看构造方法

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

• 构建字符串的3+1种方式

  构造举例，代码如下：

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

  除了使用构造方法创建对象之外，我们之前还经常使用的是直接使用字符串常量赋值，如下

  //不用构造方法，直接赋值字符串常量
  String str4="abc";	
  

  小贴士
  使用构造方法和使用字符常量两种形式在内存中有不同的表现。我们在下面1.3.1章节中具体学习。

1.3 常用方法

1.3.1 判断功能的方法

1. public boolean equals (String anObject) ：将此字符串与指定对象进行比较。
2. public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。
3. boolean contains(CharSequence s) :字符串中是否包含某个子串
4. boolean startsWith( String prefix) :判断是否以某个子串开头

扩展(了解)：字符串的常量池内存分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WeW6jmQ6-1575363914805)(img/字符串常量及对象内存图)]结论：

1. 字符串常量在JDK1.7版本以后存在于堆内存中的字符串常量池中（之前的版本常量池在方法区中）

2. 符号 ==用于比较变量的地址（引用）是否相同 。

3. equals用于比较引用类型堆中对象内容是否相同。

   因此在比较两个字符串内容是否相同时不能使用==号，应该使用equals

如果直接定义双引号的字符串那么是在字符串常量池中，

如果使用构造方法构建对象，那么字符串在普通的堆中

1.3.2 获取功能的方法

1. public int length () ：返回此字符串的长度。

2. public String concat (String str) ：将指定的字符串连接到该字符串的末尾。 +

3. public char charAt (int index) ：返回指定索引处的 char值。

4. public int indexOf (String str) ：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

5. public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。

6. public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex（包头不包尾）。

方法演示，代码如下：

 public static void main(String[] args) {
        String str1 = "apple";
        //1. public int length () ：返回此字符串的长度。
        int len = str1.length();
        System.out.println("apple有" + len + "个字符");
        System.out.println("↑↑↑↑↑ length ()-----------------");
        //2. public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
        String str2 = "pen";
        //2.1 使用+ 好拼接
        String str3 = str1 + str2;
        System.out.println(str3);
        //2.3 使用concat
        String str4 = str1.concat(str2);
        System.out.println(str4);
        System.out.println("↑↑↑↑↑ concat (String str) ----------------");
        //3. public char charAt (int index) ：返回指定索引处的 char值。
        char c = str1.charAt(0);
        System.out.println("第个0字符为:" + c);
        System.out.println("第个1字符为:" + str1.charAt(1));
        System.out.println("第个2字符为:" + str1.charAt(2));
        System.out.println("第个3字符为:" + str1.charAt(3));
        System.out.println("第个4字符为:" + str1.charAt(4));
//        System.out.println("第个5字符为:"+str1.charAt(5));
//        System.out.println("第个6字符为:"+str1.charAt(6));
        System.out.println("↑↑↑↑↑ charAt (int index) ----------------");
        //4. public int indexOf (String str) ：
     	//返回指定子字符串第一次出现在该字符串内的索引，不存在返回-1。
        //                    "apple"
        int i1 = str1.indexOf("app");
        int i2 = str1.indexOf("pp");
        int i3 = str1.indexOf("ppap");

        System.out.println("i1=" + i1);
        System.out.println("i2=" + i2);
        System.out.println("i3=" + i3);

        System.out.println("---------------↑↑↑↑↑ indexOf (String str) ----------------");
        //5. public String substring (int begin) ：
     	//	返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
        //               "apple"
        String subStr1 = str1.substring(0);
        String subStr2 = str1.substring(3);
        String subStr3 = str1.substring(str1.length());//参数可以 [0,str.length()]
          //不能大于str.length(),报StringIndexOutOfBoundsException
//        String subStr4 = str1.substring(str1.length()+1);
     
        System.out.println(subStr1);
        System.out.println(subStr2);
        System.out.println(subStr3);

        System.out.println("↑↑↑↑↑ substring (int begin)  ----------------");
        //6. public String substring (int begin, int end) ：
        // 返回一个子字符串，从begin到end截取字符串。含begin，不含end（包头不包尾巴）。
        String subStr5 = str1.substring(1, 5);
//        String subStr6 = str1.substring(4, 6);//取值的范围
        System.out.println(subStr5);
        System.out.println("↑↑↑↑↑ substring (int begin, int end) ------------");

    }

1.3.3 转换功能的方法

1. public char[] toCharArray () ：将此字符串转换为新的字符数组。
2. public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
3. public String replace (String target, String replacement) ：将与target匹配的字符串使用replacement字符串替换。
4. public String toLowerCase()  使用默认语言环境的规则将此 String中的所有字符都转换为小写。
5. public String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

方法演示，代码如下：

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对象传递到方法中。

1.3.4 分割功能的方法

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

方法演示，代码如下：

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

☆正则表达式中有些特殊符号,比如.+?，使用分割时要进行转义，直接前面双斜线就可以 \\ 如

 public static void main(String[] args) {
      String s = "1.1+2?123*789$abc\\ddbcd";
      System.out.println(Arrays.toString(s.split("\\.")));
      System.out.println(Arrays.toString(s.split("\\+")));
      System.out.println(Arrays.toString(s.split("\\?")));
      System.out.println(Arrays.toString(s.split("\\*")));
      System.out.println(Arrays.toString(s.split("\\$")));
      System.out.println(Arrays.toString(s.split("\\\\")));
     
}

其中斜线\叫做转义字符，当转义字符要当做普通的字符时，需要进行自身转义变成\\

1.4 String类的练习

拼接字符串 (+ contact)

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

[1#2#3]

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+"个");
    }
}

第二章 static关键字 (静态)

2.1 概述

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的成员，而不单单是属于某个对象的。 类(方法区 ) 对象(成员方法,成员变量)

static修饰成员叫做类成员，使用类名直接访问也可以使用该类创建的对象来调用(不建议)。

2.2 定义和使用格式

2.2.1 类变量(静态变量)

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

• 类变量：使用 static关键字修饰的成员变量。

定义格式：

static 数据类型 变量名； 

举例：

static String className；

比如说,基础班新生报到,每一位同学都有各自的学号,姓名,年龄等信息, 但是同学们都所属同一个班级, 也就是班级名称都是相同的. 班级名称是所有同学所共享的,我们可以使用static关键字来访问.

public class Student {
    //班级名称,共享信息
    public static String className;
    // public 和 private一样也权限修饰符.private权限最小, public权限最大
    
    String name;
    int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    //打印信息
    public  void show() {
        System.out.println("姓名:"+name+" 年龄"+age+" 班级:"+className);
    }
}

public class TestStudent {
    public static void main(String[] args) {
        Student stu1 = new Student("李雷", 19);
        Student stu2 = new Student("韩梅梅", 18);

        stu1.show();//姓名:李雷 年龄19 班级:null
        stu2.show();//姓名:韩梅梅 年龄18 班级:null

        //可以使用  对象名.静态变量名   但不建议
        stu2.className = "12";

        //静态变量直接使用  类名.静态变量名
        Student.className = "JavaEE 黑马45";

        stu1.show();//姓名:李雷 年龄19 班级:JavaEE 黑马45
        stu2.show();//姓名:韩梅梅 年龄18 班级:JavaEE 黑马45
    }
}

总结:

成员变量前加上 static
用法
 对象去调用(无法直接提示: 不太建议使用对象去调用)
     1.所有对象都共享其值
     2.一个变所有变
 类调用:直接使用类名.变量名

2.2.2 静态方法

当static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有static ，建议使用类名来调用，而不需要创建类的对象。

• 类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

定义格式：

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

//public private

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

public static void showClassName() {
  	System.out.println("班级:" +  className);
}

2.2.3 调用格式

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

访问格式：

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

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

调用演示，代码如下：

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

内部访问规则：

​ 静态方法只能访问静态成员（静态变量或者静态方法），不能使用非静态的成员。反之非静态的方法可以访问本类中的所有成员包含静态成员。

2.3 静态原理图解(了解)

我们对以上代码案例中的静态成分做个分析,如下图.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-joPo2DHT-1575363914805)(img/静态原理图分析.png)]

1.类加载的时候进入到方法区即class文件加载到方法区:

​ 在方法区内存中类会把静态和非静态的成员区分放.

2.静态成员(静态变量和静态方法)是在方法区中，此时可以直接使用, 此时是没有该类的对象.

也就是说静态方法不能访问非静态成员(成员属性 成员方法) this也不能够存在

3.类先加载，对象是在后来通过构造方法创建的。

​ 意味着对象存在时， 静态成员已经存在, 所以我们可以使用对象去调用静态成员.

核心： 是对象先存在还是静态成员先存在？

静态先存在，所不能非静态的成员

小贴士

1. 静态成员的值随着类的加载而加载，且只加载一次 ,因此在整个内存中,只有一份数据.

2. 静态成员存储于一块固定的内存区域（方法区中的静态区). 可以直接被类名调用。

2.4 静态代码块

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

1. 位置：类中方法外。
2. 执行：随着类的加载而执行且执行一次，优先于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 方法的便利。

第三章 Arrays类

3.1 概述

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

3.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]
}

3.3 练习

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

public class ArraysTest {
    public static void main(String[] args) {
        // 定义随机的字符串
        String line = "ysKUreaytWTRHsgFdSAoidq";
        // 转换为字符数组
        char[] chars = line.toCharArray();

        // 升序排序
        Arrays.sort(chars);
        // 反向遍历打印
        for (int i =  chars.length-1; i >= 0 ; i--) {
          	System.out.print(chars[i]+" "); 
        }
    }
}

第四章 Math类

4.1 概述

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

4.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) ：返回大于等于参数的最小的整数。(记忆:ceil 天花板)

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) ：返回小于等于参数最大的整数。(记忆:floor 地板)

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.0
long d2 = Math.round(5.4); //d2的值为5.0

4.3 练习

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

public class MathTest {
    public static void main(String[] args) {
        // [-10.8, 5.9]  -->[-10,5]
        
        // 定义最小值
        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 + " 个");
    }
}

ic long round(double a)` ：返回最接近参数的 long。(相当于四舍五入方法)

long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0

4.3 练习

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

public class MathTest {
    public static void main(String[] args) {
        // [-10.8, 5.9]  -->[-10,5]
        
        // 定义最小值
        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 + " 个");
    }
}