2021-03-04：java第8天：字符串，static，Array类，Math类

学习目标：

掌握 Java 入门知识

---

学习内容：

字符串的概述和特点：

package Day_8;
/*
java.lang.String类代表字符串
API当中说，java程序中所有字符串字面值“abc”都作为此类的实例实现
程序当中所有的双引号字符串，都是String类的对象，就算没有new,也照样是
字符串的特点；
1.字符串的内容用不可变！！
2.正是因为字符串不可改变，所以字符串是可以共享使用的。
3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的常见3+1种方式：
三种构造方法：
public String();创建一个空白字符串，不含有任何内容
public String(char[] array)：根据字符数组的内容，来创建对应的字符串
public String(byte[] array):根据字节数组的内容，来创建对应的字符串
一种直接创建：
String str = "Hello";

注意:直接协商双引号，就是字符串对象。JVM帮我new了
 */
public class demo01String {
    public static void main(String[] args) {
        //空参
        String str1 = new String();
        //根据字符数组创建字符串
        char[] charArray={'A','B','C'};
        String str2 = new String(charArray);
        System.out.println(str2);
        //根据字节数组创建字符串
        byte[] byteArray = {97,98,99};
        String str3 = new String(byteArray);
        System.out.println(str3);

        //直接创建
        String str = "Hello";
    }

}

字符串的常量池：

package Day_8;
/*
字符串常量池(堆当中)：程序当中直接写上的双引号字符串，就在字符串常量池中。

对于基本类型来说，==是进行数值的比较。
对于引用类型来说，==是进行【地址值】的比较。
 */
public class demo02StringPool {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        char[] charArray = {'a','b','c'};
        String str3 = new String(charArray);
        //str1 = str2
        //str3!=str1  str3!=str2
    }
}

 

字符串的比较的相关方法：

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

方法1：
public boolean equals(Object obj):参数可以是任何对象，但只有参数是一个字符串并且内容相同的才会给true。
注意事项：
1.任何对象都能用Object进行接收。
2.equals方法具有对称性，a.equals(b)和b.equals(a)效果一样。
3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面
推荐： “Hello”.equals(str1)
为什么？
    String str2 = null;
    System.out.println(str2.equals("Hello"));//不推荐：报错，空指针异常
    System.out.println("Hello".equals(str2));//推荐：null

 方法2：
 public boolean equalsIgnoreCase(String str); //忽略字符串大小写
 注意：只有英文字母区分大小写，其他都不
 System.out.println("abc一123".equalsIgnoreCase(“abc壹123”));
 */
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(str3));
        System.out.println("Hello".equals(str1));
    }
}

package Day_8.demo02;
/*
String当中与获取相关的常用方法有:
public int length(); 获取字符串当中含有的字符个数，拿到字符串长度
public String concat(String str); 将当前字符串和参数字符串拼接
public char charAt(int index); 获取指定索引位置的单个字符(索引从0开始)
public int indexOf(String str); 查找参数字符串在本字符串当中首次出现的索引位置，如果没有，返回-1
 */
public class demo02StringGet {
    public static void main(String[] args) {
        //获取字符串长度
        int length = "asdsadefsdfsegv".length();
        System.out.println(length);
        //拼接后str1,str2都不改变，只是创建了新的字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        //获取指定索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是"+ch);
        //查找参数字符串在本来字符串当中出现的第一次索引位置
        String original = "Helloworld";
        int index = original.indexOf("llo");// 2

    }
}

package Day_8.demo02;
/*
字符串的截取方法：
public String substring(int index);截取从参数位置一致到字符串末尾，返回新字符串
public String substring(int begin, int end);截取从begin开始，一直到end结束，返回中间的字符串[begin,end)
 */
public class demo03SubString {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5); //World,新字符串

        String str3 = str1.substring(4,7);//4~6 oWo
        //下面这种写法，字符串的内容仍然是没有改变的
        //下面两个字符串"Hello","Java"; strA当中保存的是地址值
        String strA= "Hello"; //Hello
        strA = "Java";//Java
    }

}

 

package Day_8.demo02;

import java.nio.charset.StandardCharsets;

/*
String当中与转换相关的常用方法有：
public char[] toCharArray(); 将当前字符串拆分成为字符数组作为返回值
public byte[] getBytes();获得当前字符串底层的字节数组
public String replace(CharSequence oldString, CharSequence newString);
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串；
 */
public class demo04StringConvert {
    public static void main(String[] args) {
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);
        System.out.println(chars.length);//数组.length没有()

        //转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]); // 97 98 99
        }

        String str1 = "How do you do?";
        String str2 = str1.replace("o","*");
        //str2: H*w d* y*u d*? 游戏里骂脏话可以替换
    }
}

 

 

package Day_8.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(",");
        // aaa bbb ccc

        String str2 = "XXX.YYY.ZZZ";
        String[] array3 = str2.split("."); // 改为"\\."
        //array3.fori
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
            //英文中的句点不能切分
        }
    }
}

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

 */
public class demo06StringPractice {
    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 += "word" + array[i]+"]";
            } else{
                str += "word"+array[i]+"#";
            }
        }
        return str;
    }
}

package Day_8.demo02;

import java.util.Scanner;

/*
题目：
键盘输入一个字符串，并且统计其中各种字符出现的次数
种类有；大写字母、小写字母、数字、其他

思路：
1.Scanner
2.键盘输入字符串 String str = sc.next();
3.定义4个变量，代表4种不同字符的出现次数
4.对字符串字符字符的检查，String-->char[] toCharArray
5.遍历char[]数组，对当前字符的种类进行判断，并且变量计数
 */
public class demo07StringCount {
    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++;
            } else if ('a'<=ch&&ch<='z'){
                countlower++;
            } else if ('0'<=ch&&ch<='9'){
                countnumber++;
            } else{
                countother++;
            }
        }
    }
}

静态static关键字概述：

 

 

package Day_8.demo03;

public class demo01StaticField {
    public static void main(String[] args) {
        Student one = new Student("郭靖",19);
        Student two = new Student("黄蓉",16);
        one.room = "101教室";
        System.out.println("郭靖的教室"+one.room+"学号："+one.getId()); //101教室 学号1
        System.out.println("黄蓉的教室"+two.room+"学号:"+two.getId()); //101教室 学号2
    }
}

静态static关键字修饰成员方法:

package Day_8.demo03;

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(num);
        //错误写法，静态不能直接访问非静态
        //System.out.println(this);
        //错误写法，静态方法中不能使用this关键字
    }
}

 

package Day_8.demo03;
/*
一旦使用static修饰成员方法，那么成为静态方法，静态方法不属于对象，而是属于类
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它
如果有static关键字，那么不需要创建对象，直接就能通过类名称来使用它

无论是成员变量，还是成员方法，如果有了static,都推荐使用类名称进行调用
静态变量： 类名称.静态变量
静态方法：类名称.静态方法()

注意事项；
1.静态不能直接访问非静态
原因：因为在内存当中式先有的静态内容，后有的非静态内容
“先人不知道后人，但是后人知道先人”
2.静态方法当中不能用this
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象
 */
public class demo02StaticMethod {
    public static void main(String[] args) {
        Myclass obj = new Myclass();
        obj.method();

        obj.methodstatic();//不推荐，容易误以为这是一个普通方法，而不是静态
        //这种写法在编译之后也会被java翻译成为“类名称.静态方法名”

        Myclass.methodstatic();//推荐
        //对于本来当中的静态方法，可以省略类名称
        myMethod();
        demo02StaticMethod.myMethod();
    }
    public static void myMethod(){
        System.out.println("这是个静态方法");
    }
}

方法区里放class(成员变量及成员方法)；栈里放正在运行的进栈的方法和对象，变量；堆里放new出来的东西。堆里放的new的类的方法是一个地址值，对象也有一个相应的地址，放在栈里。

 

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

静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值。
 */
public class demo04Static {
    public static void main(String[] args) {
        Person one = new Person();// 静态代码块执行！ 构造方法执行！
        Person two = new Person();//构造方法执行！
    }
}

 

package Day_8.demo03;
/*
静态代码块的格式是：
public class 类名称{
    static {
        //静态代码块的内容
        }
    }
特点：当第一次使用到本类时，静态代码块执行唯一的一次
 */
public class Person {
    static{
        System.out.println("静态代码块执行！");
    }
    public Person(){}
}

 

package Day_8.demo04;

import java.util.Arrays;

/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组的常见操作
public static String toString(数组)：将参数数组变成字符串
public static void sort(数组)：按照默认升序(从小到大)排列
备注：
1.如果是数值，sort默认按照升序从小到大
2.如果是字符串，sort默认按照字母升序
3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持
 */
public class demo01Arrays {
    public static void main(String[] args) {
        int[] intArray = {10,20,30};
        String intStr = Arrays.toString(intArray);//[10,20,30]
        int[] array1 = {2,1,3,10,6};
        Arrays.sort(array1);//[1,2,3,6,10]
        String[] array2 = {"bbb","aaa","ccc"};
        Arrays.sort(array2); //aaa bbb ccc
    }
}

 

package Day_8.demo04;

import java.util.Arrays;

/*
排序后倒序输出
 */
public class demo02ArraysPractice {
    public static void main(String[] args) {
        String str = "afesfdvgfnrtfbf";
        char[] str1 = str.toCharArray();
        Arrays.sort(str1);

        //需要倒序遍历
        for (int i = str1.length - 1; i >= 0; i--) {
           System.out.println(str1[i]);
        }

    }
}

 

package Day_8.demo04;
/*
java.util.Math是数学相关的工具类，里面提供了大量静态方法，完成与数学运算相关的操作

public static double abs(double num):获取绝对值
public static double ceil(double num):向上取整
public static double floor(double num):向下取整
public static long round(double num):四舍五入
Math.PI代表近似的圆周率常量(double)
 */
public class demo03Math {
    public static void main(String[] args) {
        System.out.println(Math.abs(-2.5));//2.5
        System.out.println(Math.ceil(3.9));//4.0
        System.out.println(Math.floor(30.9));//30.0
        System.out.println(Math.round(10.5));//11

    }
}

 

package Day_8.demo04;
/*
题目：
计算在-10到5.9之间，绝对值大于6或者小于2.1的整数
 */
public class demo04MathPractice {
    public static void main(String[] args) {
        double min = -10.8;
        double max = 5.9;
        int count = 0;
        for (int i =(int)min; i < max; i++) {
            int abs = Math.abs(i);
            if (abs >6 || abs <2.1){
                count++;
            }
        }
    }
}