Java Day08

第一章 String类

1.1 String类概述

• 概述：java.lang.String 类代表字符串，Java程序中所有的字符串文字都可以被看作是实现此类的实例。类String中包括用于检查哥哥字符串的方法。
• 特点
  • 字符串不变：字符串的值在创建后不改变。
  • 因为String对象是不可变的，所以它们可以被共享。
  • “abc” 等效于 char[] data = {'a', 'b', 'c'}

1.2 使用步骤

• 查看类
• 查看构造方法

1.3 常用方法

• 判断功能的方法：equals、equalsIgnore

package cn.itcast.day08.demo02;

/*
* ==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：
*   public boolean equals(Object obj)，参数可以是任何对象，只有参数是一个字符串并且内容相同的才会返回true，否则返回false
* 注意事项：
*   1、任何对象都能用Object进行接收
*   2、equals方法具有对称性，也就是a。equals(b)和b.equals(a)效果一样
*   3、如果比较双放一个常量一个变量，推荐吧常量自付串写在前面。推荐："abc".equals(str)，不推荐 str.equals("abc")，因为如果str为null的话，后者会报空指针异常的错误。
*
*   public boolean equalsIgnoreCase(String str)，忽略大小写，进行内容的比较。只有英文字母区分大小写其他都不区分
*/

public class Demo01StringEquals {
    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));  // true
        System.out.println(str2.equals(str3));  // true
        System.out.println(str3.equals("Hello"));  // true
        System.out.println("Hello".equals(str1));  // true

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

        System.out.println("================================");

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB));  // 严格区分大小写，false
        System.out.println(strA.equalsIgnoreCase(strB));  // 忽略大小写，返回true
    }
}

• 获取功能方法：length、concat、charAt、indexOf、substring

package cn.itcast.day08.demo02;

/*
*
* public int length()：获取字符串的长度
* public String concat(String str)，将当前字符串和参数字符串拼接成为新的字符串返回
* public char charAt(int index)：获取指定索引为止的单个字符
* public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引为止，如果没有返回-1
*
* */

public class Demo02StringGet {
    public static void main(String[] args) {
        // 获取字符串的长度
        int length = "hfskdhfsufhskufsi".length();
        System.out.println("字符串的长度是：" + length);
        System.out.println("========================");

        // 拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);  // HelloWorld，新的字符串
        System.out.println("========================");

        // 获取指定索引为止的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符串是：" + ch);
        System.out.println("========================");


        // 查找参数字符串在大字符串中出现的第一次索引位置
        // 如果没有返回值是-1
        String original = "HelloWorld";
        int index = original.indexOf("llo");
        System.out.println(index);
        System.out.println("HelloWorld".indexOf("in"));
    }
}

package cn.itcast.day08.demo02;

/*
* public String substring(int index)，截取从参数为止一直到字符串末尾，返回新字符串
* public String substring(int begin, int end)：截取一个范围，从begin开始到end结束，中间的字符串。注意：左闭右开
*
* */

public class Demo03Substring {
    public static void main(String[] args) {
        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);

        System.out.println("========================");
        String strA = "Hello";
        System.out.println(strA);
        strA = "Java";
        System.out.println(strA);
    }
}

• 转换功能的方法：toCharArray、getBytes、replace

package cn.itcast.day08.demo02;

/*
* String当中与转换相关的常用方法有：
*   public char[] toCharArray()：将当前字符串拆分成为字符数组
*   public byte[] getBytes()：获取当前字符串的底层字节数组
*   public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果
*       备注：CharSequence意思就是可以接受字符串类型
* */

public class Demo04StringConvert {
    public static void main(String[] args) {
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);  // H
        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]);
        }

        String str1 = "How do you do?";
        String str2 = str1.replace( "o", "*");
        System.out.println(str1);
        System.out.println(str2);

        String lang1 = "会不会玩啊，你大爷的，你大爷的，你大爷的";
        String lang2 = lang1.replace("你大爷的", "****");
        System.out.println(lang2);
    }
}

• 分割功能方法：split

package cn.itcast.day08.demo02;

/*
* 分割字符串的方法：
*   public String[] split(String regex)；按照参数的规则，将字符串切分成为若干部分
* 注意事项：split方法的参数其实是一个正则表达式，如果要使用"."来分割一定要使用"\\."
*
* */

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

    }
}

1.4 练习

package cn.itcast.day08.demo02;

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

public class Demo06StringPactice {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        String str = stringConcat(array);
        System.out.println(str);

    }

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

        }
        return str;
    }
}

第二章 static关键字

2.1 概述

• 概述：static关键字可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是蛋蛋是属于某个对象的，也就是说，既然属于类就可以不靠某个对象来调用。

2.2 定义和使用格式

• 类变量：当static修饰成员变量时，该变量为类变量，该类的每个对象都共享同一个类变量的值，任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量来使用了。
• 格式：

static 数据类型 变量名;

• 举例

package cn.itcast.day08.demo03;

public class Student {
    private int id;
    private String name;
    private int age;
    static String room;

    private static int idCounter = 0;  // 学号计数器，每当new了一个新对象的时候，计数器++

    public Student() {
        idCounter++;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++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 int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

package cn.itcast.day08.demo03;

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

public class Demo01StaticField {
    public static void main(String[] args) {
        Student one = new Student("郭靖", 19);
        one.room = "101教室";
        Student two = new Student("黄蓉",16);

        System.out.println("姓名：" + one.getName()
                + "，年龄" + one.getAge() + "，教室：" + one.room
                + "，学号" + one.getId());
        System.out.println("姓名：" + two.getName()
                + "，年龄" + two.getAge() + "，教室：" + two.room
                + "，学号" + two.getId());

    }

}

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

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

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

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

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

2.3 静态原理图

static修饰的内容：

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

2.4 静态代码块

• 静态代码块：定义在成员位置，使用static修饰的代码块。
  • 位置：类中方法外。
  • 执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
  • 作用：给类变量进行初始化赋值。
  • 格式

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

package cn.itcast.day08.demo03;

/*
 * 静态代码块的格式是：
 *   public class 类名称 {
 *       static {
 *
 *       }
 *   }
 *
 * 特点：当第一次用到本类是，静态代码块执行唯一一次。
 * 静态内容总是优先于非静态，静态代码块比构造方法先执行。
 * 静态代码块的典型用途：
 *  用来一次性地对静态成员变量进行赋值。
 * */

public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }

}

第三章 Array类

3.1 概述

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

3.2 操作数组的方法

• sort：对指定的int型数组按数字升序进行排序。
• toString：返回指定数组内容的字符串表示形式。

package cn.itcast.day08.demo04;

/*
* java.util.Array是一个与数组相关的工具类，里面提供了大量静态方法，用来事项数组常见的操作。
*
* public static String toString(数组)，将参数数组变成字符串。
* public static void sort(数组)，按照默认升序（从小到大）对数组的元素进行排序
* 备注：
*   1、如果是数值，按照数值大小排序
*   2、如果是字符串，sort默认按照字母升序
*   3、如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。
*
* */

import java.util.Arrays;

public class Demo01Arrays {
    public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);

        int[] array1 = {2, 1, 4, 5, 3, 4, 9, 2, 10, 90, 22};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));

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

}

3.3 练习

package cn.itcast.day08.demo04;

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


import java.util.Arrays;

public class Demo02ArraysPactise {
    public static void main(String[] args) {
        String str = "fjlksanisahvavniwrowehfoah";
        char[] strArrays = str.toCharArray();
        Arrays.sort(strArrays);
        System.out.println(Arrays.toString(strArrays));
        for (int i = 0; i < strArrays.length; i++) {
            System.out.print(strArrays[(strArrays.length - i - 1)]);
        }
    }
}

第四章 Math类

4.1 概述

类包含用于执行基本数学运算的方法。

4.2 基本运算的方法

• abs：返回double值的绝对值。
• ceil：返回大于等于参数的最小的整数。
• floor：返回小于等于参数最大的整数。
• round：返回最接近参数的long。

package cn.itcast.day08.demo04;

/*
* java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作
* public static double abs(double num),获取绝对值。
* public static double ceil(double num)，向上取整。
* public static double floor()，向下取整
* public static long round(double num)，四舍五入
*
* 常量值：Math.PI
*
* */

public class Demo03Math {
    public static void main(String[] args) {
        // 获取绝对值
        System.out.println(Math.abs(3.14));
        System.out.println(Math.abs(-1.2));
        System.out.println("==================");

        // 向上取整
        System.out.println(Math.ceil(3.9));
        System.out.println(Math.ceil(4.0));
        System.out.println("==================");

        // 向下取整
        System.out.println(Math.floor(3.2));
        System.out.println("==================");

        // 四舍五入
        System.out.println(Math.round(20.4));

    }
}

4.3 练习

package cn.itcast.day08.demo04;

/*
* 题目：
* 计算在-10.8到5.9之间，绝对值大于6或者小于2.1整数有几个?
*
* */

public class Demo04MathPractise {
    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(Math.floor(i)) > 6.0 || Math.abs(Math.floor(i)) < 2.1) {
                count++;
            }
        }
        System.out.println(count);
    }
}