常用工具类
java.util.Date;日期
java.time.LocalDate;
java.time.LocalDateTime;Java8后的日期
java.lang.Math 数学运算
java.util.Arrays 数组工具类
package d12;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.util.Date;
public class D12 {
public static void main(String[] args) {
//java.time.LocalDateTime Java8后新增的日期类
//获取当前日期时间
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDateTime);
System.out.println(localDateTime.getYear());//获取年份
System.out.println(localDateTime.getMonthValue());//获取月份
System.out.println(localDateTime.getMonth());//获取月的名字
System.out.println(localDateTime.getDayOfMonth());//或租所在月的第几天
System.out.println(localDateTime.getDayOfWeek());//获取所在周的第几天
System.out.println(localDateTime.getHour());//获取小时
System.out.println(localDateTime.getMinute());//获取分钟
System.out.println(localDateTime.getSecond());//获取秒
//自定义一个日期
LocalDate date2 = LocalDate.of(2014, Month.JULY, 20);
System.out.println(date2);
// //java.util.Date 日期
//
//
// Date date = new Date();//创建一个日期对象
// System.out.println(date);
//
// //java.text.Sim
// //new SimpleDateFormat(日期格式模板) 创建一个日期格式化工具类
// SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
// String dateString = sf.format(date);
// System.out.println(dateString);
// //java.lang.Math 数学运算
// byte a = 2;
// short b = 4;
// //加法
// int h = Math.addExact(a,b);
// System.out.println(h);
//
// //减法
// int j = Math.subtractExact(a, b);
//
// //乘法
// int c = Math.multiplyExact(a, b);
//
// //除法
// int chu = Math.floorDiv(a, b);
//
// System.out.println("----------------------");
//
// //求最大值
// int max = Math.max(12, 3);
// System.out.println(max);
// //最小
// int min = Math.min(2, 3);
// System.out.println(min);
//
// //绝对值
//
// double ab = Math.abs(-3.14);
// //圆周率
// System.out.println(Math.PI);
// //pow(a,b)a的b次方
// double r1 = Math.pow(2, 10);
// System.out.println(r1);
}
}
包装类
8个基本数据类型分别对应的包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
package d12;
import java.util.Arrays;
public class D12 {
public static void main(String[] args) {
//java.util.Arrays 数组工具类
int[] a = {2,1,3,4,5};
//1.打印数组
System.out.println(Arrays.toString(a));
//2.数组赋值
Arrays.fill(a, 0);//给数组所有元素赋值为0
//fill（数组，开始下标，结束下标，替换值）
//从开始下标（包括开始下标）到结束下标（不包括结束下标）范围内的所有元素都替换为11
// Arrays.fill(a, 1, 3, 11);
//3.数组排序
// Arrays.sort(a);
//4.二分查找 前提：数组排好序
// int index = Arrays.binarySearch(a, 3);
// System.out.println(index);
//5.数组扩容 copyOf(原数组,新数组长度)
int[] b = Arrays.copyOf(a, 12);
System.out.println(Arrays.toString(b));
//6.比较数组中的元素以及顺序是否相同
int[] c = {2,1,3,4,5};
boolean tar = Arrays.equals(a, c);
System.out.println(tar);
}
}
package d12;
import java.util.Arrays;
public class D12 {
public static void main(String[] args) {
int a = 12;
Integer b = a;
Integer b2 = 20;
String str = "110";
//valueOf()将其他类型，转换为整数类型
Integer b3 = Integer.valueOf(str);
//取值范围
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;
System.out.println();
/*
* valueOf的原理
* Integer会缓存[-128,127]这个范围内的数，当传入的参数在这个范围内时，会直接返回缓存中的数字
* 否则超出这个范围才创建新的Integer对象
* */
//1.比较两个数的大小
int res = Integer.compare(2, 4);//compare(a,b)返回1表示a>b返回-1表示a<b返回0表示a=b
//2.数字转字符串
String s = Integer.toString(res);
}
}
集合
Collection接口又有3种子类型，List、Set和Queue，在下面是一些抽象类，最下面具体实现类
Collection的实现类只能存储引用类型，所以对于基本数据类型，Collection的实现类只能存储他们的包装类（位于java.lang包）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lD0qzYFq-1666005032931)(C:\Users\19912\Documents\Tencent Files\1991234066\FileRecv\6-1 集合-Collection.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XRsiXjnG-1666005032933)(C:\Users\19912\Documents\Tencent Files\1991234066\FileRecv\6-2 集合-Map.png)]
List
有序，可重复
ArrayList是实现了基于动态数组的数据结构，在未声明长度的情况下，默认长度是10，数据填满会自动扩充原长度的一半
public static void main(String[] args) {
//创建一个List集合
List<String> list = new ArrayList<>();
//添加元素
list.add("AAA");
//指定下标添加元素
list.add(1,"CCC");
//获取元素的值
// System.out.println(list.get(1));
//集合的长度
// System.out.println(list.size());
//遍历集合
for (String s : list) {
System.out.println(s);
}
//List是有序的，允许重复的
list.add("BBB");
list.add("BBB");
}
Set
特点：
1.集合中的元素无序，不可重复
public static void main(String[] args) {
//创建一个set集合
Set<Integer> set = new HashSet<Integer>();
//添加元素
set.add(1);
set.add(2);
//获取集合的长度size
//遍历元素
//判断是否存在指定元素
boolean tar = set.contains(1);
//移除元素
set.remove(2);
//清空集合
set.clear();
}
Queue
队列：先进先出
栈：后进先出
package d12;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;
/*
队列Queue
*/
public class D13 {
public static void main(String[] args) {
//创建一个set集合
Queue<Integer> queue = new LinkedList<Integer>();
//添加元素
queue.add(12);
queue.add(4);
//获取队列长度size()
//1.获取队列头部元素，但不删除，队列为空，引发异常
// int firstEle = queue.element();
//2获取队列头部元素，不删除，队列为空返回null
// Integer fristEle2 = queue.peek();
//3.获取并删除头部元素，队列为空，返回null
// Integer fristEle3 = queue.poll();
// System.out.println(fristEle3);
//
// System.out.println(queue.poll());
//4.在不超过容量长度的情况下，可以立即插入一个元素到队列尾
//当插入元素超出容量长度时（插入失败），add()方法会报异常，而offer()方法会返回布尔值false
queue.offer(7);
//5.遍历队列
Integer ele = null;
while ((ele = queue.poll()) != null) {
System.out.println(ele);
}
}
}
vector
允许重复
1.基于动态数组的数据结构
2.是线程同步（线程安全），执行效率慢
3.数据填满时会自动扩容原长度的一倍，因此ArrayList更节省空间
package d12;
import java.util.List;
import java.util.Vector;
/*
Vector
1.基于动态数组的数据结构
2.是线程同步（线程安全），执行效率慢
3.数据填满时会自动扩容原长度的一倍，因此ArrayList更节省空间
*/
public class D13 {
public static void main(String[] args) {
List<Integer> vector = new Vector<Integer>();
//添加
vector.add(1);
vector.add(1);
vector.add(2);
vector.add(3);
//集合长度
System.out.println(vector.size());
//获取指定下标的元素
Integer ele = vector.get(3);
System.out.println(ele);
for (Integer integer : vector) {
System.out.println(integer);
}
}
}
Map
特点：
- 存储的是键值对
- k和v只能存储引用类型
- map的key不允许重复，多次给一个key赋值，后面的会把前面的赋值覆盖Map
| Map实现类 | Key | Value |
|---|---|---|
| HashMap | 允许为null | 允许为null |
| TreeMap | 不允许为null | 允许为null |
| ConcurrentMap | 不允许为null | 不允许为null |
| HashTable | 不允许为null | 不允许为null |
package d12;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*
Map
*/
public class D13 {
public static void main(String[] args) {
//创建一个Map集合，map中存储的元素，k-v键值对
Map<String, Integer> map = new HashMap<String, Integer>();
//添加元素
map.put("name", 12);//k-v键值对 key键，value值
//获取值,根据键名
Integer v = map.get("name");
System.out.println(v);
map.put("name", 24);//map中的键名是唯一的，多次对同一个键赋值，后面的值会覆盖前面的值
System.out.println(map.get("name"));
//集合长度
int len = map.size();
//获取集合中所有键的Set集合
Set<String> kSet = map.keySet();
for (String k : kSet) {
System.out.println(map.get(k));
}
//清空
// map.clear();
//是否包含指定键
boolean hasK = map.containsKey("name");
//是否包含指定值
boolean hasV = map.containsValue(24);
System.out.println(hasV);
//获取所有键值对的Set集合
Set<Entry<String, Integer>> eSet = map.entrySet();
for (Entry<String, Integer> entry : eSet) {
System.out.println(entry.getKey()+entry.getValue());
}
//判断是否为空集合
boolean t = map.isEmpty();
//根据键删除键值对
// System.out.println(map);
// map.remove("name");
// System.out.println(map);
//替换
map.replace("name", 100);
System.out.println(map);
}
}
HashMap的实现原理
- HashMap底层原理是数组加链表的结构，在java8后又增加了红黑树
- 当添加一个元素key-value时，首先计算键值对的Key的hash值，以此来确定插入到数组的位置
- 如果根据Hash值确定的数组位置已经存在元素，就添加到同一个Hash值的元素的后面，于是形成了链表
- 当链表长度大于8，并且数组中元素k-v键值对个数超过64时，链表就转成红黑树，这样就提高了查找的速率
- 当红黑树中的节点数个数小于6时，红黑树又重新转换为链表
小练习
package d13;
import java.util.ArrayList;
import java.util.List;
public class Student {
private String name;
private double grade;
private char level;
public Student(String name, double grade) {
this.name = name;
this.grade = grade;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getGrade() {
return grade;
}
public void setGrade(double grade) {
this.grade = grade;
}
public char getLevel() {
return level;
}
public void setLevel(char level) {
this.level = level;
}
@Override
public String toString() {
return "Student [name=" + name + ", grade=" + grade + ", level=" + level + "]";
}
void stuLevel(){
if (grade >=85) {
level = 'A';
}else if (grade>=60&&grade<85) {
level = 'B';
}else {
level = 'c';
}
}
public static void main(String[] args) {
List<Student> list = new ArrayList<Student>();
list.add(new Student("张三",85));
for (Student student : list) {
student.stuLevel();
}
System.out.println(list);
}
}
扫一扫
613
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
