目录
一、Api学习
1.Object
Object 类 是Java所有类的父类
1.1toString
toString与类
自定义类，输入 toString + enter , 生成形如一下代码
public class Student { //默认继承Object
private String name;
private int age;
private String sex;
public Student() {
}
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
sout类对象时，可以直接输出成员变量。当然，可以再自定义重写toString;
toString与数组
Integer[] a = new Integer[]{1,2,3,4,5,6};
System.out.println(a); //[Ljava.lang.Integer;@4eec7777
System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 5, 6]
通过Arrays.toString（）方法输出数组元素
toString与集合
List<Student> list = new ArrayList<>();
Student s1 = new Student("张三",28,"男");
Student s2 = new Student("张三",28,"男");
list.add(s1);
list.add(s2);
System.out.println(list);
//[Student{name='张三', age=28, sex='男'}, Student{name='张三', age=28, sex='男'}]
1.2equals
右键 generate ，点击equals()，自动生成官方
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;//.getClass 获取类的类型
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name) && Objects.equals(sex, student.sex);
}
注意：对象内容比较时，存在object为null的情况， null.equals(…)调用方法出错
解决：
使用Objects(工具类) 的 equals(Object a , Object b)
Student s1 = new Student("张三",28,"男");
Student s2 = new Student("张三",28,"男");
System.out.println(Objects.equals(s1, s2)); //true
2.StringBuilder
-
StringBuilder是一个可变的字符串类，可以看作为一个容器；
-
作用：提高字符串的操作效率，如：拼接，修改等；
-
原因：String内容不可变，拼接性能差；所以，定义字符串使用String , 拼接修改等使用StringBuilder
-
拼接对象后的类型还是StringBuilder类型，支持链式编程，需要toString转换成String类型
-
StringBuilder s1 = new StringBuilder(); s1.append("我爱你中国，").append("祝您繁荣永昌");
-
-
构造器：
-
名称 说明 public StringBuilder() 创建一个空白的可变的字符串对象，不包含任何content public StringBuilder(String str) 创建一个指定字符串的可变字符串的对象
-
StringBuilder (手段)和 String（目的）， 不存在继承关系
(1)相同点：
StringBuilder和String都是用来接收和处理字符串类型的数据
(2)不同点：
String拼接字符串的时候，（String内容不可变）是先将每个字符串在内存中创建出来，然后再将字符串拼接成一个新的字符串返回，这样做对于几个字符串来说不会有什么效率和感知上的差别.
StringBuilder它是一种动态对象，它所代表的字符串是可变的，它的字符串拼接原理是在该对象的地址后面加上要拼接的对象，不用反复的去开辟创建新的地址，节省了内存资源也提高了拼接性能，当有大量的拼接需求或者不可知的拼接次数时，推荐使用StringBuilder来进行字符串的拼接。
原理对比
常用方法
| api | 描述 |
|---|---|
| append(“…”) | 追加字符串 |
| replace(start,end,“…”) | 替换下标为start ~ end-1的位置内容为 “…” |
| delete(start,end) | 删除下表为start~end-1位置的内容 |
| insert(index,“…”) | 在指定index处插入"…" |
| reverse | 逆序反转 |
public static void main(String[] args) {
//1.StringBuilder只能无参与有参构造
//StringBuilder s1 = "哈哈哈"; 常见错误：""字符串类型，不能传递地址给StringBuilder
StringBuilder s = new StringBuilder();
s.append(1);
s.append('c');
s.append(1.0);
s.append(false);
s.append("hh");
System.out.println(s);
//2.StringBuilder支持链式编程
StringBuilder s1 = new StringBuilder();
s1.append("我爱你中国").append("hhh");
//反转.reverse()
System.out.println(s1.reverse());
//3.注意：StringBuilder只是拼接字符串的手段，效率好。
//最终，还是要返回为字符串类型，toString()，返回
StringBuilder s2 = new StringBuilder();
s2.append("我爱你中国").append("hhh");
//回复成String类型
String s3 = s2.toString();
//4.delete
StringBuilder sb = new StringBuilder();
sb.append("巴山楚水凄凉地，responsebility").delete(10, 12) // 按照下标内容删除
.deleteCharAt(0); // 删除指定位置内容
System.out.println(sb);
}
3.Math工具类
public static void main(String[] args) {
//1.取绝对值 abs
System.out.println(Math.abs(-1.2)); //1.2
//2.向上取整 ceil
System.out.println(Math.ceil(4.00001)); //5.0
//3.向下取整 floor
System.out.println(Math.floor(4.999999));//4.0
//4.四舍五入 round
System.out.println(Math.round(4.4999)); //4
System.out.println(Math.round(4.50)); //5
//5.获取两个int值较大值 max
System.out.println(Math.max(8, 9)); //9
//6.返回a的b次幂的值 pow
System.out.println(Math.pow(2, 10)); //1024.0
//7.返回值为double的随机值[0.0,1.0) 包前不包后 random
System.out.println(Math.random()); //[0.0 , 1.0)
}
4.System工具类
| api名称 | 描述 |
|---|---|
| public static void exit(int status) | 终止当前运行的JVM，非0表示异常终止 |
| public static long currentTimeMills() | 返回当前系统的事件毫秒值 |
| public static void arrayCopy(原数组，原数组开始序号，复制数组，复制数组开始序号，复制长度) | 数组自定义拷贝 |
| System.in.println | 标准输入流，用于从控制台读取用户输入 |
| System.out.println | 标准输出流，用于从控制台打印输出信息 |
| System.err.println | 标准错误流，用于控制台打印错误信息 |
5.BigDecimal
public static void main(String[] args) {
//浮点型运算 +-*/可能出现失真（精度问题）
System.out.println(0.09 + 0.01);
System.out.println(1.0 - 0.332);
System.out.println(1.015 * 100);
System.out.println(1.201 / 1000);
System.out.println("------------");
double a = 0.1;
double b = 0.2;
System.out.println(a + b);
System.out.println("------------");
//1.包装浮点型数据 成为 大数据对象
//注意：不可以直接使用构造器，还存在失真问题 (利用String)
BigDecimal a1 = BigDecimal.valueOf(a);
//return new BigDecimal(Double.toString(val));
BigDecimal b1 = BigDecimal.valueOf(b);
BigDecimal c = a1.add(b1);
BigDecimal c1 = a1.subtract(b1);
BigDecimal c2 = a1.multiply(b1);
BigDecimal c3 = a1.divide(b1);
System.out.println(c);
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
//转变为double 类型
double c4 = c.doubleValue();
System.out.println(c4);
//2.BigDecimal一定是精度运算！！！
BigDecimal bigDecimal1 = BigDecimal.valueOf(10.0);
BigDecimal bigDecimal2 = BigDecimal.valueOf(3.0);
// BigDecimal bigDecimal = bigDecimal1.divide(bigDecimal2); //no exact representable decimal result(不精确)
//特殊！！！
BigDecimal bigDecimal = bigDecimal1.divide(bigDecimal2,2,RoundingMode.HALF_UP); //保留两位小数，四舍五入
System.out.println(bigDecimal);
}
6.Arrays工具类
数组操作工具类，专门用于操作数组元素的；
常用Api
| 方法名 | 说明 |
|---|---|
| public static String toString(类型[] a) | 数组元素输出 |
| public static void sort(类型[] a) | 对数组元素进行默认升序排序 |
| public static void sort(类型[] a，Comparator<?super T> c) | 使用比较器对象自定义排序 |
| public static int binarySearch(int[] a , int key) | 二分搜索数组中的数据(升序)，存在返回索引，不存在返回-1 |
public static void main(String[] args) {
//1.输出 Arrays.toString([])
int[] arr = {1,2,5,4,3};
System.out.println(Arrays.toString(arr));
//2.排序 Arrays.sort([])
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//3.二分查找 Arrays.binarySearch() 返回索引 失败 返回-(插入位置+1)
int index = Arrays.binarySearch(arr,50);
System.out.println(index);
System.out.println(Arrays.binarySearch(arr, 3));
// int[] arr1 = {23,1,4,5};
// System.out.println(Arrays.binarySearch(arr1, 2)); 数组要升序 ！！！
int[] arr1 = {5,4,3,2,1};
System.out.println(Arrays.binarySearch(arr1, 1)); //-1
}
6.1Comparator
- 设置Comparator接口对应的比较器对象，来定制比较规则：
- 如果认为 左边数据大于右边数据，返回正整数；
- 如果认为 左边数据小于右边数据，返回负整数；
- 如果认为左边数据 == 右边数据， 返回0；
Double[] arr1 = {1.1,2.3,10.0,25.0,1.3,10.0};
Arrays.sort(arr1, new Comparator<Double>() {
@Override
public int compare(Double o1, Double o2) {
//使用Double.compare(double d1,double d2) 优雅!!!
return Double.compare(o1,o2); //规则与↑一致 , 升序
}
});
System.out.println(Arrays.toString(arr1));//[1.1, 1.3, 2.3, 10.0, 10.0, 25.0]
类对象数组的成员变量怎么样进行排序？
解决：使用Comparable ， 实体类实现接口Comparable < T >的 compareTo方法，然后Arrays.sort数组
6.2Comparable< T >
//省略了 getXxx / setXxx方法 , 需要补上
public class Student implements Comparable<Student> {
private String name;
private int age;
private double height;
public Student() {
}
public Student(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = height;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
@Override
public int compareTo(Student o) {
return Double.compare(o.getHeight(),this.getHeight()); //降序!!!
}
}
Student[] students = new Student[3];
students[0] = new Student("王阳明",20,170.5);
students[1] = new Student("小明",25,191.5);
students[2] = new Student("皓轩",16,190.5);
Arrays.sort(students);
System.out.println(Arrays.toString(students)); //按照身高降序，对对象排序
二、基本认识
1.包装类
- 基本数据类型，对应的引用类型；
- 实现了万物皆对象；
- 集合和泛型等不支持基本类型，只能使用引用类型；
- 变量默认为null；
特殊功能：
-
把基本类型的数据转为字符串数据；
-
把字符串数据的数值转换为真实的数据类型（优雅！！！）
-
自动装箱：基本数据类型的数据值和变量 给 包装类型的变量
-
自动拆箱：包装类型的变量可以直接 赋值 给基本类型的变量
-
基本数据类型转换为字符串类型 ： Integer.toString(基本类型的数据)
-
字符串类型的数值转换为 真实值的数据类型
- Intger.parseInt(“字符串类型的整数”)
- Double.parseDouble(“字符串类型的小数”) ; Double d4 = Double.valueOf(s2); //优雅！！！
2.正则表达式
正则表达式（regex）是一个字符串，由字面值字符和特殊符号组成，是用来描述匹配一个字符串集合的模式，可以用来匹配、替换和拆分字符串
模式： String regex = “[…]\…{…}”；
2.1matches匹配
注意：使用\时，需要添加转义字符
//验证码四位
System.out.println("23Mf_".matches("[a-zA-Z0-9]{4}")); //false
System.out.println("23Mf".matches("[a-zA-Z0-9]{4}")); //true
System.out.println("23fa".matches("[\\w&&[^_]]{4}")); //true
System.out.println("232_".matches("[\\w&&[^_]]{4}")); //false
2.2替换和匹配
分隔split(regex) , 替换replaceAll(regex，newStr)
public static void main(String[] args) {
String names = "刘晓璐fahhhdkga王宝强fakgafal王蓉";
//1.split()
String[] splitNames = names.split("\\w+");
for (int i = 0; i < splitNames.length; i++) {
System.out.println(splitNames[i]);
}
//2 String .replaceAll()
System.out.println(names.replaceAll("\\w+", " "));
}
//邮箱匹配 "\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2}"
public static void checkEmail(){
Scanner scanner = new Scanner(System.in);
while (true){
System.out.println("请输入您的邮箱:");
String s = scanner.next();
//邮箱，3390511354@qq.com 15fa5@163.com
if(s.matches("\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2}")){
System.out.println("输入成功");
break;
}else {
System.out.println("输入有误");
}
}
}
3.Lambda表达式
-
Lambda是JDK8开始后的一种新语法形式
-
作用：只能 简化 函数式接口 的 匿名内部类
-
Lambda表达式的简化格式：
（匿名表达式被重写方法的形参列表）-> { 被重写方法的方法体 } 注： -> 是语法形式，无实际含义； -
什么是函数式接口？
- 首先必须是接口， 其次接口中有且仅有一个抽象方法的形式；
- 在接口上 加上 @FunctionalInterface注解，标记该接口的是函数式接口；
-
-
对Lambda表达式的进一步省略：
-
参数类型可以不写；
-
如果只有一个参数，参数类型可以省略，同时（）也可以省略；
-
如果Lambda表达式的方法体 只有一行代码。可以省略大括号不写，同时要省略分号；
-
如果只有一行代码，可以省略大括号不写。此时，如果这行代码有 return 语句，必须省略return 不写，同时省略";"不写;
-
Arrays.sort(arr1, new Comparator<Double>() {
@Override
public int compare(Double o1, Double o2) {
//使用Double.compare(double d1,double d2) 优雅!!!
return Double.compare(o1,o2); //规则与↑一致 , 升序
}
});
//Lambda形式
Arrays.sort(arr1, ( o1, o2) -> {
return Double.compare(o1,o2);
});
//进一步对Lambda简化
Arrays.sort(arr1, (o1, o2) -> Double.compare(o1,o2));
//最终
Arrays.sort(arr1, Double::compare);
4.泛型
- 使Object对象替代一切引用数据类型，泛型使得数据类型的类别可以向参数一样由外部传递进来；
- 提供了一种类型安全检查机制，只有数据类型相匹配的变量才能正常的赋值；
- 泛型提高了代码的可读性：在定义 类、接口、方法或者实例化对象阶段，<参数类型>在代码中显式地显现
4.1泛型类
-
定义类同时定义了泛型，就是泛型类
-
泛型格式：
-
class 类名称 <泛型标识> { private 泛型标识 key; ..... public 类名称（泛型标识 t）{ this.key = t; } public 泛型标识 getKey(){ //泛型方法 return this.key; } }
-
-
此处泛型标识 是 任意标识的，常见如: T, E, K , V等
-
作用： 在编译阶段可以指定类型
-
原理：把出现泛型标识的地方全部其替换成 传输的真实数据类型
4.2泛型接口
使用泛型定义的接口
格式：
public interface QuickSort< T >{}
4.3通配符
泛型通配符三种形式：
- <?>被称作无限定的通配符 , 既没有上界也没有下界
- <? extends T>被称作有上界 T的通配符
- <? super T>被称作有下界 T的通配符
403
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
