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++;
}
}
}
}