第二阶段 day03 String类、static关键字、Array类、Math类
今日内容
- String类
- static关键字
- Arrays类
- Math类
目标:
能够使用String类的构造方法创建字符串对象
能够明确String类的构造方法创建对象,和直接赋值创建字符串对象的区别
能够使用文档查询String类的判断方法
能够使用文档查询String类的获取方法
能够使用文档查询String类的转换方法
能够理解static关键字
能够写出静态代码块的格式
能够使用Arrays类操作数组
能够使用Math类进行数学运算
第一章 String类
1.1 String类概述
概述
java.lang.String 类代表字符串。Java程序中所有的字符串文字(例如"abc" )都可以被 看作是实现此类的实例。
类 String 中包括用于检查各个字符串的方法,比如用于比较字符串,搜索字符串,提取子字 符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。
特点
1 字符串不变:字符串的值在创建后不能被更改。
String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有 “abc”, “abcd” 两个对象,s1从指向“abc”, 改变指向,指向了“abcd”
2 因为String对象是不可变的,所以他们可以被共享
String s1 = "abc";
String s2 = "abc";
// 内存中只有一个“abc”对象被创建,同时被s1和s2共享
3 “abc” 等效于 char[] date = {‘a’, ‘b’, ‘c’};(仅限于JDK8 和以前版本)
“abc” 等效于byte[] by = {97, 98, 99}; (仅限于JDK以上版本 9 10 11 13 )
例如:
String str = "abc";
相当于:
char date[] = {'a', 'b', 'c'};
String str = new String(date);
// String 底层是靠字符数组实现的 。(仅限于JDK8 和以前版本)
相当于:
byte[] by = {97, 98, 99};
String str = new String(by);
// String 底层是靠字节数组实现的 。(仅限于JDK以上版本 9 10 11 13 )
1.2 使用步骤
查看类
java.lang.String :此类不需要导入。
查看构造方法
public String() :初始化新创建的 String对象,以使其表示空字符序列。
public String(char[] value) :通过当前参数中的字符数组来构造新的String。
public String(byte[] bytes) :通过使用平台的默认字符集解码当前参数中的字节数组来构造 新的String。
构造举例,代码如下:
// 无参构造
String str = new String();
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);
1.3 常用方法
判断功能的方法
public boolean equals (Object anObject) :将此字符串与指定对象进行比较。
public boolean equalsIgnoreCase (String anotherString) :将此字符串与指定对象进行比较,忽略大小写。
boolean contains(String s):判断字符串中是否包含指定的内容。
boolean startsWith(String prefix):判断字符串是否以指定的内容开头。
boolean endsWith(String suffix):判断字符串是否以指定的内容结尾
方法演示,代码如下:
package cn.witty.string.demo01;
/*
判断方法:
boolean equals(Object anObject):比较两个字符串的内容是否相同。参数如果是Object,可以传递任何数据,包括字符串。
boolean equalsIgnoreCase(String anotherString):比较两个字符串的内容是否相同,不区分大小写。
boolean contains(String s):判断字符串中是否包含指定的内容。
boolean startsWith(String prefix):判断字符串是否以指定的内容开头。
boolean endsWith(String suffix):判断字符串是否以指定的内容结尾
*/
public class Demo04StringMethod {
public static void main(String[] args) {
// 创建字符串
String s1 = "JAVA";
String s2 = "java";
// boolean equals(Object anObject):比较两个字符串的内容是否相同。参数如果是Object,可以传递任何数据,包括字符串。
boolean b1 = s1.equals(s2);
System.out.println("s1.equals(s2): " + b1);
// boolean equalsIgnoreCase(String anotherString):比较两个字符串的内容是否相同,不区分大小写。
boolean b2 = s1.equalsIgnoreCase(s2);
System.out.println("s1.equalsIgnoreCase(s2): " + b2);
// boolean contains(String s):判断字符串中是否包含指定的内容。 区分大小写
boolean b3 = s1.contains("JA");
System.out.println("s1.contains('JA'):" + b3);
// boolean startsWith(String prefix):判断字符串是否以指定的内容开头。
boolean b4 = s1.startsWith("J");
System.out.println("s1.startsWith(\"J\"): " + b4);
// boolean endsWith(String suffix):判断字符串是否以指定的内容结尾
boolean b5 = s1.endsWith("VA");
System.out.println("s1.endsWith(\"VA\"): " + b5);
}
}
Object 是” 对象”的意思,也是一种引用类型。作为参数类型,表示任意对象都可以传递到方法中。
获取功能的方法
public int length () :返回此字符串的长度。
public String concat (String str) :将指定的字符串连接到该字符串的末尾。
public char charAt (int index) :返回指定索引处的 char值。
public int indexOf (String str) :返回指定子字符串第一次出现在该字符串内的索引。
public String substring (int beginIndex) :返回一个子字符串,从beginIndex开始截取字符串到字符串结尾。
public String substring (int beginIndex, int endIndex) :返回一个子字符串,从beginIndex到
endIndex截取字符串。含beginIndex,不含endIndex。
方法演示,代码如下:
package cn.witty.string.demo01;
/*
字符串的获取方法
int length():获取字符串的长度并返回。 字符串中有几个字符,那么字符串的长度就是几
char charAt(int index):获取指定索引位置的字符并返回。
int indexOf(String str):查找某个字符串第一次出现的索引。如果没有找到,返回-1
int lastIndexOf(String str):查找某个字符串最后一次出现的索引。如果没有找到,返回-1
String concat(String str): 将字符串进行拼接,返回拼接后新的字符串。
String substring(int beginIndex):截取字符串,从beginIndex索引位置开始截取,一直截取到最末尾。 返回截取后新的字符串。
String substring(int beginIndex, int endIndex):截取字符串。从beginIndex位置开始截取,截取到endIndex。
包含beginIndex,不包含endIndex。返回截取后新的字符串。
*/
public class Demo05StringMethod {
public static void main(String[] args) {
// 创建字符串
String s = "Hello,Java.GO.python.xxx天下第一。";
// int length():获取字符串的长度并返回。 字符串中有几个字符,那么字符串的长度就是几
int num1 = s.length();
System.out.println("s 长度:" + num1); // 29
// char charAt(int index):获取指定索引位置的字符并返回。
char ch = s.charAt(11);
System.out.println(ch); // G
// int indexOf(String str):查找某个字符串第一次出现的索引。如果没有找到,返回-1
int num2 = s.indexOf('G');
System.out.println(num2); // 11
// int lastIndexOf(String str):查找某个字符串最后一次出现的索引。如果没有找到,返回-1
int num3 = s.lastIndexOf('o');
System.out.println(num3); // 18
// String concat(String str): 将字符串进行拼接,返回拼接后新的字符串。
String s2 = s.concat("冯宝宝");
System.out.println("拼接字符串 concat :" + s2);
// String substring(int beginIndex):截取字符串,从beginIndex索引位置开始截取,一直截取到最末尾。 返回截取后新的字符串。
String s3 = s.substring(11);
System.out.println("substring() 截取:" + s3);
// String substring(int beginIndex, int endIndex):截取字符串。从beginIndex位置开始截取,截取到endIndex。
// 包含beginIndex,不包含endIndex。返回截取后新的字符串。
String s4 = s.substring(11, 13);
System.out.println("从beginIndex位置开始截取,截取到endIndex。:" + s4);
}
}
转换功能的方法
public char[] toCharArray () :将此字符串转换为新的字符数组。
public byte[] getBytes () :使用平台的默认字符集将该 String编码转换为新的字节数组。
String toLowerCase(): 将字符串全部转成小写并返回转换后新的字符串。
String toUpperCase(): 将字符串全部转成大写并返回转换后新的字符串。
public String replace (CharSequence target, CharSequence replacement) :将与target匹配的字符串使用replacement字符串替换。
方法演示,代码如下:
package cn.witty.string.demo01;
/*
转换方法
char[] toCharArray():将字符串转成字符数组并返回。
byte[] getBytes():将字符串转成字节数组并返回。
String toLowerCase(): 将字符串全部转成小写并返回转换后新的字符串。
String toUpperCase(): 将字符串全部转成大写并返回转换后新的字符串。
String replace(String oldStr, String newStr):替换字符串。 使用newStr替换掉所有的oldStr,并且返回替换后新的字符串。
*/
public class Demo06StringMethod {
public static void main(String[] args) {
// 创建字符串
String s = "Hello,Java.GO.python.xxx天下第一。";
// char[] toCharArray():将字符串转成字符数组并返回。
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i++) {
System.out.print(ch[i] + " ");
}
System.out.println();
// byte[] getBytes():将字符串转成字节数组并返回。
byte[] by = s.getBytes();
for (int i = 0; i < by.length; i++) {
System.out.print(by[i] + " ");
}
System.out.println();
// String toLowerCase(): 将字符串全部转成小写并返回转换后新的字符串。
String s2 = s.toLowerCase();
System.out.println(s2);
// String toUpperCase(): 将字符串全部转成大写并返回转换后新的字符串。
String s3 = s.toUpperCase();
System.out.println(s3);
// String replace(String oldStr, String newStr):替换字符串。 使用newStr替换掉所有的oldStr,并且返回替换后新的字符串。
String s4 = s.replace("o", "噢");
System.out.println(s4);
}
}
CharSequence 是一个接口,也是一种引用类型。作为参数类型,可以把String对象传递到方法中。
分割功能的方法
public String[] split(String regex) :将此字符串按照给定的regex(规则)拆分为字符串数组。
String trim():去除字符串两边的空格,去除空格之后的新的字符串会以返回值的形式交给我们方法演示,代码如下:
package cn.witty.string.demo01;
/*
字符串的分割方法
String[] split(String regex):根据指定字符串进行切割,切割之后的内容会放到字符串数组中返回。
String trim():去除字符串两边的空格,去除空格之后的新的字符串会以返回值的形式交给我们
*/
public class Demo07StringMethod {
public static void main(String[] args) {
// 创建字符串
String s = "Hello,Java.GO.python.xxx天下第一。";
// String[] split(String regex):根据指定字符串进行切割,切割之后的内容会放到字符串数组中返回。
String[] arr = s.split(",");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
// String trim():去除字符串两边的空格,去除空格之后的新的字符串会以返回值的形式交给我们
String s1 = " 你好, 哈喽 ";
String s2 = s1.trim();
System.out.println("原|" + s1 + "|");
System.out.println("现|" + s2 + "|");
}
}
1.4 String类的练习
拼接字符串
定义一个方法,把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下:[word1#word2#word3]。
package cn.witty.string.demo01;
/*
拼接字符串
定义一个方法,把数组{1,2,3}按照指定个格式拼接成一个字符串。
格式参照如下:[word1#word2#word3]。
*/
public class Demo09Test {
public static void main(String[] args) {
// 创建一个数组
byte[] by = {1, 2, 3};
// 参照格式拼接
String s = "[";
// 遍历拼接
for (int i = 0; i < by.length; i++) {
if ((by.length - 1) == i) {
s+=(by[i] +"]");
} else {
s+=(by[i] + "#");
}
}
// 输出
System.out.println(s);
}
}
统计字符个数
键盘录入一个字符,统计字符串中大小写字母及数字字符个数
package cn.witty.string.demo03;
import java.util.Scanner;
/*
1.5 String类的练习
1.5.1 统计字符个数
键盘录入一个字符,统计字符串中大小写字母及数字字符个数
*/
public class StringTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 1 创建字符串
String str = sc.next();
// 2 键盘录入一个字符,统计字符串中大小写字母及数字字符个数
traverse(str);
}
private static void traverse(String str) {
int x = 0;
int y = 0;
int z = 0;
int j = 0;
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
if (ch >= 'a' && ch <= 'z') {
x++;
} else if (ch >= 'A' && ch <= 'Z') {
y++;
} else if (ch >= '0' && ch <= '9') {
z++;
} else {
j++;
}
}
System.out.println("小写" + x);
System.out.println("大写" + y);
System.out.println("数字" + z);
System.out.println("其他" + j);
}
}
第二章 static关键字
2.1 概述
关于 static 关键字的使用,它可以用来修饰的成员变量和成员方法,被修饰的成员是属于类的,而不是单单是属于某个对象的。也就是说,既然属于类,就可以不靠创建对象来调用了。
2.2 定义和使用格式
类变量
当 static 修饰成员变量时,该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值,但也可以在不创建该类的对象的情况下对类变量进行操作。
- **类变量:**使用 static关键字修饰的成员变量。
定义格式:
举例:
比如说,小学开班,学员报到。现在想为每一位新来报到的同学编学号(sid),从第一名同学开始,sid为1,以此类推。学号必须是唯一的,连续的,并且与班级的人数相符,这样以便知道,要分配给下一名新同学的学号是多少。这样我们就需要一个变量,与单独的每一个学生对象无关,而是与整个班级同学数量有关。所以,我们可以这样定义一个静态变量numberID,代码如下:
public class Student {
private String name;
private int age;
private int id;
public static int numberID;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
// 使用numberID 为 id赋值
this.id = ++numberID;
}
public void show() {
System.out.println("姓名:" + name + " 年龄:" + age + " 学号:" + id);
}
}
public class StudentTest {
public static void main(String[] args) {
// 创建Student对象
Student stu1 = new Student("冯宝宝", 190);
Student stu2 = new Student("李庚希", 19);
Student stu3 = new Student("李逍遥", 22);
// 调用show方法
stu1.show();
stu2.show();
stu3.show();
}
}
静态方法
当static 修饰成员方法时,该方法称为类方法 。静态方法在声明中有static ,建议使用类名来调用,而不需要创建类的对象。调用方式非常简单。
- 类方法:使用 static关键字修饰的成员方法,习惯称为静态方法。
定义格式:
修饰符 static 返回值类型 方法名 (参数列表) {
// 执行语句
}
举例 :在Student类中定义静态方法
public static void show() {
System.out.println("姓名:" + name + " 年龄:" + age + " 学号:" + id);
}
静态方法调用的注意事项:
- 静态方法可以直接访问类变量和静态方法。
- 静态方法不能直接访问普通成员变量或成员方法。反之,成员方法可以直接访问类变量或静态方法。
-
静态方法中,不能使用this关键字。
小贴士:静态方法只能访问静态成员。
调用格式
格式:被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员,原因即多个对象均属于一个类,共享使用同一个静态成员,但是不建议,会出现警告信息。
// 访问类变量
类名.类变量名;
// 调用静态方法
类名.静态方法名(参数);
调用演示,代码如下:
package com.witty.web.demo08_static;
public class StudentDemo02 {
public static void main(String[] args) {
// 访问类变量
System.out.println(Student.numberID);
// 调用静态方法
Student.showNum();
}
}
2.3 静态原理图解
static 修饰的内容:
- 是随着类的加载而加载的,且只加载一次。
- 存储于一块固定的内存区域(静态区),所以,可以直接被类名调用。
- 它优先于对象存在,所以,可以被所有对象共享。
2.4 静态代码块
- 静态代码块:定义在成员位置,使用static修饰的代码块{ }。
- 位置:类中方法外。
-
执行:随着类的加载而执行且执行一次,优先于main方法和构造方法的执行。
格式:
public class ClassName() {
static {
// 执行语句
}
}
作用 : 给类变量进行初始化赋值,用法演示,代码如下:
package com.witty.web.demo08_static;
import java.util.ArrayList;
public class Game {
public static int number;
public static ArrayList<String> list;
static {
// 给类变量赋值
number = 2;
list = new ArrayList<String>();
// 添加元素到集合中
list.add("李庚希");
list.add("张子枫");
}
}
小贴士:
static 关键字,可以修饰变量、方法和代码块。在使用的过程中,其主要目的还是想在不创建对象的情况下,去调用方法。下面将介绍两个工具类,来体现static 方法的便利。
第三章 Arrays类
3.1 概述
java.util.Arrays 此类包含用来操作数组的各种方法,比如排序和搜索等。其所有方法均为静态方法,调用起来
非常简单。
3.2 操作数组的方法
public static String toString(int[] a) :返回指定数组内容的字符串表示形式。
package com.witty.web.demo09_arrays类;
import java.util.Arrays;
/*
public static String toString(int[] a) :返回指定数组内容的字符串表示形式。
*/
public class ArraysDemo01 {
public static void main(String[] args) {
// 定义int数组
int[] arr = {2, 34, 35, 4, 67, 66, 2};
// 打印数组,输出地址值
System.out.println(arr); // [[email protected]
// 数组内容转换为字符串
String s = Arrays.toString(arr);
// 打印字符串,输出内容
System.out.println(s); // [2, 34, 35, 4, 67, 66, 2]
}
}
public static void sort(int[] a) :对指定的 int 型数组按数字升序进行排序。
package com.witty.web.demo09_arrays类;
import java.util.Arrays;
/*
public static void sort(int[] a) :对指定的 int 型数组按数字升序进行排序。
*/
public class ArraysDemo02 {
public static void main(String[] args) {
// 定义int数组
int[] arr = {2, 34, 35, 4, 67, 66, 2};
// 排序前
System.out.println("排序前:" + Arrays.toString(arr));
// 排序后
Arrays.sort(arr);
System.out.println("排序后:" + Arrays.toString(arr));
}
}
3.3 练习
请使用Arrays 相关的API,将一个随机字符串中的所有字符升序排列,并倒序打印。
package com.witty.web.demo09_arrays类;
import java.util.Arrays;
/*
3.3 练习
请使用Arrays 相关的API,将一个随机字符串中的所有字符升序排列,并倒序打印。
*/
public class ArraysDemo03 {
public static void main(String[] args) {
// 设置字符串
String s = "dfasdfasgdfga13123";
char[] chars = s.toCharArray();
// 升序排列
Arrays.sort(chars);
// StringBuilder
StringBuilder sb = new StringBuilder(String.valueOf(chars));
// 反转
sb = sb.reverse();
// 打印
System.out.println(sb.toString());
}
}
第四章 Math类
4.1 概述
java.lang.Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。类似这样的工具
类,其所有方法均为静态方法,并且不会创建对象,调用起来非常简单。
4.2 基本运算的方法
public static double abs(double a) :返回 double 值的绝对值。
double d1 = Math.abs(-5); // d1 的值为5
double d2 = Math.abs(5); // d2 的值为5
public static double ceil(double a) :返回大于等于参数的最小的整数。
// public static double ceil(double a) :返回大于等于参数的最小的整数。
double c1 = Math.ceil(5.6); // 6.0
double c2 = Math.ceil(5.4); // 6.0
public static double floor(double a) :返回小于等于参数最大的整数。
// public static double floor(double a) :返回小于等于参数最大的整数。
double d3 = Math.floor(5.49); // 5.0
double d4 = Math.floor(5.51); // 5.0
public static long round(double a) :返回最接近参数的 long。(相当于四舍五入方法)
// public static long round(double a) :返回最接近参数的 long。(相当于四舍五入方法)
double l1 = Math.round(5.49); // 5.0
double l2 = Math.round(5.51); // 6.0
4.3 练习
请使用Math 相关的API,计算在 -10.8 到5.9 之间,绝对值大于6 或者小于2.1 的整数有多少个?
package com.witty.web.demo10_Math;
/*
#### 4.3 练习
请使用Math 相关的API,计算在 -10.8 到5.9 之间,绝对值大于6
或者小于2.1 的整数有多少个?
*/
public class MathTest02 {
public static void main(String[] args) {
// 统计数
int count = 0;
// 1 遍历
for (int i = (int) -10.8; i < 5.9; i++) {
int num = Math.abs(i);
if (num > 6 || num < 2.1) {
count++;
System.out.print(i + " ");
}
}
System.out.println();
System.out.println("数有:" + count);
}
}