Day08-String-static-Arrays-Math

String类

java.lang.String类代表字符串
程序中所有的双引号字符串，都是String类的对象。(就算没有new，也照样是)

1.字符串的特点：【重点】

1.字符串的内容不可变，字符串是常量；它们的值在创建之后不能更改。【重点】
2.正是因为字符串不可改变，所以字符串是可以共享使用的。
3.字符串效果上相当于是char[ ]字符数组，但是底层原理是byte[ ]字节数组。

2.创建字符串的常见3+1种方式：

三种构造方法：
public String()：创建一个空白字符串，不含有任何内容。
public String(char[] array)：根据字符数组的内容，来创建对应的字符串。
public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = “Hello”；//右边直接用双引号
注意：直接写上双引号，就是字符串对象。

package day08.demo01;
public class Demo01String {
    public static void main(String[] args) {
        //使用空参构造
        String str1 = new String();//小括号留空，说明字符串什么内容都没有。
        System.out.println("第1个字符串：" + str1);//第1个字符串：

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

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

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

3.字符串常量池：

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池种。new的不在池当中。

4.String与比较相关的方法:

对于基本类型来说：== 是进行数值的比较。

对于引用类型来说：==是进行【地址值】的比较。

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

1.public boolean equals(Object obj)

参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true，否则返回false。
注意事项：
1.任何对象都能用Object进行接收。
2.equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3.如果比较双方一个是常量一个是变量，推荐把常量字符串写在前面。
推荐：“abc”.equals(str) 不推荐str.equals(“abc”)

2.public boolean equalsIgnoreCase(String str)

忽略大小写，进行内容比较。

5.String与获取相关的方法：

1.public int length()

获取字符串当中还有的字符个数，拿到字符串长度。
str.length();

2.public String concat(String str)

将当前字符串和参数字符串拼接成为返回值新的字符串
String str1 = “ab”;
String str2 = “cd”;
String str3 = str1.concat(str2);//拼接后str3为"abcd"

3.public char charAt(int index)

获取指定索引位置的单个字符。（索引从0开始）
String str = “abc”;
char ch = str.charAt(1);//字符ch的值为b

4.public int indexOf(String str)

查找参数字符串在本字符串当中首次出现的索引位置，如果没有，返回-1值。
int index = “HelloWorld”.indexOf(“Wor”);//index为5
int index2 = “Hello”.indexOf(“cvc”);//-1

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

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

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

        //查找参数字符串在本来字符串当中出现的第一次索引位置
        //如果根本没有，返回-1值。
        String original = "HelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次索引值是：" + index);//2

        System.out.println("HelloWord".indexOf("abc"));//-1
    }
}

6.String与截取相关的方法：

1.public String substring(int index)

截取从参数位置一直到字符串末尾，返回新字符串
String str1 = “HelloWorld”;
String str2 = str1.substring(5);//“World”

2.public String substring(int begin,int end)

截取从begin开始，一直到end结束，中间的字符串。
【注意】[begin,end)，左闭右开区间，包含左边，不包含右边
String str1 = “HelloWorld”;
String str2 = str1.substring(4,7);//“oWo”

7.String与转换相关的方法：

1.public char[] toCharArray()

将当前字符串拆分成为字符数组作为返回值
char[] ch = “Hello”.toCharArray();

2.public byte[] getBytes()

获取当前字符串底层的字节数组
byte[] bt = “Hello”.getBytes();

3.public String replace(CharSequence oldString,CharSequence newString)

将所有出现的老字符串替换成为新的字符串，返回替换后的结果新字符串。
备注：CharSequence意思是可以接收字符串类型。
String str1 = “我是abcabc”;
String str2 = str1.replace(“是”,“嘿嘿”);//“我嘿嘿abcabc”
String str3 = “啊吧啊啊啊吧啊啊吧吧”;
String str4 = str3.replace(“啊吧”,“!”);//“!啊啊!啊!吧”

8.String与分割相关的方法：

public String[] split(String regex)

按照参数的规则，将字符串切分成为若干部分。
注意事项：
split方法的参数其实是一个“正则表达式”
如果按照英文句点“.”进行分割，必须写成“\.”(加两个反斜杠)

package day08.demo02;
public class DemoStringSplit {
    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);//3
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
    }
}

String常用方法总结

1.public boolean equals(Object obj)
2.public boolean equalsIgnoreCase(String str)

3.public int length()
4.public char charAt(int index)
5.public int indexOf(String str)
6.public String concat(String str)

7.public String substring(int index)
8.public String substring(int begin,int end)

9.public String replace(CharSequence oldStr,CharSequence newStr)
10.public char[] toCharArray();
11.public byte[] getBytes();

12.public String[] split(String regex)

static关键字

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

1.static用于修饰类的变量

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

2.静态方法

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
如果方法没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果方法有了static关键字，那么不需要创建对象，直接就能通过类名称使用它。格式:类名称.静态方法名

对于静态方法来说，可以通过对象名进行调用，也可以通过类名称调用。
对于调用本类当中的静态方法，可以省略类名称。
无论是成员变量，还是成员方法，如果有了static，都推荐类名称进行调用。
静态变量：类名称.静态变量;
静态方法：类名称.静态方法();

3.【注意事项】：【重点】

1.静态只能访问静态，静态不能直接访问非静态。

比如在静态方法中访问类中的非静态成员变量
原因：因为内存当中是【先】有的静态内容，【后】有的非静态内容。
“先人不知道后人，但是后人知道先人”

2.静态方法当中不能使用this。

原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。但是静态与对象没关系。

一定要熟悉理解下面的代码

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);//错误写法
    }
}

4.static原理

static修饰的内容：是随着类的加载而加载的，且只加载一次
存储于一块固定的内存区域(静态区)，所以可以直接被类名调用
它优先于对象存在，所以，可以被所以对象共享
根据类名称访问静态变量的时候，全程和对象没有任何关系，只和类有关系

5.静态代码块【重点】

格式：

public class 类名称{
	static {
		//静态代码块的内容
	}
}

特点：

当第一次用到本类时，静态代码块【自动】执行且执行【唯一】的一次。
静态内容总是优先于非静态，所以【静态】代码块【比】【构造方法】【先】执行。
比如刚new的对象，Student stu = new Student();
静态代码看到用到最左边的Student类了，那么Student中的静态代码块就会最先自动执行唯一一次

用途：

静态代码块最典型的用途：用来一次性地对静态成员变量进行赋值。

static需要牢记的：

1.静态只能访问静态，静态不能访问非静态（比如在静态方法中访问类中的非静态成员变量）
2.静态方法中不能使用this关键字
3.静态代码块，在第一次使用本类的那一刻，静态代码块的内容会自动执行且执行唯一一次，比构造方法都要先执行，一般用于给静态变量批量的初始化。

Arrays类

java.util.Arrays类包含用来操作数组的各种方法，其中所有的方法都是【静态方法】，调用起来非常简单

1.public static String toString(数组)

将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3…]）

		int[] intArray = {10,20,30};
		String intStr = Arrays.toString(intArray);
		System.out.println(intStr);//[10, 20, 30]

2.public static void sort(数组)

按照默认升序（从小到大）对数组的元素进行排序。
注意：1.如果是数值，sort默认按照升序从小到大
2.如果是字符串，sort默认按照字母升序
3.如果是自定义的类型，那么这个自定义的类需要Comparable或者Comparator接口的支持（之后学习）

		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]

Math类

java.util.Math类是数学相关的工具类，里面提供了大量的【静态方法】,完成与数学运算相关的操作。

1.public static double abs(double num)

获取绝对值，有多种重载

        System.out.println(Math.abs(3.14));//3.14
        System.out.println(Math.abs(-2.15));//2.15
        System.out.println(Math.abs(0));

2.public static double ceil(double num)

向上取整

        System.out.println(Math.ceil(3.1));//4.0
        System.out.println(Math.ceil(3.0));//3.0

3.public static double floor(double num)

向下取整

        System.out.println(Math.floor(30.15));//30.0
        System.out.println(Math.floor(42.99));//42.0
        System.out.println(Math.floor(40.0));//40.0

4.public static long round(double num)

四舍五入

        System.out.println(Math.round(20.4));//20
        System.out.println(Math.round(21.5));//22
        System.out.println(Math.round(36.0));//36

5.Math.PI代表近似的圆周率常量(double)。