JavaStudy08 String类、static关键字、Arrays类、 Math类

20200322 目录+1.1
20200323 试了不看视频看讲义加自己编写，速度快了很多，也更轻松。
20200325 想完游戏来着 打开idea开始编程就不想玩啦 学习

今日内容

• String类
• static关键字
• Arrays类
• Math类

教学目标

• 能够使用String类的构造方法创建字符串对象
• 能够明确String类的构造方法创建对象,和直接赋值创建字符串对象的区别
• 能够使用文档查询String类的判断方法
• 能够使用文档查询String类的获取方法
• 能够使用文档查询String类的转换方法
• 能够理解static关键字
• 能够写出静态代码块的格式
• 能够使用Arrays类操作数组
• 能够使用Math类进行数学运算

第一章 String类

1.1 String类概述

概述

java.lang.String 类代表字符串。

特点

1、字符串的内容是常量，永远不变
2、正是因为不变，所有字符串可以共享使用
3、字符串效果上相当于char[]字符数组，但底层原理上byte[]字节数组

直接赋值写上的双引号字符串在字符常量池中

1.2 使用步骤

查看类

①导包，属于lang自动导包

查看构造方法

②构造方法创建对象

1、无参
String st = new String();
2、字符数组
char chars[] = {‘a’,‘b’,‘c’}; #? 两种写法都可？char[] chars = {‘a’,‘b’,‘c’}；
String st1 = new String(chars);
3、字节数组
byte bytes[] = { 97, 98, 99 };
String str2 = new String(bytes);

1.3 常用方法

判断功能的方法

1、区分大小写是否等于 equals(Object obj)
2、不区分大小写是否等于 equalsIgnoreCase(String str)

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法
public boolean equals（ Object obj），参数可以是任何对象，只有参数是一个宇符串并且内容相同的才会给 truer否则返回 false。
注意事项
1，任何对象都能用 Object进行接收，
2. equals方法具有对称性，也就是a.equals（b）和b,.equaLs（a）效果一样
3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面
推荐：“abc”， equals（str）不推荐：str, equals（"abc）

获取功能的方法

1、获取字符串长度
public int length ()
2、将指定的字符串连接到该字符串的末尾
public String concat (String str)
3、返回指定索引处的char值
public char charAt (int index)
4、返回指定子字符串第一次出现在该字符串内的索引，没有返回-1
public int indexOf (String str)
5、返回一个子字符串，从beginIndex开始截取字符串到字符串结尾
public String substring (int beginIndex)
6、返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex [)
public String substring (int beginIndex, int endIndex)
#快捷键 创建对象


#快捷键 查源码 ctrl+名字 /ctrl + n搜索 可其查看源码

转换功能的方法

1、将此字符串转换为新的字符数组:
public char[] toCharArray ()
2、使用平台的默认字符集将该 String编码转换为新的字节数组：
public byte[] getBytes ()
3、将与target匹配的字符串使用replacement字符串替换
public String replace (CharSequence target, CharSequence replacement)
CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

分割功能的方法

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

举例

package demo01spring;
/*
①导包，属于lang自动导包
②构造方法创建对象
    1、无参
    String st = new String();
    2、字符数组
    char chars[] = {'a','b','c'}; ?
    String st1 = new String(chars);
    3、字节数组
    byte bytes[] = { 97, 98, 99 };
    String str2 = new String(bytes);
③常用方法
    一、判断功能
        1、区分大小写是否等于 equals(Object obj)
        2、不区分大小写是否等于 equalsIgnoreCase(String str)
    二、获取功能
        1、获取字符串长度 public int length ()
        2、将指定的字符串连接到该字符串的末尾 public String concat (String str)
        3、返回指定索引处的char值 public char charAt (int index)
        4、返回指定子字符串第一次出现在该字符串内的索引，没有返回-1 public int indexOf (String str)
        5、返回一个子字符串，从beginIndex开始截取字符串到字符串结尾public String substring (int beginIndex)
        6、返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex [)
            public String substring (int beginIndex, int endIndex)
    三、转换功能
        1、将此字符串转换为新的字符数组:public char[] toCharArray ()
        2、使用平台的默认字符集将该 String编码转换为新的字节数组：public byte[] getBytes ()
        3、将与target匹配的字符串使用replacement字符串替换
            public String replace (CharSequence target, CharSequence replacement)
            CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。
    四、分割功能
        将此字符串按照给定的regex（规则）拆分为字符串数组:public String[] split(String regex)
         */

import javax.swing.*;

public class Demo01Equals {
    public static void main(String[] args) {
        //创建String对象
        String st1 = "swag";
        String st2 = "swag";
        String st3 = "Swag";

//一、判断功能
        //equals(Object obj)方法比较大小，不忽略大小写
        System.out.println(st1.equals(st2));//true
        System.out.println(st1.equals(st3));//false

        //equalsIgnoreCase(String str)方法比较大小，忽略大小写
        System.out.println(st1.equalsIgnoreCase(st2));//true
        System.out.println(st1.equalsIgnoreCase(st3));//true

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

//二、获取功能
        //         1、获取字符串长度 public int length ()
        System.out.println(".length()字符串长度"+st1.length());//4

        //         2、将指定的字符串连接到该字符串的末尾 public String concat (String str)
        System.out.println(".concat()连接到该字符串的末尾:"+st1.concat(st3));//swagSwag

        //        3、返回指定索引处的char值 public char charAt (int index)
        System.out.println(".charAt()索引处的char值"+st1.charAt(1));//w

        //        4、返回指定子字符串第一次出现在该字符串内的索引，没有返回-1 public int indexOf (String str)
        System.out.println("子字符串第一次出现在该字符串内的索引"+st1.indexOf("d"));//-1
        System.out.println("子字符串第一次出现在该字符串内的索引"+st1.indexOf("sw"));//0
        System.out.println("子字符串第一次出现在该字符串内的索引"+st1.indexOf("sd"));//-1

        //        5、返回一个子字符串，从beginIndex开始截取字符串到字符串结尾public String substring (int beginIndex)
        System.out.println("从beginIndex开始截取字符串到字符串结尾"+st1.substring(1));//wag

        //        6、返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex [)
        System.out.println("从beginIndex到endIndex截取字符串"+st1.substring(1,3));//wa

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

//三、转换功能
//        1、将此字符串转换为新的字符数组:public char[] toCharArray ()
        // char[] toCharArray():把字符串转换为字符数组
        char[] chs = st1.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i]);
        }

//        2、使用平台的默认字符集将该 String编码转换为新的字节数组：public byte[] getBytes ()
        // byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes = st1.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }

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

//        3、将与target匹配的字符串使用replacement字符串替换 public String replace (CharSequence target, CharSequence replacement) ：
        //// 替换字母sw为a
        String st4 = st1.replace("sw","a");
        System.out.println(st4);
        System.out.println("=========================");

//    四、分割功能
       // public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。
        String st5 = "fa@re@la";
        String[] strArray = st5.split("@");//["fa","re","la"]
        for (int i = 0; i < strArray.length; i++) {
            System.out.println(strArray[i]);//fa re la
        }

    }
}

1.4 String类的练习

拼接字符串

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

package demo01spring;
//定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。
/*思路：
1、创建数组 array
2、定义方法
    三要素：返回值 String 方法名 getString 参数int array[]*/
public class Text01String {
    public static void main(String[] args) {
        //定义一个int数组
        int[] array = {1,2,3};
        //调用方法 给方法传参数
        String s1 = getSpring(array);
        //输出结果打印字符串
        System.out.println(s1);//结果：[1#2#3]
    }
    //定义一个方法
    public static String getSpring(int array[]){
        //创建字符串s且初始化
        String s = new String("[");
        //遍历数组并拼接字符串
        for (int i = 0; i < array.length; i++) {
            if(i==array.length-1){
                s = s.concat(array[i]+"]");
            }else {
                s = s.concat(array[i]+"#");
            }
        }
        return s;
    }
}

统计字符个数

键盘录入一个字符，统计字符串中大小写字母及数字字符个数

package demo01spring;

import java.util.Scanner;

//键盘录入一个字符，统计字符串中大小写字母及数字字符个数
/*//思路：
1、Scanner录入字符
2、判断大小写数字个数if count++*/
public class Test02CountString {
    public static void main(String[] args) {
        //创建Scanner对象st
        Scanner st = new Scanner(System.in);
        //提示输入
        System.out.println("请输入字符");//dkjf$@#333FGG

        //.nextLine()方法获取st值赋给字符串s
        String s = st.nextLine();

        //定义三个变量初始化0

//        char bigCount = 0; 为啥这样不报错？
        int bigCount = 0;
        int smallCount = 0;
        int numCount = 0;
        int otherCount = 0;

        //循环判断++

        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i); //为什么是char不是string 回顾char 已知 单字符
            if(ch>='A'&&ch<='Z'){
                bigCount++;
            } else if(ch>='a'&&ch<='z'){
                smallCount++;
            } else if (ch>='0'&&ch<='9'){
                 numCount++;
            }else{
                otherCount++;
            }
        }
//        System.out.println("字符串中大小写字母及数字字符个数分别是"+(bigCount,smallCount,numCount));//#bug 为什么这样写错误？
        System.out.println("大写字母个数为" +bigCount); //大写字母个数为3
        System.out.println("小写字母个数为" +smallCount);//小写字母个数为4
        System.out.println("数字个数为" +numCount);//数字个数为3
        System.out.println("其他字符个数为"+ otherCount );//其他字符个数为3
    }

}

第二章 static关键字

2.1 概述

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。
static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。

2.2 定义和使用格式

类变量

静态方法

调用格式

package demo02static;
//定义学生类
//定义成员变量 、 构造方法
public class Student {
    //为什么要封装？
    private  int id;
        private String name;
        private int age;
        static int room;
        private static int idCount = 0;//每当new了一个新对象时计数器++，为啥前面要加private？
    public Student(){
        this.id = ++idCount;
    }
    //为什么用this？
    public Student(String name,  int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCount;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

//调用Student类
package demo02static;

public class Static {
    public static void main(String[] args) {
    Student st1 = new Student("卡卡",13);
    st1.room =101;
        System.out.println("姓名:"+st1.getName()+",年龄："+st1.getAge()+"教室："+st1.room
        +"学号"+st1.getId());//姓名:卡卡,年龄：13教室：101学号1
    Student st2 = new Student("新新",36);
        System.out.println("姓名:"+st2.getName()+",年龄："+st2.getAge()+"教室："+st1.room
        +"学号"+st2.getId());//姓名:新新,年龄：36教室：101学号2

    }

}

package demo02static;

public class MyClass {
    //成员变量
    int age;
    //静态变量
    static int num;
    //成员方法 可以访问静态变量
    public void method(){
        System.out.println("这是一个成员方法");
        System.out.println(age);
        System.out.println(num);
    }
    //静态方法
    public static void staticmethod(){
        System.out.println("这是一个静态方法");
       // System.out.println(age);静态方法不可直接访问成员变量  错误写法
        //System.out.println(this); this表示当前对象 错误写法静态方法不能使用this关键字
        System.out.println(num);
    }
}
===
package demo02static;

public class Demo02StaticMethod {
    public static void main(String[] args) {
    //成员方法调用要先创建对象
        MyClass m = new MyClass();
        m.method();//这是一个成员方法

        //静态方法不用创建对象
        m.staticmethod();//不推荐 对象名.静态方法； 这是一个静态方法
        MyClass.staticmethod();//推荐 类名称.静态方法； 这是一个静态方法

        //对于本类当中的静态方法，可以省略类名称
        myMethod();//自己的方法
        Demo02StaticMethod.myMethod();//自己的方法 相等
    }
    public static void myMethod(){
        System.out.println("自己的方法");
    }
}

2.3 静态原理图解

2.4 静态代码块

典型用途，用来一次性得给静态成员变量赋值

第三章 Arrays类

3.1 概述

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

3.2 操作数组的方法

3.3 练习

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

package demo02static;

import java.util.Arrays;
import java.util.Random;

//请使用 Arrays 相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
/*思路：
1、Random/ 手写
2、sort 字符串转成数组
3、for i--*/
public class Test01String {
    public static void main(String[] args) {
        //如何产生随机字符串？
        /*Random r = new Random();
        int[] num;
        for (int i = 0; i < 5; i++) {
            int x = r.nextInt();//只能是int~float？
        }*/
        String st = "dfjeiu23jodfdxv";
        char[] c = st.toCharArray();
        //排列
        Arrays.sort(c);
        //倒序打印
        for (int i = c.length - 1; i >= 0; i--) {
            System.out.println(c[i]);
        }

    }
}

第四章 Math类

4.1 概述

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

4.2 基本运算的方法

4.3 练习

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

package demo03math;
/*请使用 Math 相关的API，计算在 -10.8 到 5.9 之间，绝对值大于 6 或者小于 2.1 的整数有多少个？
1、定义最小值、最大值、计数变量
2、整数 ceil判断之间绝对值，count++
*/
public class Test01 {
    public static void main(String[] args) {
        double min = -10.8;
        double max = 5.9;
        int count = 0;
        for(double i=min;i<=max;i++){
            /*可强转 for(int i = (int)min;i<=max;i++)
            可for(double i=Math.ceil(min;i<=max;i++) */
            if(Math.abs(i)>6||Math.abs(i)<2.1){
                count++;
            }
        }
        System.out.println(count);//9
    }

}