第一章 String类
1.1 字符串的概述和特点
- java.lang.String类代表字符串
- API当中说:Java程序中的所有字符串字面值(如"abc")都作为此类的实例实现。
- ++其实就是说:程序当中所有的双引号字符串,都是String类的对象。++(++就是没有new,也照样是++)
- String的特点:
- 字符串的内容永不可变【重点】(—常量)
- 正是因为字符串不可改变,所以字符串是可以共享使用的
- 字符串效果上相当于char[]字符数组,但是底层原理是byte[]字节数组
- 注:byte是数据的最小存储单位
1.2 字符串的构造方法和直接创建
- 创建字符串的常见3+1种方法
- 三种构造方法:
- public String():创建一个空白字符串,不含有任何内容
- public String(char[] array):根据字符数组的内容,来创建对应的字符串
- public String(byte[] array):根据字节数组的内容,来创建对应的字符串
- 一种直接创建:
- String str = “hello”; //右边直接用双引号
- 三种构造方法:
- 注:直接写上双引号,就是字符串对象(JVM帮new了)
//使用空参构造 String str1 = new String(); //小括号留空,说明字符串什么内容都没有 System.out.println("第一个字符串:" + str1); //根据字符数组创建字符串 char[] charArray = {'A', 'B', 'C'}; String str2 = new String(charArray); System.out.println("第二个字符串:" + str2); //根据字节数组创建字符串 byte[] byteArray = {97, 98, 99}; //a, b, c String str3 = new String(byteArray); System.out.println("第三个字符串:" + str3); //直接创建 String str4 = "hello"; System.out.println("第四个字符串:" + str4);
1.3 字符串的常量池
- 字符串常量池:程序当中++直接写上的双引号字符串++,++就在字符串常量池中++(从1.7开始在堆当中)
- 注:对于基本数据类型来说:==是进行数值的比较
- 注:对于引用数据类型来说:==是进行地址值的比较
- 注:整数相除不做四舍五入,直接向下取整。
- ++12345 / 10 = 1234++不是1235
- ++12345 / 10 = 1234++不是1235
1.4 字符串的比较相关方法
- ==是进行对象的++地址值++比较,如果确实需要字符串的内容比较,可以使用两个方法:
- public boolean equals(Object obj):参数可以是任意对象,只有参数是一个字符串并且内容相同的才给true,否则false
- 任何对象都能用Object接收
- equals方法具有对称性:也就是a.equals(b)和b.equals(a)效果一样
- 如果比较双方一个常量一个变量,推荐把常量字符串写在前面(++“abc”.equals(b)++,如果常量放后面,前面是个null就会空指针异常)
- public boolean equalsIgnoreCase(String str):++忽略大小写,进行内容比较++(只区分英文字母大小写)
String str1 = "yes"; String str2 = "yes"; char[] charArray = {'y', 'e', 's'}; String str3 = new String(charArray); System.out.println(str1.equals(str2)); System.out.println(str1.equals(str3)); System.out.println(str3.equals("yes")); System.out.println("yes".equals(str3)); String str4 = "Yes"; System.out.println(str4.equals(str1)); System.out.println("==============="); String str5 = null; System.out.println("abc".equals(str5)); //false //System.out.println(str5.equals("abc")); //空指针异常 System.out.println("==============="); String str6 = "Java"; String str7 = "java"; System.out.println(str6.equals(str7)); System.out.println(str6.equalsIgnoreCase(str7));
- public boolean equals(Object obj):参数可以是任意对象,只有参数是一个字符串并且内容相同的才给true,否则false
1.5 字符串的获取相关方法
- String中与获取相关的方法
- public int length():获取字符串当中含有的字符个数,拿到字符串长度
- 注:数组length没有括号,字符串length()有
- public String concat(String str):将当前字符串和参数字符串拼接成为返回值新的字符串(用+也行)
- public char charAt(int index):++获取指定++索引位置的++单个字符++(索引从0开始)
- public int indexOf(String str):查找参数字符串在本字符串当中++首次出现的索引的位置++,如果++没有返回-1++
//获取字符串长度 int len = "jflasjfjaskfjiasighasnhoias".length(); System.out.println("字符串的长度是:" + len); //拼接字符串 String str1 = "Hello"; String str2 = "World"; String str3 = str1.concat(str2); System.out.println(str1); System.out.println(str2); System.out.println(str3); //获取指定索引位置的单个字符 char ch = "Hello".charAt(1); System.out.println("第1个索引位置的字符是:" + ch); //查找参数字符串在本来字符串当中出现的第一次索引位置 String original = "HelloWorld"; int index = original.indexOf("llo"); System.out.println("第一次索引值是:" + index); int index1 = original.indexOf("lle"); System.out.println("第二次索引值是:" + index1);
- public int length():获取字符串当中含有的字符个数,拿到字符串长度
1.6 字符串的截取相关方法
- 字符串的截取方法
- public String substring(int index):截取从参数位置一直到字符串末尾,返回新字符串。
- public String substring(int begin, int end):截取从begin开始,一直到end结束,中间的字符串
- 注:[begin, end):包含左边,不包含右边.
- 注:++substring中的s小写++
String str1 = "HelloWorld"; String str2 = str1.substring(5); System.out.println(str1); System.out.println(str2); System.out.println("=========="); String str3 = str1.substring(4, 7); System.out.println(str3);
- 注:
- 下面这种写法,字符串内容仍然没有改变
- 有两个字符串:“Hello”,“Java”
- strA当中保存的是地址值
- 本来地址是Hello的0X666
- 变成后来的Java的0X999
String strA = "Hello"; System.out.println(strA); strA = "Java"; System.out.println(strA);
1.7 字符串的转换相关方法
-
String当中与转换相关的方法
- public char[] toCharArray():将当前字符串拆分成为字符数组作为返回值。
- public byte[] getBytes():获取当前字符串底层的字节数组(“abc”–>97 98 99)
- public String replace(CharSequence oldString, CharSequence newString):将所有出现的老字符串替换成为新的字符串,返回替换之后的结果新字符串
- CharSequence意思就是说可以接收字符串类型
//转换成字符数组 char[] chars = "Hello".toCharArray(); System.out.println(chars[0]); System.out.println(chars.length); //转换成字节数组 byte[] bytes = "abc".getBytes(); //遍历 /*for (int i = 0; i < bytes.length; i++) { System.out.println(bytes[i]); }*/ for(byte by : bytes){ System.out.print(by + " "); } System.out.println("=========="); String str1 = "How do you do?"; String str2 = str1.replace("o", "*"); System.out.println(str1); System.out.println(str2); System.out.println("=========="); String lang1 = "会不会玩?你大爷的!,你大爷的!,你大爷的!!!"; String lang2 = lang1.replace("你大爷的!", "****"); System.out.println(lang1); System.out.println(lang2);
1.8 字符串的分割相关方法
- 分割字符串的方法
- public String[] split(String regex):按照参数的规则,将字符串切分成若干部分
- ++注:切割出来就算是d一个也是字符串++
- 注:“.“切不了要写成”\\.”(两个反斜杠),数组长度0,循环为空
- 注:++split方法的参数其实是一个‘正则表达式’,++
String str1 = "aaa,bbb,ccc"; String[] array1 = str1.split(","); /*for (int i = 0; i < array1.length; i++) { System.out.println(array1[i]); }*/ for(String ary : array1){ System.out.println(ary); } System.out.println("======="); String str2 = "aaa.bbb.ccc"; String[] array2 = str2.split("."); int len = array2.length; //数组长度不加(),且等于0 System.out.println(len); for(String ary : array2){ //空 System.out.println(ary); } //"."前加\\ String str3 = "aaa.bbb.ccc"; String[] array3 = str3.split("\\."); for(String ary : array3){ //空 System.out.println(ary); }
- public String[] split(String regex):按照参数的规则,将字符串切分成若干部分
1.9 练习一:按指定格式拼接字符串
- 要求:定义一个方法,把数组{1, 2, 3}按照指定格式拼接成一个字符串。格式如下:[word1#word2#word3]
- 思路:
- 定义一个int数组:内容1,2,3
- 定义一个方法,用来将数组变成字符串
- 三要素:
- 返回值类型:String
- 方法名称:fromArrayToString
- 参数列表:int[]
- 格式:[word1#word2#word3]会用到:
- for循环
- String拼接
- 每个数组元素之前都有一个word字样
- 分隔使用的是#
- 区分一下是不是最后一个
- 调用方法,得到返回值,并打印结果字符串
public static void main(String[] args) { int[] array = {1, 2, 3}; String result = formArrayToString(array); System.out.println(result); } public static String formArrayToString(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; }
1.10 练习二:统计输入的字符串中各个字符的个数
- 要求:键盘输入一个字符串,并且统计其中各个字符出现的次数
- 种类:大写字母,小写字母,数字,其他
- 思路:
- 既然用到键盘输入:Scanner
- 键盘输入的是字符串:String str = sc.next();
- 定义四个变量,分别代表四种字符各自出现的次数
- 需要对字符串一个字,一个字检查,String–>char[],方法就是++toCharArray()++
- 变量char[]字符数组,对当前字符的种类进行判断,并且用四个变量进行++动作。
- 打印输出四个变量,分别代表四种字符出现次数
public static void main(String[] args) { Scanner sc = new Scanner(System.in); int num = 0; int letterS = 0; int letterB = 0; int other = 0; System.out.print("请输入一串字符串:"); String str = sc.next(); char[] charA = str.toCharArray(); //将字符串转成数组 for (int i = 0; i < charA.length; i++) { if(charA[i] >= '0' && charA[i] <= '9'){ num++; }else if(charA[i] >= 'a' && charA[i] <= 'z'){ letterS++; }else if(charA[i] >= 'A' && charA[i] <= 'Z'){ letterB++; }else{ other++; } } System.out.println("数字:" + num + "小写字母:" + letterS + "大写字母:" + letterB + "其他:" + other); }
第二章 静态static关键字
2.1 静态static关键字概述
- 一旦用了static关键字,那么这样的内容不再属于对象自己,而是属于类的,所以凡是本类的对象,都共享同一份
- 注:只在类当中保存唯一一份,那所有本类对象共享同一份
- 注:对于姓名,年龄,学号来说,每个对象都有自己独立的数据,但是对于教师来说,这应该是多个对象共享同一个数据才对。
2.2 静态static关键字修饰成员变量
- 如果一个成员变量使用了static关键字,那么这个变量不再属于对象自己,而是属于所在的类。多个对象共享同一份数据。
- 注:动态学号计数(例子):创建一个new对象就加一
- 注:++推荐用类名来调用成员变量或者成员方法++——>会误以为这是成员变量或成员方法
- one.room = “101教室”; 可以,不推荐
- Student.room = “101教室”; 可以,推荐
生成一个Student类:Student.java
public class Student {
private int id; //学号
private String name;
private int age;
static String room;
private static int idCounter = 0; //学号计数器,每当new了一个新对象的时候,计数器++
//无参
public Student(){
this.id = ++idCounter;
}
//全参
public Student(String name, int age){
this.name = name;
this.age = age;
this.id = ++idCounter;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
}
//创建一个对象:Demo01StaticField.java
public static void main(String[] args) {
Student one = new Student("郭靖", 19);
one.room = "101教室";
System.out.println("姓名:" + one.getName()
+ "年龄:" + one.getAge() + "教室:" + one.room
+ "学号:" + one.getId());
Student two = new Student("黄蓉", 16);
System.out.println("姓名:" + two.getName()
+ "年龄:" + two.getAge() + "教室:" + one.room
+ "学号:" + two.getId());
}
2.3 静态static关键字修饰成员方法
- 一旦使用static修饰成员方法,那么这就成为了静态方法。++静态方法不属于对象,而是属于类的。++
- 如果没有static关键字,那么必须首先创建对象,然后通过对象才能使用它。
- 对于++成员方法++来说,++首先创建对象++,++然后才能使用没有static关键字的内容++
- 对于++静态方法++来说,++可以通过对象名进行调用,也可以直接通过类名称调用++
- obj.methodStatic(); 正确,不推荐(obj对象名)
- MyClass.methodStatic(); 正确,推荐(MyClass类名)
- 对象名.静态方法的写法,在编译之后也会被javac翻译成:类名称.静态方法
- 如果有了static关键字,那么不需要创建对象,直接就能通过类名称来使用它。
- 与2.2的总结:
- 无论是成员变量,还是成员方法。如果有了static,都推荐使用类名称进行调用
- 静态变量:类名称.静态变量;
- 静态方法:类名称.静态方法();
- 无论是成员变量,还是成员方法。如果有了static,都推荐使用类名称进行调用
- 注:对于本类当中的静态方法,可以省略类名称
- myMethod();
- Demo02StaticMethod.myMethod(); //完全等效
- 注:静态不能直接访问非静态
- 因为在内存当中是++先++有的静态内容,++后++有的非静态内容
- “++先人不知道后人,后人知道先人++”
- 注:静态方法当中不能用this关键字
- this代表当前对象,通过谁调用的方法,谁就是当前对象(但是静态和对象无关)
生成一个类:MyClass.java
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(numStatic);
//静态方法当中不能使用this关键字
//System.out.println(this);
}
}
创建一个对象:Demo02StaticMethod
public class Demo02StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass(); //首先创建对象
//然后才能使用没有static关键字的内容
obj.method();
//对于静态方法来说,可以通过对象名进行调用,也可以直接通过类名称调用
obj.methodStatic(); //可以,不推荐
MyClass.methodStatic(); //可以,推荐
myMethod();
}
public static void myMethod(){
System.out.println("自己的方法!");
}
}
2.4 静态static的内存图
- 注:根据类名称访问静态成员变量的时候,全程和对象就没有关系,只和类有关系
- 注:就算你写的对象名.静态变量–>编译时候也会被javac翻译成:类名称.静态方法
2.5 静态代码块
- 注:直接用大括号括起来的都叫代码块
- 静态代码块的格式(在类中):
public class 类名称 { //静态代码块的内容 }
- 特点:当第一次用到本类时,静态代码块执行唯一的一次
- 构造方法在每次使用到本类时,都会执行一次
- 静态代码块的典型用途:
- 用来一次性的对静态成员变量进行赋值
- JDBC相关环境下
//生成一个类:Person.java
public class Person {
static {
System.out.println("静态代码块执行!");
}
public Person(){
System.out.println("构造方法执行!");
}
}
//创建一个对象:Demo04Static.java
public static void main(String[] args) {
Person one = new Person();
Person two = new Person();
}
- 结果:
- 静态代码块执行!
- 构造方法执行!
- 构造方法执行!
- 注:++静态内容总是优先于非静态++,所以静态代码块比构造方法先执行
第三章 Arrays类
3.1 ++数组++工具类Arrays
- java.util.Arrays是一个与数组相关的工具类,里面提供了大量的静态方法,用来实现数组常见的操作
- ++因为静态方法不用new,直接通过类名称就能点(‘.’),所以很方便,快捷++
- 常用的两个方法:
- public static String toString(++数组++):将参数数组变成字符串
- 按照默认格式:[元素1, 元素2, 元素3…]++++
- public static void sort(数组):按照默认升序(从小到大)对数组的元素进行排序
- ++因为是void所以直接把原来数组排序++
- 如果是++数值++,sort默认按照升序,从小到大
- 如果是++字符串++,sort默认按照字母升序,从小到大
- 如果是自定义的类型,那么这个自定义的类需要有Comparable或者Comparator接口的支持(今后学习++)++
- 必须是一个数组才可以使用Arrays.sort方法
- public static String toString(++数组++):将参数数组变成字符串
public static void main(String[] args) {
int[] intArray = {1, 2, 4, 5};
//将int数组按照默认格式变成字符串
String intStr = Arrays.toString(intArray);
System.out.println(intStr); //[1, 2, 4, 5]
System.out.println("===========");
int[] array1 = {1, 2, 10, 3, 5};
Arrays.sort(array1);
System.out.println(Arrays.toString(array1));
/*System.out.print("[");
for(int i = 0; i < array1.length; i++){
if(i == array1.length - 1){
System.out.print(array1[i] + "]");
}else{
System.out.print(array1[i] + " ");
}
}*/
/*for(int ary : array1){
System.out.print(ary + " ");
}*/
String[] array2 = {"123", "ccc", "bbb"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2));
}
3.2 Arrays类练习:字符串倒序排列
- 要求:请使用Arrays相关的API(也就是相关的方法),将一个随机字符串中的所有字符升序排列,并倒序打印
- 注:倒序遍历的快捷键——>array.forr(array是数组名)
public static void main(String[] args) {
String str = "jdfjfjieafnalgjifejnsaa";
//如何进行升序排列:sort
//必须是一个数组,才能用Arrays.sort方法
//String -->数组,用toCharArray()
char[] array = str.toCharArray();
Arrays.sort(array); //对字符数组进行升序排列
//==需要倒序遍历==
for (int i = array.length - 1; i >= 0; i--) {
System.out.print(array[i] + " ");
}
}
第四章 Math类
4.1 ++数学++工具类Math
- java.util.Math类是数学相关的工具类,里面提供了大量的静态方法,完成与数学运算相关的操作。
- 常用的方法:
- public static double abs(double num):获取绝对值(有多种重载)
- public static double ceil(double num):向上取整
- 12.1–>13.0
- public static double floor(double num):向下取整
- 12.9–>12.0
- public static long round(double num):四舍五入
- 12.4–>12
- 12.5–>12
- public static double sqrt(double num):正平方根
- 4 -->2.0
- public static double pow(double num1, double num2):返回第一个参数的第二个参数次幂的值。
- (2, 2)–>4.0
- Math.PI(念“π”):代表近似的圆周率常量。(就是一个double值)
- 注:两个整数相除不做四舍五入:12345 / 10 = 1234
- 注:保留两位小数:String.format(“%.2f”, 变量名);
- double num = 12.325;
- System.out.println(String.format(“%.2f”, num)); //12.33
- 注:转换为字符串形式:String.valueof();
public static void main(String[] args) {
//绝对值abs
System.out.println(Math.abs(3.12));
System.out.println(Math.abs(0));
System.out.println(Math.abs(-3.12)); //3.12
System.out.println("========");
//向上取整ceil
System.out.println(Math.ceil(12.1)); //13.0
System.out.println("========");
//向下取整floor
System.out.println(Math.floor(12.9)); //12.0
System.out.println(Math.floor(21)); //21.0
System.out.println("========");
//四舍五入round
System.out.println(Math.round(12.4)); //12
System.out.println(Math.round(12.5)); //13
System.out.println("========");
//平方pow
System.out.println(Math.pow(2, 2)); //4.0
System.out.println("========");
//平方根sqrt
System.out.println(Math.sqrt(4)); //2.0
System.out.println("========");
//算圆的面积(半径:2)
double radius = 2.325;
//System.out.println(String.format("%.2f", radius));
System.out.println("圆的面积是:" + String.format("%.2f", (Math.PI * Math.pow(radius, 2))));
}
4.2 Math练习一:小学数学
- 要求:计算在-10.8到5.9之间,绝对值大于6或者小于2.1的整数有多少个?
- 分析:
- 确定了范围:for循环
- 起点位置-10.8换成-10的两种方法:
- 可以使用Math.ceil方法,向上(向正方法)取整
- 强转成int,就会自动舍弃所有小数位
- 每一个数字都是整数,所以步进表达式应该是num++,这样每次都是+1的
- 如何拿到绝对值:Math.abs方法
- 一旦发现了一个数字,需要让计数器++进行统计
- 注:如果使用Math.ceil方法,-10.8可以变成10.0。++double也是可以进行++的++
public static void main(String[] args) {
int count = 0; //符合要求的数量
double min = -10.9;
double max = 5.9;
ArrayList<Integer> listA = new ArrayList<>();
//这样处理,变量i就是区间之内所有的整数
for(int i = (int)min; i < max; i++){
int abs = Math.abs(i); //绝对值
if(abs > 6 || abs < 2.1){
count++;
listA.add(abs);
}
}
System.out.println("符合要求的总共有:" + count); //符合要求的总共有:9
System.out.println("分别是:");
System.out.println(listA); //[10, 9, 8, 7, 2, 1, 0, 1, 2]
}