零.昨日复习
1. static 修饰静态成员变量有什么特征
1. 通过类名直接调用，是一个【类变量】
2. 静态成员成员变量对于整个类而言，有且只有一个
3. 静态成员变量在类文件加载阶段准备就行，已具备数据的提供和存储能力
4. 静态成员变量常用于常量定义，共享资源定义。
2. List 集合和 Set 集合有什么特征
List
有序 添加顺序和存储循序一致
可重复
Set
无序 添加顺序和存储顺序不一致
不可重复
3. ArrayList 底层数组扩容方法流程概述
1. 要求提供的参数是当前扩容所需的最小容量需求 minCapacity
2. 获取原数组容量 oldCapacity
3. 计算新数组容量，大约是原数组容量的 1.5 倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
4. 判断新数组容量是否满足最小容量要求
5. 判断行数组容量是否超出最大容量限制
6. 创建新数组
7. 从原数组中复制数据到新数组中
8. 保存新数组地址。
/**
* 私有化底层扩容方法，在添加数据的操作过程中，控制底层数组容量
*
* @param minCapacity 最小容量要求
*ArrayList底层数组扩容方法流程概述：
*/
private void grow(int minCapacity) {
// 1. 获取当前底层数组容量
int oldCapacity = elementsData.length;
// 2. 计算得到新数组容量 大约 1.5 倍
int newCapacity = oldCapacity + oldCapacity / 2;
// 3. 判断新数组容量是否满足当前添加数据要求 ==> 原数组容量 + 当前添加的元素个数
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
// 4. 判断新数组容量是否超出 MAX_ARRAY_SIZE 【错误提示】
if (newCapacity > MAX_ARRAY_SIZE) {
throw new OutOfMemoryError();
}
// 5. 创建新数组
Object[] newArray = new Object[newCapacity];
// 6. 从原数组中移动数据到新数组，使用 size 更合适，是有效元素个数，避免无效拷贝
for (int i = 0; i < size; i++) {
newArray[i] = elementsData[i];
}
// 7. 新数组地址保存到底层数组引用数据类型变量中。
elementsData = newArray;
}
4. ArrayList 常用方法默写
增
add(E e);
add(int index, E e);
addAll(Collection<? extends E> c);
addAll(int index, Collection<? extends E> c);
删
E remove(int index);
remove(Object obj);
removeAll(Collection<?> c);
retainAll(Collection<?> c);
clear();
removeIf(Predicate<? super E> filter);
@FunctionalInterface
public Predicate<T> {
boolean test(T t);
}
改
E set(int index, E e);
查
int size();
boolean isEmpty();
boolean contains(Object obj);
boolean containsAll(Collection<?> c);
int indexOf(Object obj)
int lastIndexOf(Object obj)
E get(int index);
List<E> subList(int fromIndex, int toIndex);
Object[] toArray();
5. ArrayList 性能简要分析
增
1. 数据添加有可能导致扩容，扩容效率低。
2. 在数组中添加元素，会导致数据整体向后移动，效率低
删
1. 在数组中删除元素，会导致数据整体向前移动，效率低
2. 删除操作会导致有效元素个数和当前底层数组容量占比降低，浪费内存空间。
trimToSize()
改/查
E set(int index, E e);
数组下标操作效率极高，修改，查询效率极高。
搞定ArrayList源码中所有方法
一.LinkedList概述
1.1 LinkedList双向链表结构图例
LinkedList是双向链表结构，并且具备链表头特征
class Node<E> {
Node<E> previous; // 前结点引用
E e; // 存储元素
Node<E> next; // 下一个结点引用
}
链表头 LinkedList
链表结构按照数据结构原理分析，链表长度不限制，但是按照 Java LinkedList 链表头核心数据 int size
Java 规定链表结点个数最大为 Integer.MAX_VALUE
class LinkedList<E> {
Node<E> first; // 头结点引用
Node<E> last; // 尾结点引用
int size; // 有效结点个数/有效元素个数
}
1.2LinkedList常用方法
LinkedList 遵从 List 接口，List 接口中所有方法都可以使用。
addLast(E e);
在链表末尾添加元素
addFirst(E e);
在链表头添加元素
E getLast();
获取链表尾对应的元素
E getFirst();
获取链表头对应的元素
E removeLast();
删除链表尾元素，并且返回值是存储的元素对象
E removeFirst();
删除链表头元素，并且返回值是存储的元素对象
1.3 LinkedList 核心方法源码实现
LinkedList 添加元素操作，添加数据为 E 类型
添加 E 类型对象是打包成 Node 结点，存储到 LinkedList 双向链表中中。
添加 E 类型对象方法中，包含实例化 Node 结点对象过程。
MyLinkedList.java
package com.qfedu.b_linkedList;
/**
* @author Anonymous 2023/3/2 14:49
*/
public class MyLinkedList<E> {
private MyNode<E> first;
private MyNode<E> last;
private int size;
public MyLinkedList() {
}
public boolean add(E e) {
/*
情况考虑:
1. 当前 LinkedList 有元素
LinkedList.last 结点 和新的 Node 结点拼接
2. 当前 LinkedList 没有元素
a. last = null;
b. first = null;
*/
// 1. 实例化 MyNode 结点对象
MyNode<E> node = new MyNode<>(e);
// 判断 last 是否为 null
if (null == last) {
/*
2. 当前添加的结点是整个双向链表中的第一个结点
2.1 first 存储当前结点对象
当前链表没有元素，链表头 first 和 last 都需要指向当前新结点
*/
first = node;
} else {
/*
当前链表中有元素，需要对 last 元素进行修改
3. 当前链表中有其他结点
3.1 首先获取最后一个结点对象，直接使用成员变量 last
3.2 修改 last 的 next 指向
*/
last.setNext(node);
// 3.3 修改新添加结点的 prev 为当前 last
node.setPrev(last);
}
// last 存储当前新添加结点
last = node;
// 有效元素个数 + 1
size += 1;
return true;
}
public void addLast(E e) {
add(e);
}
public void addFirst(E e) {
/*
情况
1. 当前链表中没有元素，first 和 last 直接赋值当前元素
2. 当前链表中有其他元素，需要对第一个结点 Node 进行数据修改
*/
if (null == first) {
// 2. 当前 LinkedList 中没有任何元素, 相当于尾插法
add(e);
} else {
// 3. 有其他元素
// 3.1 实例化 Node 结点
MyNode<E> node = new MyNode<>(e);
// 3.2 原本第一个 Node 结点的 prev 赋值为新结点对象
first.setPrev(node);
// 3.3 当前结点的 Node 结点的 next 赋值为 first
node.setNext(first);
// 3.4 LinkedList 中 first 赋值为新 Node 结点
first = node;
size += 1;
}
}
public E getLast() {
return last != null ? last.getE() : null;
}
public E getFirst() {
return first != null ? first.getE() : null;
}
public E removeFirst() {
E e = null;
if (size > 1) {
// 当前 LinkedList 中有结点元素
// 1. 临时存储 要求被删除的 Node 结点
final MyNode<E> temp = first;
// 2. LinkedList 中的 first 指向原本头结点之后的结点
first = temp.getNext();
// 3. first 指向的新的 头结点 prev 赋值为 null
first.setPrev(null);
// 4. 被删除的 Node 结点 next 赋值为 null
temp.setNext(null);
// 5. 有效元素 - 1
size -= 1;
// 6. 被删除的元素内容保留
e = temp.getE();
/*
省空间
e = first.getE();
first = first.getNext();
first.getPrev().setNext(null);
first.setPrev(null);
*/
} else if (1 == size) {
// 有且只有一个元素，直接获取被删除数据情况，同时 LinkedList first 和 last 同步为 null
e = first.getE();
first = null;
last = null;
size -= 1;
}
return e;
}
public E removeLast() {
E e = null;
if (size > 1) {
final MyNode<E> temp = last;
last = temp.getPrev();
last.setNext(null);
temp.setPrev(null);
e = temp.getE();
size -= 1;
} else if (1 == size) {
e = last.getE();
first = null;
last = null;
size -= 1;
}
return e;
}
@Override
public String toString() {
if (size != 0) {
StringBuilder stb = new StringBuilder("[");
MyNode<E> temp = first;
while (temp != null) {
stb.append(temp.getE().toString()).append(", ");
temp = temp.getNext();
}
return stb.substring(0, stb.lastIndexOf(", ")) + "]";
} else {
return "[]";
}
}
public int size() {
return size;
}
}
MyNode.java
package com.qfedu.b_linkedList;
/**
* 自定义结点类
*
* @author Anonymous 2023/3/2 14:49
*/
public class MyNode<E> {
private MyNode<E> prev;
private E e;
private MyNode<E> next;
public MyNode(E e) {
this.e = e;
}
// Setter and Getter 方法
public MyNode<E> getPrev() {
return prev;
}
public void setPrev(MyNode<E> prev) {
this.prev = prev;
}
public E getE() {
return e;
}
public void setE(E e) {
this.e = e;
}
public MyNode<E> getNext() {
return next;
}
public void setNext(MyNode<E> next) {
this.next = next;
}
}
头结点前添加元素图
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tNCs4oDR-1678063049824)(GP_07.assets/image-20230304144258159.png)]](https://img-blog.csdnimg.cn/82343ec28b124e489c89d0677d39a5e8.png)
头结点前删除元素图
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cR6Q80eL-1678063049826)(GP_07.assets/image-20230304144330220.png)]](https://img-blog.csdnimg.cn/9db905c9a9e449a29cf5141e8f81060c.png)
1.4LinkedList 性能分析和适用场景
因为 LinkedList 底层是一个带有链表头结构双向链表，在头结点和尾结点进行【增删改查】操作效率极高，其他的结点因为空间不连续的问题，需要进行逐一遍历，效率较低。
LinkedList 适用的场景都是一些队列，线程池，数据库连接池，消息队列，任务队列…
二.Map
2.1 存储结构概述
数据存储方式是键值对方式
<K, V>
K ==> Key 键
V ==> Value 值
【要求】
- K 不可以重复
- 常用实现类有 HashMap 和 HashTable
2.2 常用方法
构造方法
HashMap();
用于实例化 HashMap 对象
HashMap(int initCapacity);
根据用户指定的底层键值对个数/容量，实例化 HashMap 对象
成员方法:
增
put(K k, V v);
putAll(Map<? extends K, ? extends V> map);
删
V remove(Object k);
void remove(Object k, Object v);
clear();
改
put(K k, V v);
查
int size();
boolean isEmpty();
boolean containsKey(Object key);
boolean containsValue(Object value);
V get(Object k);
Collection<V> values();
Set<K> keySet();
特殊方法:
Set<Map.Entry<K, V>> entrySet();
2.3 Entry
Entry 底层结构
Entry 是 Map 结构的内部数据类型，使用的泛型是延续 Map 声明的情况。
Entry 是【键值对模型】。在 Map 中存储的键值对数据其实都是一个又一个的 Entry，Map 提供了方法将 Map 底层的 Entry 对象返回提供给程序员使用
Set<Map.Entry<K, V>> entrySet();
class Entry<K, V> {
K k;
V v;
K getKey() {
return k;
}
V getValue() {
return v;
}
}
package com.qfedu.c_map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @author Anonymous 2023/3/2 19:38
*/
public class Demo2 {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("青岛啤酒", "6RMB");
map.put("乌苏啤酒", "10RMB");
map.put("百威啤酒", "12RMB");
map.put("修道院10号啤酒", "39RMB");
map.put("精酿啤酒", "10RMB");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey() + ":" + entry.getValue());
}
// Set 集合对应的 forEach
System.out.println();
map.entrySet().forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));
// Map 双边队列 forEach
System.out.println();
map.forEach((key, value) -> System.out.println(key + ":" + value));
// Map 双边队列 forEach 同时使用方法引用
System.out.println();
map.forEach(Demo2::test);
}
public static void test(String s1, String s2) {
System.out.println(s1 + ":" + s2);
}
}
3. String类
String实现的两个接口：
Serializable【String可以串行化，可以进行网络传输】
Comparable【String对象可以比较大小】
常用的4个构造器：
String s1 = new String();
String s2 = new String(char[] c);
String s3 = new String(byte[] b);
String s4 = new String(String original);
package com.qf.string;
/**
* @Author: 只想做个优秀
* @CreateTime: 2023-03-05 21:12
* @Description: 演示String的4个常用构造器
String s1 = new String();
String s2 = new String(char[] c);
String s3 = new String(byte[] b);
String s4 = new String(String original);
*/
public class Constructor {
public static void main(String[] args) {
// 创建对象的第一种方式
String name = "abc";
name = name + "d";
// 不是abc值变化了,而是name引用变化了,name指向了新的字符串
System.out.println(name );// abcd
// String s1 = new String(); 创建空字符串对象
String s1 = "";
System.out.println(s1);// (什么都没有)
// String s3 = new String(byte[] b);
byte[] bytes = {65,66,67};
String s3 = new String(bytes);
System.out.println(s3 );// ABC
// String s2 = new String(char[] c);
char[] chars = {'我','爱','学','习'};
String s2 = new String(chars);
System.out.println(s2);// 我爱学习
// String s4 = new String(String original);
String abc = new String("dang浩123");
System.out.println(abc);// dang浩123
}
}
通过看源码得知：
String是一个final类，不能被继承
字符串中的的字符适用Unicode字符编码，一个字符(不论字母还是数字)占两个字节
String有属性 private final char value[];用于存放字符串内容。一定要注意: value 是一个final类型，不可以修改地址:即value不能指向 新的地址，但是单个字符内容是可以变化
3.1 面试题:
第一题：
Java 中字符串是一个【常量】，字符串 + 拼接每一次都会有一个新的字符串！！！
可以明确有 8 个字符串，但是在 += 拼接过程中，一共会产出 6 个多余的字符串！！！
String str = "啤酒";
str += "白酒";
str += "葡萄酒";
str += "米酒";
str += "黄酒";
str += "药酒";
str += "起泡酒";
System.out.println("请问这里有多少个字符串???");
第二题：
下方代码的运行结果剖析:
- == ，判断依据是当前变量的数据类型，引用型数据类型比较的是【地址】，基本数据类型比较的是【值】
补充：创建String对象的两种方式：
方式一:直接赋值String s = “磊哥真狗”;
方式二:调用构造器String s2 = new String(“磊哥真狗”);方式一:先从常量池查看是否有"磊哥真狗"数据空间，如果有，直接指向；如果没有则重新在常量池中创建,然后指向。即s最终指向的是常量池中的空间地址。
方式二:先在堆中创建空间，里面维护了value属性。然后从常量池查看是否有"磊哥真狗"数据空间，如果有，则value指向常量池中的"磊哥真狗"数据空间；如果常量池没有"磊哥真狗"，重新在常量池中创建然后指向。最后s2指向堆中的空间地址。
画出String创建对象两种方式的内存分布图：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j8Ndnhs7-1678063049827)(GP_07_LInkedList 和 Map 和 String 和 Math类.assets/image-20230305210007401.png)]](https://img-blog.csdnimg.cn/216249a557314504affb1d71e3de0f1e.png)
对于 Java 而言所有 “” 包含的字符串内容，只要是一样的，都是同一个字符串，为了省空间
【规定】任何时候，字符串判断是否一致，必须使用 equals(Object) 方法。equals方法是 Object 类方法，String 进行重写之后，是字符串数据内容进行判断比较。
String str1 = "磊哥真狗";
String str2 = "磊哥真狗";
String str3 = new String(str1);
String str4 = new String("磊哥真狗");
sout(str1 == str2);
sout(str2 == str3);
sout(str3 == str4);
sout(str4 == str1);
/*
T F F F
*/
JDK 1.7 和 JDK 1.8 字符串常量 + 处理的区别
jdk1.7字符串拼接操作是在数据区/常量池进行，操作过程效率较低。
jdk1.8是根据第一个字符串，在内存堆区创建StringBuilder可变长字符串对象，利用append进行拼接其他字符串，效率高，不占用数据区/常量池空间，最后通过toString方法转换为String字符串返回
3.2字符串常用方法
3.2.1 字符串获取相关数据的方法(6个)
int length();
字符串有效字符长度。
char charAt(int index);
获取当前字符串指定下标元素的字符
int indexOf(int ch);
查询指定字符在当前字符串中第一次出现的下标位置，如果没有找到返回 -1
int indexOf(String str);
查询指定字符串在当前字符串中第一次出现的下标位置，如果没有找到返回 -1
int lastIndexOf(int ch);
查询指定字符在当前字符串中最后一次出现的下标位置，如果没有找到返回 -1
int lastIndexOf(String str);
查询指定字符串在当前字符串中最后一次出现的下标位置，如果没有找到返回 -1
package com.qf.string;
/**
* @Author: 只想做个优秀
* @CreateTime: 2023-03-05 21:33
* @Description:字符串获取相关数据的方法(6个)
*/
public class Get {
public static void main(String[] args) {
// int length();
// 字符串有效字符长度。
String s1 = "党浩一定能坚持学java";
int length = s1.length();
System.out.println(length);// 12
// char charAt(int index);
// 获取当前字符串指定下标元素的字符
char c = s1.charAt(0);
System.out.println(c);// 党
// int indexOf(int ch);
// 查询指定字符在当前字符串中第一次出现的下标位置，如果没有找到返回 -1
String s2 = "党浩党浩党浩";
int h = s2.indexOf('党');
System.out.println(h);// 0
int a = s2.indexOf('啊');
System.out.println(a);// -1
// int indexOf(String str);
// 查询指定字符串在当前字符串中第一次出现的下标位置，如果没有找到返回 -1
int dh = s2.indexOf("党浩");
System.out.println(dh);// 0
// int lastIndexOf(int ch);
// 查询指定字符在当前字符串中最后一次出现的下标位置，如果没有找到返回 -1
int d1 = s2.lastIndexOf('党');
System.out.println(d1);// 4
// int lastIndexOf(String str);
// 查询指定字符串在当前字符串中最后一次出现的下标位置，如果没有找到返回 -1
int dh2 = s2.lastIndexOf("党浩");
System.out.println(dh2);// 4
}
}
3.2.2 字符判断的方法个(6个)
boolean endsWith(String str);
判断当前字符串是否以目标字符串结尾
boolean startsWith(String str);
判断当前字符串是否以目标字符串开头
boolean isEmpty();
当前字符串是否为空，JDK1.6 之后空字符串是""
boolean contains(String str);
判断指定字符串是否在当前字符串中存在。
boolean equals(Object obj);
重写 Object 类方法，判断两个字符串数据内容是否一致
boolean equalsIgnoreCase(String str);
不区分大小写比较字符串内容。
package com.qf.string;
/**
* @Author: 只想做个优秀
* @CreateTime: 2023-03-05 21:55
* @Description:字符判断的方法个(6个)
*/
public class Judgment {
public static void main(String[] args) {
// boolean endsWith(String str);
// 判断当前字符串是否以目标字符串结尾
String s1 = "只想做个优秀";
boolean yx = s1.endsWith("优秀");
System.out.println(yx);// true
// boolean isEmpty();
// 当前字符串是否为空，JDK1.6 之后空字符串是""
boolean empty = s1.isEmpty();
System.out.println(empty);// false
// boolean equals(Object obj);
// 重写 Object 类方法，判断两个字符串数据内容是否一致
String s2 = "zhixiang";
System.out.println(s1.equals(s2));// false
// boolean equalsIgnoreCase(String str);
// 不区分大小写比较字符串内容。
String s3 = "ZHIXIANG";
System.out.println(s2.equalsIgnoreCase(s3));// true
}
}
3.2.3 字符串转换的方法(5个)
String(char[] arr);
【构造方法】将一个字符数组转换为字符串
String(char[] arr, int offset, int length);
【构造方法】将一个字符数组转换为字符串，offset表示从字符数组中哪一个下标开始，length 是计数字符个数
static String valueOf(char[] arr) {
return new String(arr);
}
【静态方法】将一个字符数组转换为字符串
static String valueOf(char[] arr, int offset, int length) {
return new String(arr, offset, length);
}
【静态方法】将一个字符数组转换为字符串，offset表示从字符数组中哪一个下标开始，length 是计数字符个数
char[] toCharArray();
字符串内容转字符数组
package com.qf.string;
/**
* @Author: 只想做个优秀
* @CreateTime: 2023-03-05 22:08
* @Description:字符串转换的方法(5个)
*/
public class Transfer {
public static void main(String[] args) {
// String(char[] arr);
// 【构造方法】将一个字符数组转换为字符串
char[] arr1 = {'我','爱','学','j','a','v','a'};
String s1 = new String(arr1);
System.out.println(s1);
// String(char[] arr, int offset, int length);
// 【构造方法】将一个字符数组转换为字符串，offset表示从字符数组中哪一个下标开始，length 是计数字符个数
String s2 = new String(arr1, 2, 5);
System.out.println(s2);// 学java
// static String valueOf(char[] arr) {
// return new String(arr);
// }
// 【静态方法】将一个字符数组转换为字符串.静态成员方法通过类名String调！！！
String s3 = String.valueOf(arr1);
System.out.println(s3);// 我爱学java
// static String valueOf(char[] arr, int offset, int length) {
// return new String(arr, offset, length);
// }
// 【静态方法】将一个字符数组转换为字符串，offset表示从字符数组中哪一个下标开始，length 是计数字符个数
String s4 = String.valueOf(arr1, 3, 4);
System.out.println(s4);// java
// char[] toCharArray();
// 字符串内容转字符数组
String s5 = "我爱学java";
char[] c = s5.toCharArray();
System.out.println(c);// 我爱学java(是单个的字符数组)
}
}
3.2.4 修改字符串，返回新字符串，而且原字符串无改变(7个)
String replace(char oldChar, char newChar);
调用方法字符串中的所有 oldChar 替换为 newChar，通过方法返回值得到结果新字符串。
String[] split(String str);// 【重要方法】
当前字符串按照目标字符串进行切割操作，得到结果为字符串数组
案例:
String str = "name=James&age=37&gender=f";
String[] arr = str.split("&");
arr 数组中数据内容 ==> {"name=James","age=37", "gender=f"}
String substring(int begin);
截取子字符串，从目标下标 begin 到字符串末尾
String substring(int begin, int end);
截取子字符串，从目标下标 begin 到 end 结束，要头不要尾
String toUpperCase();
字符串内容小写字母全部转大写，得到新字符串
String toLowerCase();
字符串内容大写字母全部转小写，得到新字符串
String trim();
去除字符串两边的无效空格，返回新字符串
package com.qf.string;
/**
* @Author: 只想做个优秀
* @CreateTime: 2023-03-05 22:36
* @Description: 修改字符串，返回新字符串，而且原字符串无改变
*/
public class NewString {
public static void main(String[] args) {
// String replace(char oldChar, char newChar);
// 调用方法字符串中的所有 oldChar 替换为 newChar，通过方法返回值得到结果新字符串。
String s1 = "我爱学java";
String r1 = s1.replace('爱', '喜');
System.out.println(s1);// 我爱学java
System.out.println(r1);// 我喜学java
// String[] split(String str);// 【重要方法】
// 当前字符串按照目标字符串进行切割操作，得到结果为字符串数组
// 案例:
// String str = "name=James&age=37&gender=f";
// String[] arr = str.split("&");
// arr 数组中数据内容 ==> {"name=James","age=37", "gender=f"}
// String substring(int begin);
// 截取子字符串，从目标下标 begin 到字符串末尾
String substring = s1.substring(1);
System.out.println(substring);// 爱学java
// String substring(int begin, int end);
// 截取子字符串，从目标下标 begin 到 end 结束，要头不要尾
String substring1 = s1.substring(2, 4);
System.out.println(substring1);// 学j
// String toUpperCase();
// 字符串内容小写字母全部转大写，得到新字符串
String t1 = s1.toUpperCase();
System.out.println(t1);// 我爱学JAVA
// String toLowerCase();
// 字符串内容大写字母全部转小写，得到新字符串
// String trim();
// 只去除字符串两边的无效空格，返回新字符串
String s2 = " 我爱学 java ";
String trim = s2.trim();
System.out.println(trim);// 我爱学 java
}
}
4.Math类
列举八个常用的数学方法(都是静态方法，所以可以通过类Math类名直接调用，并且有对应的返回值)
abs 绝对值
pow 求幂
sqrt 开平方
ceil向上取整，返回 >= 该参数的最小整数
floor 向下取整，返回 <= 该参数的最大整数
round四舍五入
max和min 返回最大值和最小值
random 返回的是[0,1)之间的随机小数，小数点后保留16位
代码演示：
public class Demo1 {
public static void main(String[] args) {
// 以下是Math常用的方法(都是静态方法，所以可以通过类Math类名直接调)
// 1.abs 绝对值
int abs = Math.abs(-9);
System.out.println(abs);// 9
// 2.pow 求幂
double pow = Math.pow(2, 4);// 2的4次方
System.out.println(pow);// 16.0
// 3.sqrt 开平方
double sqrt = Math.sqrt(9.0);
System.out.println(sqrt);// 3.0
// 4.ceil向上取整，返回 >= 该参数的最小整数
double ceil = Math.ceil(-3.0001);
System.out.println(ceil);// -3.0
// 5.floor 向下取整，返回 <= 该参数的最大整数
double floor = Math.floor(-4.999);
System.out.println(floor);// -5.0
// 6.round四舍五入
long round = Math.round(5.51);
System.out.println(round);// 6
// 7.max和min 返回最大值和最小值
int max = Math.max(1, 9);
System.out.println(max);// 9
int min = Math.min(1, 9);
System.out.println(min);// 1
// 8.random 返回的是[0,1)之间的随机小数，小数点后保留16位
double random = Math.random();
System.out.println(random);// 0.6135571246605124
// 练习：获取a——b之间的随机整数
//公式 ：int num = (int)(Math.random()*b-a+1)
}
}
tln(abs);// 9
// 2.pow 求幂
double pow = Math.pow(2, 4);// 2的4次方
System.out.println(pow);// 16.0
// 3.sqrt 开平方
double sqrt = Math.sqrt(9.0);
System.out.println(sqrt);// 3.0
// 4.ceil向上取整，返回 >= 该参数的最小整数
double ceil = Math.ceil(-3.0001);
System.out.println(ceil);// -3.0
// 5.floor 向下取整，返回 <= 该参数的最大整数
double floor = Math.floor(-4.999);
System.out.println(floor);// -5.0
// 6.round四舍五入
long round = Math.round(5.51);
System.out.println(round);// 6
// 7.max和min 返回最大值和最小值
int max = Math.max(1, 9);
System.out.println(max);// 9
int min = Math.min(1, 9);
System.out.println(min);// 1
// 8.random 返回的是[0,1)之间的随机小数，小数点后保留16位
double random = Math.random();
System.out.println(random);// 0.6135571246605124
// 练习：获取a——b之间的随机整数
//公式 ：int num = (int)(Math.random()*b-a+1)
}
}
102
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
