文章目录
1. String类
1.1 String类概述
java.long.String 代表字符串的类（说明书）
API 说，java 程序当中所有字符串字面值（如"abc")都作为此类的实例实现，
其实就是说，程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。）
字符串的特点：
- 字符串的内容永不可变，字符串是常量。【重点】
- 正是因为字符串不可改变，所以字符串是可以共享使用。节省内存。
- 字符串效果上相对于char[]字符数组，但是底层原理【存储】是byte[]字节数组存储每个字母“字节数据”。？
创建字符串的常见3+1中方式：
三种构造方法
public String();创建一个空白字符串，不含有任何内容。
public String(char[] array);根据字符数组的内容，来创建对应的字符串。好多字给串起来。
public String(byte[] array);根据字节数组的内容，来创建对应的字符串。
一种直接创建
String str = “Hello!”//右边直接用双引号。
注意事项：直接写上双引号，就是字符串对象。 }
return smallList;
}
}
例子：
public class Demo01String {
public static void main(String[] args) {
//使用空参构造
String str1 = new String();//无参数的无内容的构造字符串
System.out.println("第一个字符串：" + str1);
//根据字符数组创建字符串
char[] charArray = new char[]{'A', 'B', 'C'};
String str2 = new String(charArray);//每单个字符串起来的字符串
System.out.println("第二个字符串：" + str2);
//根据字节数组来创建字符串
// byte[] byteArray = {'a', 'b','c'};//【提问】整数类型为什么可以存储字符串？
byte[] byteArray = {97, 98, 99};
String str3 = new String(byteArray);
System.out.println("第三个字符串：" + str3);
//直接创建
String str4 = "Hello!";
System.out.println("第四个字符串：" + str4);
}
}
1.2字符串常量池：
字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中，
对于基本类型来说，==是进行数值的比较；
对于引用类型来说，==是进行【地址值】得比较。
例子：
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);
System.out.println(str1 == str2);//true
System.out.println(str1 == str3);//false
System.out.println(str2 == str3);//false
}
}
1.3 字符串的相关方法
字符串的比较相关方法（功能）
【明确：】String是一个类，其中有成员方法（功能），调用成员方法（功能），直接用实体名称（对象名称）就行。
== 是进行对象的地址值比较，如果确实需要字符串的内容 比较，可以使用两个方法。
方法1：
public boolean equals(Object obj);//参数可以是任何对象只有参数是一个字符串并且内容相同才会给true，否则会返回false，Object暂时不学
注意事项：
- 任何对象都能用Object进行接受。参数是一个地址值，功能是对比地址值里面的内容。
- equals方法具有对称性，也即是说a.equals(b)与b.equals(a)效果一样。
- 如果比较双方一个常量一个变量，推荐把常量字符串写在前面：
推荐：“abc”.equals(a).不推荐：a.equals(“abc”)。
方法2：
public boolean equalsIgnoreCase(String str);忽略大小写，进行内容比较。
Ignore:忽略；Case：大小写。
例子：
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(str2));//true
System.out.println(str2.equals(str3));//true
System.out.println(str3.equals("hello"));//true
System.out.println("hello".equals(str1));//true
String str4 = "Hello";
System.out.println(str1.equals(str4));//false
System.out.println("---------------------------------");
// String str5 = "abc";
String str5 = null;//没new，无地址
System.out.println("abc".equals(str5));//推荐 false
// System.out.println(str5.equals("abc"));//不推荐，即使equals有对称性也不推荐，
//因为会出现空指针异常：NullPointerException情况。
System.out.println("---------------------------------");
System.out.println("---------------------------------");
String strA = "Java";
String strB = "java";
System.out.println(strA.equals(strB));//false
//严格区分大小写
System.out.println(str1.equalsIgnoreCase(str4));//true
//省略大写写
System.out.println("abc一123".equalsIgnoreCase("abc壹123"));//false
//注意：只有英文字母区分大小写，其他都不区分。
}
}
String与获取相关的常用方法（功能）
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) {
//1.获取字符串的长度。
int length = "1234567890".length();
System.out.println("字符串的长度是：" +length);
System.out.println("----------------------");
//2.拼接字符串
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);//Hello,World! 新的字符串拼接
System.out.println("----------------------");
System.out.println("----------------------");
//3.获取指定位置的单个字符
char ch = "hello".charAt(1);
System.out.println("在第1号索引位置的字符是：" + ch);
System.out.println("----------------------");
System.out.println("----------------------");
System.out.println("----------------------");
//4.查找参数字符串在本来字符串当中出现的第一次的索引位置，如果没有，返回-1值
String original = "helloworld";
int index = original.indexOf("le");
System.out.println("参数字符串在本字符串首次出现的索引是：" + index);//-1
}
}
字符串截取的子字符串(功能）
字符串的截取方法：
public String substring(int index);截取从参数位置一一直到字符串末尾，返回新字符串。[n,/0)
public String substring(int begin, int end);截取从begin开始，一直到end结束，中间的字符。[n,m)
备注：[begin.end),包含左边，不包含右边。
substring：子字符串。
例子：
public class Demo3SubString {
public static void main(String[] args) {
String str1 = "hello";
String str2 = str1.substring(0);
String str3 = str1.substring(0,5);//成员方法的重载形式[0,5)
System.out.println("原本字符串为：" + str1);//hello
System.out.println("参数位置截取到末尾子字符串为：" + str2);//hello
System.out.println("截取begin开始，end结束子字符串为：" + str3);//hello
System.out.println("----------------------------------");
//下面这种写法，字符串的内容仍然是没有改变的
//有两个字符串："Hello"\"Java"
//strA当中保存的是地址值，本来是"Hello"new的，后来是"Java"new的.
//看你用的是谁的地址了。
String strA = "Hello";
System.out.println(strA);//Hello
strA = "Java";
System.out.println(strA);//Java
}
}
String当中与转换相关的常用方法有（功能）
public char[] toCharArray();将当前字符串拆分成为字符[数组]作为返回值。
public byte[] getBytes();获得当前字符串底层的字节[数组]。
public String replace(charSequence oldString, CharSequence newString);
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
备注：charSequence 接口，意思就是说可以接受字符串类型。当做字符串。
例子：
public class Demo04StringConvert {
public static void main(String[] args) {
//转换成为字符数组
char[] chars = "Hello".toCharArray();//遍历，长度
System.out.println(chars[0]);//H
System.out.println(chars.length);//5
System.out.println("-----------------");
//转换成为字节数组 I/O流会用
byte[] bytes = "ABC".getBytes();
System.out.println(bytes.length);//3
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]);//65
}
// char a = 65;
// System.out.println(a);//A
System.out.println("-----------------");
//字符串的内容替换
String str1 = "How do you do?";
String str2 = str1.replace("do", "*");
System.out.println(str1);//How do you do?
System.out.println(str2);//How * you *?
System.out.println("-----------------");
String lang1 = "你大爷的！会不会玩儿呀！你大爷的！";
System.out.println("您输入的：" + lang1);
System.out.println("替换后的：" + lang1.replace("你大爷的","****"));
}
}
分隔字符串的方法（功能）
public String[] split(String regex);按照参数的规则，将字符串切分成若干部分。
注意事项：
split参数：regex其实是一个“正则表达式”，今后学习；
今天要注意，如果按照英文句点".“进行切分，必须写”\."（两个反斜杠）给个区分。
"."单独出现的时候在正则表达式当中有特殊含义。
例子：
public class Demo05StringSplit {
public static void main(String[] args) {
String str1 = "aa-a,bb-b,c-cc,dd-d";
String[] array1 = str1.split(",");
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]);
}
System.out.println("-----------------");
String str2 ="xxx.yyy.zzz";
String[] array2 = str2.split(".");//用"\\."
System.out.println(array2.length);//0
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i]);
}
}
}
1.4 String练习
题目：
拼接字符串 定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。
格式参照如下：[word1#word2#word3]。
思路：
- 首先准备一个int[]数组，内容是1,2,3。
- 定义一个方法，用来将数组变成字符串。
三要素：
返回值类型：String
方法名称：fromArrayToString
参数列表:int[]
3.格式：[word1#word2#word3]
用到：for循环、字符串拼接、每个数组元素之前都有一个Word字样、分隔使用的是#、区分是不是最后一个。
4.调用方法，得到返回值，并打印字符串。
public class Demo06StringPractice {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7};
String str = fromArrayToString(array);
System.out.println(str);
}
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;
}
}
题目：
键盘输入一个字符串，并且统计其中各种字符出现的次数。
种类有：大写字母、小写字母、数字、其他
思路：
- 既然用到键盘输入，肯定用是Scanner。
- 键盘输入的是字符串，那么：String str = sc.next();
- 定义四个变量，分别代表四种字符各自出现的次数。
4.需要对字符串一个字一个字的检查：String --> char[],方法就是toCharArray(); - 遍历char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。
- 打印输出四个变量，分别代表四种字符出现的次数。
import java.util.Scanner;
public class Demo07StringCount {
public static void main(String[] args) {
System.out.println("请随机输入一个字符串：" );
String str = new Scanner(System.in).next();//获取键盘输入一个字符串。
int countUpper = 0;//大写字母
int countLower = 0;//小写字母
int countNumber = 0;//数字
int countOther = 0;//其他字符
char[] charsArray = str.toCharArray();
for (int i = 0; i < charsArray.length; i++) {
char ch = charsArray[i];//当前单个字符
if('A' <= ch && ch <= 'Z'){//char类型进行数学运算时，可以提升int类型
countUpper++;
}else if('a' <= ch && ch <= 'z'){
countLower++;
}else if('0' <= ch && ch <= '9'){//输入的是字符0-9，所以用的是'0'.
countNumber++;
}else{
countOther++;
}
}
System.out.println("大写字母有：" + countUpper);
System.out.println("小写字母有：" + countLower);
System.out.println("数字有：" + countNumber);
System.out.println("其他字母有：" + countOther);
}
}
2. static关键字
2.1 概述
关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。
2.2 static定义和使用格式
静态变量：
当 static 修饰成员变量时，该变量称为【类变量】。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。
定义格式：
static 数据类型 变量名；
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XesiTY8C-1654688023437)(en-resource://database/1940:1)]
纠正一下图片：静态变量和方法的确在一个空间内，只不过不是在堆内存，而是在方法区：调用的时候与堆内存开辟的地址没关系，因为使用的是类名称调用的，指向的是方法区，所以与实体对象的地址空间没关系。【见2.3】
如果一个成员变量使用了static关键字，那么这个变量不再属于自己，而是属于所在的类。也就是对个对象共享同一个数据。
结果：
用类名称来调用静态变量和静态方法，就很好区分static了，因为不管再多实体对象，使用静态变量和静态方法时，都用的是一个类名称在调用。（即使对象名称调用可以被转化为类名称调用，但为什么不在使用的时候用简洁一点的呢）
例子：
public class Student {
//用堆空间地址很好理解static变量，表示其空间内有单独的一个地址，所有实体都连的同一个地址。
//迁移：static类似于纵横所有实体化对象的一个全局变量。
private static int idCounter = 0;
private int id;//学号
private String name;//姓名
private int age;//年龄、
static String room;//所在教室
//学号计数器，每当new了一个新对象的时候，计数器++。
public Student() {//谁先实体化谁就先+1.
this.id = ++idCounter;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCounter;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
public class Demo01StaticField {//Field 内属性
public static void main(String[] args) {
Student one = new Student("郭靖",19);//实体化成功，ID指针+1。
one.room = "101";
System.out.println("姓名：" + one.getName() + ",学号：" + one.getId() + ",年龄：" + one.getAge()+ ",教室：" + one.room);
Student two = new Student("黄蓉",16);
System.out.println("姓名：" + two.getName() + ",学号：" + two.getId() + ",年龄：" + two.getAge()+ ",教室：" + two.room);
}
}
静态方法：一旦使用static修饰成员方法，那么就成为了静态方法。静态方法不属于对象，而是属于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量还是成员方法，如果有了static，都推荐使用类名称进行调用。
静态变量格式：类名称.静态变量
静态方法格式：类名称.静态方法()
注意事项：
- 非静态可以支持直接访问静态，静态却不能支持直接访问非静态。【重点】
原因：内存当中【先】有的静态内容，【后】有的非静态内容。
古人不知道后人，后人却知道古人。 - 静态方法当中不能用this关键字。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
但this与静态方法没关系，因为它根本就不用类名称；静态方法被调用的时候是类名称，而不是实体对象。
例子：
public class MyClass {
int num = 0;//成员变量
static int numStatic = 1;//静态变量
//这是成员方法
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);
//静态方法当中不能用this关键字。
// System.out.println(this);
}
}
public class Demo02StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass();//首先实体化（创建对象）
//然后使用功能（没有static关键字的方法——成员方法）
//对于静态方法，即可以通过对象进行调用，也可以通过类名称进行调用。
//实体化对象使用静态方法没有提示。
obj.methodStatic();//正确，不推荐，因为会让你误以为是成员方法。
//这样的写法在编译过后，也会被翻译成了’类名称.静态方法‘。
//调用静态方法
MyClass.methodStatic();//正确，推荐，为了好区分，用类名调用最好。
//调用成员方法
obj.method();
//对于本类当中的静态方法，可以省略类名称。
myMethod();
Demo02StaticMethod.myMethod();//完全等效。也就是说这才是本来的格式。
}
//【提问】成员方法没法在本类里被访问吗？也对，如果能被访问，为何叫成员方法呢，直接用静态方法就行。
// 成员XX可能就是为了实体对象而存在。这就很好理解静态方法不支持直接访问非静态变量了。
//但成员方法可以访问静态变量。
public static void myMethod(){
System.out.println("这是一个自己的方法~");
}
}
2.3 静态原理图解
2.4 静态代码块
static还有一种用法：静态代码块。
静态代码块格式：
public class 类名称{ //在类中使用
static{
//静态代码块的内容
}
}
特点：当第一次用到本类时，静态代码块执行唯一的一次（只执行一次）。【重点】
静态内容总是优先与非静态：所以静态代码块会比构造方法语句先执行。【题外话：因为的因为是什么？】
静态代码块的典型用途：
用来一次性的对静态成员变量进行赋值。 后面要学的JDDC内容会用到。
静态代码块：定义在成员位置，使用static修饰的代码块{ }。
位置：类中方法外。
执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
例子：
public class Person {
public Person(){ //没有静态语句，连void也没有的就是构造方法，用于实体对象实体化的方法。
System.out.println("构造方法执行！");//实体化调用构造方法时执行。
}
//看来是静态代码块先执行。
static{
System.out.println("静态代码块执行！");
}
}
public class Demo04Static {
public static void main(String[] args) {
Person one = new Person();
Person two = new Person();
// 静态代码块执行！
// 构造方法执行！
// 构造方法执行！
}
}
3. Array类
3.1 概述
java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。
3.2 Arrays类操作数组的方法（功能）
java,util.Arrays是一个与数组有关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作。
public static String toString(数组);将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3…]
//为什么字符变成字符串直接是字符？如：{‘a’, ‘b’, ‘c’} --> abc
public static void sort(数组）;按照默认升序（从小到大）对数组进行排序。
注意事项：
- 如果是数值：sort默认按照升序从小到大。
- 如果是字符串，sort默认按照字母升序。
- 如果是自定义类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学）
例子：
import java.util.Arrays;
public class Demo01Arrays {
public static void main(String[] args) {
int[] intArray = {1, 2, 3};
char[] charArray = {'a', 'b', 'c'};
//将int数组按照默认格式变成字符串
String intStr = Arrays.toString(intArray);
System.out.println(intStr);//[1, 2, 3]
String charStr = Arrays.toString(charArray);
System.out.println(charArray);//abc 【提问】 默认格式？有点意思！
int[] array1 = {91, 20, -5, 6,};
Arrays.sort(array1);//居然直接在原数组中排序，【题外话：字符串是一个常量，不能改变】
System.out.println(Arrays.toString(array1));//[-5, 6, 20, 91]
String[] array2 ={"cc", "bb", "aa"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2));//[aa, bb, cc]
}
}
3.3 练习
题目：请使用 Arrays 相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
import java.util.Arrays;
public class Demo02ArraysPractice {
public static void main(String[] args) {
String str = new String();//可以直接实体化对象并赋值
str = "aflksjgidfjiogkngnvsfhnbg";
//如何进行升序排列：sort
//必须是一个数组，才能用Arrays.sort
//String --> 数组：用toCharArray
char[] chars = str.toCharArray();
Arrays.sort(chars);
System.out.println(Arrays.toString(chars));
//for循环倒叙快捷键：XXX.forr
for (int i = chars.length - 1; i >=0 ; i--) {
// System.out.print(chars[i]);
System.out.print(chars[i]);
}
}
}
4. Math类
4.1 概述
java.lang.Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。
4.2 基本运算方法
java.lang.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
public static double abs(double num);获取绝对值。//有多种重载
public static double ceil(double num);向上区整。12.1 --> 13
public static double floor(double num);向下区整。69.9 --> 69
public static long round(double num);四舍五入。12.1 --> 12 , 12.5 --> 13
Math.PI代表近似的圆周率常量（double）。
例子：
public class Demo03Math {
public static void main(String[] args) {
//1. 获取绝对值 abs()
System.out.println(Math.abs(-3));//3
System.out.println("------------------");
//2. 向上取整 运箱子，21个，每次10个
System.out.println(Math.ceil(3.9));//4.0
System.out.println(Math.ceil(2.001));//3.0
//3. 向下区整 超市：零头 128.36
System.out.println(Math.floor(69));//69.0
System.out.println(Math.floor(69.9));//69.0
//4. 四舍五入
System.out.println(Math.round(34.4));//34
System.out.println(Math.round(34.5));//35
}
}
4.3 Math类的练习
题目：
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少？
思路：
- 既然已经确定了范围，for循环
- 起点位置-10.8应该转换成为-10，两种办法：
- 用Math.ceil()方法，向上取整。
- 强转成为int，自动舍弃所有小数位。
- 如何拿到绝对值：Math.abs();
- 一旦发现一个数组。需要让计数器++进行统计
public class Demo04MathPractice {
public static void main(String[] args) {
// System.out.println(Math.floor(-10.8));//负数向下取整不行
int num = 0;
//可以直接用强转 【double值也是可以进行< > 或++等等的】
for(double i = Math.ceil(-10.8); i <= Math.floor(5.9); i++){
if(Math.abs(i) > 6 || Math.abs(i) < 2.1){
int a = (int)i;
System.out.print(a + ",");
num++;
}
}
System.out.println("\n" + "符合要求的整数共有" + num + "个");
}
}
——此文档为学习笔记！
扫一扫
699
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
