javaee（常用api集合）-编程思维

javaEE

常用API

Object类

  • public String toString() //打印地址 ：类的全类名@内存地址

    • 存在的意义：为了被子类去重写，以便于返回对象的内容信息，而不是地址信息

  • public Boolean equals（）//默认比较两个对象的地址是否相同

    public  Boolean equals（Object o）{
   // 1.不是同一个对象比较
    if(this==0) return true;
    //o是不是null
    if(o==null||this.getClass()!=o.getClass()) return false;
    //o一定是Student类型不是null
    Student student =(Student) o;
    return sex==student.sex&&age==student.age&&Object.equals(name,student.name);
}

StringBuilder

可变的字符串类，看成一个对象容器

提高效率，如凭借、修改

1.构造器：

  • public StringBuilder()
  • public StringBuilder(String str)

2.常用方法

  • public StringBuilder append(任意类型) 添加数据并返回StringBuilder 对象本身
  • public StringBuilder reverse() 将对象的内容反转
  • public in length() 返回对象的长度
  • public String toString() 通过toString() 就可以实现StringBuilder 转换为String
//例子
public static String toString(int[] arr){
    if(arr!=null){
        StringBuilder  sb =new StringBuilder ("[");
        for(int i =0;i<arr.length;i++){
            sb.append(arr[i]).append(i==arr.length-1?"":",");
        }
        //这里不能少；恒优雅
        sb.append("]");
        return sb.toString();
    }else{
        return null;
    }
}

Math

没有提供公开的构造器、工具类

全部是静态方法

  • public static int abs(int a) 获得绝对值
  • public static double ceil (double a) 向上取整
  • public static double floor(double a) 向下取整
  • public static int round(float a) 四舍五入
  • public static int max(int a,int b) 获得两个int 的较大值
  • public static double pow(double a,double b) 返回a 的幂
  • public static double random() 返回double的随机数【0.0,1.0）

System

System类的功能是相同的，都是直接用类名调用即可

System的方法：

  • public static void exit(int status) 终止当前的java虚拟机，非0表示异常的终止
  • public static long currentTimeMillis() 返回当前系统的事件毫秒值形式
  • public static void arraycopy (数据源数组，启始索引，目的地数组、起始索引、拷贝个数) 数组拷贝

BigDecima

解决浮点型的精度失真

public static BigDecima valueOf(double val); 包转成浮点对象为BigDecima对象

  • public BigDecima add（BigDecima b）加法
  • public BigDecima subtract(BigDecima b)减法
  • public BigDecima multiply (BigDecima b)乘法
  • public BigDecima divide (BigDecima b)除法
  • public BigDecima divide（舍入模式）除法

日期和事件

Date类在当前系统所在的此刻的日期时间

java.util.Date

Date time =new Date();
  • public long getTime() 获取对象的毫秒值1970.1.1.00.00
long time =System.currentTimeMillis();
  • 毫秒值转变成日期对象
public Date(long time);

public void setTime(Long time)

设置日期对象的事件为当前的时间毫秒值的时间

SimpleDateFormat构造器

  • public SimpleDateFormat() 默认格式
  • public **SimpleDateFormat(String pattern)指定格式

SimpleDateFormat的格式化方法

  • public final String format(Date date) 将日期格式化成日期/时间字符串
  • public final String format (Object time)将时间毫秒值转化为日期/时间字符串
  • public Date parse(String source) 从给定字符串的开始解析文本以生成日期
y 年
M 月
d 日
H 时
m 分
s 秒

yyyy-MM-dd HH:mm:ss

Date d =new Date();
SimpleDateFormat sdf =new SimpleDateFormat(yyyy-MM-dd);
String s =sdf.format(d);


String s ="2022年05月06日 14:55:60"
SimpleDateFormat sdf =new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");
Date d =  sdf.parse(s);
long time =d.getTime()+(2L*24*60*60+14*60*60+49*60+6)*1000;
sdf.format(time);

Calendar

  • Calendar代表系统此刻日期对应的日期对象
  • Calendar是抽象类，不能直接创建对象
Calendar cal =Calendar.getInstance();
//先获取字段 syso (cal)
int year =cal.get(Calendar.YEAR);
int moth =cal.get(Calendar.MONTH);
int days=cal.get(Calendar.DAY_OF_TEAR);
cal.set(Calendar.HOUR,12);//一般不会修改日历
//64天后的日期
cal.add(Calendar.DAY_OF_TEAR,64);

JDK8新增的日期类

  • LocalDate:不包含具体时间 2022-05-06getYear()\ getMonth()\getDayofMonth、getDayofYear、getDayofWeek、getMonth（）.getValue()、getMonthValue()
  • LocalTime:不包含日期时间
  • LocalDateTime:包含了日期时间
  • Instant代表的是时间戳得到的是标准时间英国
  • DateTimeFormatter用于做时间的格式化和解析
  • Duration用于计算时间的间隔
  • Period用于计算两个日期的间隔

和String类似

  • public static Xxxx now（）；静态方法，当前时间创建对象
  • public static Xxxx of(.....);静态方法，指定时间创建对象

包装类

8种数据类型的引用类型

byte-----Byte

short ------Short

int ------Integer

char----Character

float----------Float

double-------Double

boolean---Boolean

long------Long

  • 为了实现一切皆对象
  • 后面的集合和泛型只能支持包装类型，不支持基本数据类型

自动拆箱：包装类的变量可以直接赋值给基本数据类型

自动装箱：基本类型的数据和变量可以直接赋值给包装类的变量

特有功能：

  • 包装类的变量的默认值可以是null 容错率更高
  • 基本数据类型变成字符串
    • 调用toString（）方法
    • Interger.toString(基本数据类型的数据)
  • 可以把字符串的数值变成真实的数据类型
    • Interger.parseInt("字符串类型的整数")；

正则表达式

public static boolean checkQQ(String s){
    if(s==null||s.length()<6||s.length()>20){
        return false;
    }
    //判断是否全为数字
    for(int i=0;i<s.length();i++){
        char ch = s.charAt(i);
        if(ch<'0'||ch<'9'){
            return false;
        }
    }
    return true;
}

//简化正则
public static checkQQ（string s）{
    return s！=null&&s.matches("\\d{6,20}");
}
  • 字符类
    • [abc]
    • [a-zA-z]
    • [a-z&&[^ m-p]]

默认匹配一个字符

预定义的字符集：

  • . 任何字符
  • \d 一个数字：[0-9]
  • \D 非数字
  • \s 一个空白的字符
  • \S 非空的字符
  • \w 英文数字下划线
  • \W 一个非单词字符

匹配多个字符

  • X? 一次或根本不
  • X* 零次或多次
  • X{n} 正好n次
  • X{n， }至少n次
  • X{n,m} 至少n次但不超过m次

public boolean matches (String regex);

//例子
String ss ="........"
//1.写正则：
String regex =""
//2.把爬取的规则编译成对象
    Pattern pa =Pattern.compile(regex);
//3.得到一个内存匹配的对象
Matcher ma = pa.matcher(ss);
//开始查找
whil(matcher.find()){
    String rs = matcher.group();
}

Arrays

数组的工具类：

  • public static String toString(类型[] a) 对数组进行排序
  • public static void sort (类型[] a) 对数组进行默认升序排序
  • public static void sort(类型[] a,Comparator<?superT>c) 使用比较器对象自定义排序
  • public static int binartSearch(int [] a,int key) 二分搜索数组中的数据，存在返回索引，不存在返回-1**-（插入的位置的索引+1）
int[] a={1,2,3,5,6,10};
Arrays.方法（a）；

//比较器
Integer [] ages={1,2,3,4,5,6};
Arrays.sort(ages,new Comparayor<Integer>(){
    @Override
    public int compare(Integer o1,Integer o2){
        //指定比较规则
        return -(o1-o2);
    }
})
  • 认为左边数据 大于 右边数据 返回正数
  • 认为左边数据 小于右边数据 返回负数
  • 认为左边数据 等于 右边数据 返回 0

Lambada表达式

只能简化函数接口的匿名内部类,一个抽象方法,

  • @FunctionalInterface加注解

懒汉

  • 参数类型可以省略不写
  • 如果只有一个参数，参数类型可以省略，同时（）也就可以省略
  • 如果lambda表达式的方法代码只有一行代码，可以省略大括号，同时省略分号
  • 如果lambda的方法体的代码只有一行代码，如果还是return语句，必须省略return，也不写；

作用简化匿名内部类的简化代码

(匿名内部类的重写的形参列表)->{

​ 被重写的方法

}

//简化匿名内部类的代码
@FunctionalInterface
public interface aaa{
    public void run();
}


main(String[] args){
aaa a =()->{
    syso("Lambada的方法")；
}    
}

go(()->{
       syso("Lambada的方法")；
})

Collection集合体系

集合和数组都是容器。

  • 数组定义完后，类型确定，长度固定。
  • 数组增删都要放弃原有的数组或者移位

集合：

  • 大小不确定
  • 存储对象的一种容器
  • 非常适合做增删改查
  • 基本的数据类型用包装类

Collection单列：每个元素只包含一个值

Map双列:j键值对

Collection是一个接口：

  • List
    • ArrayList
    • LinkedList
  • Set
    • HashSet
      • LinkedHashSet
    • TreeSet

Collection集合特点：

  • List集合：添加的元素是有序、可重复、有索引
    • ArrayList、LinkedList：有序、可重复、有索引
  • Set集合特点：添加的元素是无序、不重复、无索引
    • HashSet：无序、不重复、无索引；LinkedHashSet：有序、不重复、无索引
    • TreeSet：按照大小默认升序，不重复，无索引
Collection<String> c =new ArratList<String>();//约束数据类型
Collection<String> c =new ArratList<>();//JDK1.7后可以不写

add() 添加

集合常用API

  • 添加元素add()
  • 清空集合clear()
  • 判断集合是否为空isEmpty()
  • 获取集合的大小size()
  • 判断集合中的元素是否存在contains()
  • 删除集合中的元素remove() 默认只会删除前面的一个，要删除所有的要边遍历，边判断删除
  • 把集合变成数组Object[] a = array.toArray();

集合的遍历方式

1.迭代器：

  • 遍历就是一个一个的把容器中的元素访问一遍
  • 迭代器在java中的代表是Iterator,迭代器是集合的专用的遍历方式

获取结合的迭代器：

Collection<String> sc =new ArrayList<>();
sc.add("我")；
sc.add("是")；
sc.add("大")；
sc.add("佬")；
sc.add("！")；
//1.获得迭代器
Iterator<String> it =sc.iterator();
while(it.hasNext()){
    String a=it.next();
}

用一次，取一次越界会有越界异常

2.forEach遍历

  • 既可以遍历集合也可以遍历数组内部是迭代器，但是迭代器不能遍历数组
  • 实现了Iterator接口才能使用

格式：

for(元素数据类型 变量名：数组或者Collection集合){

​ 在此用变量即可，该变量就是元素

}

Collection<String> list =new ArrayList<>();
....
for(String it:list){
    syso(it);
}

3.lambda表达式

  • default void forEach(Consumer<? super T> action) 结合lambda遍历集合
list.forEach(new Cousumer<String>(){
    @Overrride
    public void accept(String s){
        System.out.print(s);
    }
})

数据结构

栈：

后进先出、先进后出

  • 进入栈：压/进栈
  • 出栈：弹

队列

先进先出，后进后出

  • 入队列
  • 出队列

数组

  • 查询速度快，查询数据通过地址值和索引定位，查询任意诗句的耗时相同。（元素中在内存中是连续存储的）
  • 删除效率低：要将原始数据删除，同时后面的每个数据前移
  • 添加效率极低：添加位置后的每个数据后移，再添加元素

链表

链表中的元素是游离存储的，每个元素的节点包含数据值和下一个元素的地址

  • 链表的查询慢，无论查哪个数据都是从头开始
  • 链表的增删较快

单向链表

双向链表（java多用）

二叉树

父节点：左右节点、值

  • 只能有一个根节点
  • 节点的度
  • 高度
  • 层
  • 兄弟节点

二叉查找树

目的：提高检索数据的性能

会变成瘸子

平衡二叉树

任意节点的左右两个自树的高度不超过1，任意节点的左右的两个自树都是一颗平衡二叉树

  • 进行左旋或者右旋

情况：左边高右边拉，右边高左边拉

红黑树

平衡二叉B树

  • 每个节点是红色或者是黑色，根节点是黑色
  • 如果一个节点没有子节点或者父节点，则该节点相应的指针值为Nil，这些Nil视为叶节点，叶节点是黑色的
  • 如果一个节点是红色的，那么它的子节点必须是黑色（不能出现两个红色节点相连的情况）
  • 对于每个节点，从节点到所有的其所有的后代叶子节点的简单路径上，均包含相同的黑色节点

添加节点：

  • 添加节点可以黑色可以红色
  • 默认红色效率高

牛逼红黑树

List集合

  • ArrayList、LinedList：有序、可重复、有索引
  • 有序：存储和取出的元素顺序是一致的
  • 有索引：可以通过索引操作元素
  • 可重复：存储的元素可以重复操作

特有方法：

  • void add(int index,E element) 在集合中的指定位置插入指定的元素
  • E remove（int index） 删除指定索引出的元素，返回被删除的元素
  • E set （int index， E element）修改指定索引处的元素，返回被修改的元素
  • E get （ int index） 返回指定索引处的元素
//多态
List<String> arr =new ArrayList<>();
arr.add("Java");
arr.add("Mybatis");
arr.add("Mysql");
//特有
arr.add(2,"HTML");
arr.remove(2);
arr.get(2);
arr.set(1,"springboot");

遍历方式：

通用的遍历方式都可以

ArrayList的底层原理：

基于数组实现

  • 在底层先创建一个10的默认数组
  • 有一个size指针指向下个位置--------现在的数组的长度
  • 扩容1.5倍，元素重新迁移

LinkedList的底层原理：

基于双链表，查询慢，首尾操作快，但是查询很慢

特有方法：

  • public void addFirst(E e) 在该列表的开头插入指定的元素push()
  • public void addLast(E e)将指定的元素追加到此列表的末尾pop()
  • public E getFirst()返回此列表中的第一个元素
  • public E getLast()返回此列表的最后一个元素
  • public E removeFirst()从此列表中删除并返回第一个元素
  • public E removeLast()从此列表中删除并返回最后一个元素
//栈
LinkedList<String> stack =new LinkedList<>();
stack.addFirst("java");
stack.addFirst("HTML");
stack.addFirst("CSS");
stack.addFirst("Spring boot");
//删除并取出
stack.removeFirst()
//队列
 LinkedList<String> query =new LinkedList<>();
query.addLast("java");
query.addLast("HTML");
query.addLast("CSS");
query.addLast("Mybatis");
//删除并取出
query.removeFirst()

集合的并发修改异常

1.使用迭代器删除当前位置的元素不后移

Iterator<String> arr =list.iterator();
while(arr.hasNext()){
    String ss= is.next();
    //list.remove(); 这是不对的，要用迭代器来用remove
    it.remove();
}

2.foreach和lambda也是有bug的

3.for会漏删

结局方案：倒着删

泛型

  • 统一数据类型
  • 把运行时间出现的错误，编译时就能出现

自定义泛型类（架构师技术）

  • 定义了类的同时定义了泛型的类就是泛型
  • 泛型的格式

修饰符class类名<泛型变量>{}

public class MyArrayList<T>{

    public void add(T t){
        
    }
}

MyArrayList<String> a =new MyArrayList<>();
a.add("字符串")；

自定义泛型方法

格式：

public<T> void show(T t){}

接受任意类型的参数

public<T> void show(T[] t){
    StringBuilder sb =new StringBuilder("[");
    if(t==null){
        return false;
    }
    for(int i =0;i<t.length;i++){
        sb.append(t[i]).append(i==t.length-1?"":",");
    }
    sb.append("]");
    System.out.print(sb);
}

泛型接口

public interface Data<E>{}

public interface Data<E>{
    public void add(E e);
}

泛型的通配符

  • ？可以在使用泛型时代表一切类型
  • E T K V是在定义泛型时使用
go(ArrayList<?> a){}
  • ?extends Car:必须是Car或者其子类 泛型上线
  • ？super Car：必须是Car或者是器父类 泛型下限

Set集合

  • HashSet
    • LinkedHashSet
  • TreeSet

特点：

  • 无序行：存取的顺序不一致
  • 不重复：可以去重复
  • 无索引：没有带所有的方法

HashSet：无序、不重复、无索引

LinkedHashSet：有序、不重复、无索引

TreeSet：排序、不重复、无索引

//多态
Set<String> s =new HashSet<>();
//使用Collection的API
s.add("JAVA");
s.add("HTML");

HashSet:

采取的是哈希表组成

  • JDK8以前是数组和链表
  • JDK8以后数组+链表+红黑树

哈希值

  • JDK根据对象的地址，按照某种规则算出来的int类型的数值
String name ="我"；
name.hashCode();--------得到哈希值

JDK1.7

  • 先创建一个16长度的数组 ---table
  • 根据元素的哈希值和数组的长度求余数，计算出应存入的位置（哈希算法）
  • 当前位置为null直接存入
  • 如果不为null用equals方法比较
  • 一样则不存，不一样则存入数组
    • JDK7中新元素占用老元素的位置，指向老元素
    • JD8中新元素挂在老元素下面，当长度超过8变为红黑树
  • 每次扩容为原来的2倍

先算hashCode哈希值然后在equals比较。

LinkedHashSet：

底层的机制依然是哈希表，但是每个元素又多了一个双链表的机制记录存储的顺序

  • 有序 不重复 无索引

TreeSet

  • 不重复 无索引 可排序

Tree集合基于红黑树的数据结构实现排序

按照大小排序，string 按照首字符的编号排序

方法一：

//实现Comparable接口
重写里面的compareTo方法实现排序

方法二：

Tree集合有参的构造器，实现对应的Comparable的对应的比较器，来制定比较规则

区分方法

希望元素可以重复，又有索引，索引查找快

  • ArrayList

希望元素可以重复，又有索引，增删首尾

  • LinkedList

如果希望增删改查都很快，但是元素没重复，无序、无索引

  • HashSet

可变参数

  • 可变参数的格式

    数据类型...参数名称

main(String[] args){
    run();
    run(1,2,3,4);
    run(new int[]{10,20,30})
}
public static void run (int... nums){
    //外面看见的是一个参数，实际上是数组
    Arrays.toString(nums);
}
  • 一个形参列表中只能有一个可变参数
  • 可变参数只能在最后

Collections集合工具类

java.util.Collections:是集合的工具类

作用：Collections并不属于集合，是用来操作集合的工具类

常用的api

  • public static boolean addAll(Collection<? super T> c,T... elements) 给集合对象添加元素
  • public static void shuffle（List <?> list) 打乱集合元素的顺序

排序：

  • public static static void sort(List list) 将集合中元素按照默认规则排序
  • public static void sort (List list,Comparator<? superT >c) 将集合中的元素按照指定的规则排序
List<Integer> list =new ArrayList<>();
Collection.addAll(list,23,5,6,4);
Collection.sort(list);
  • 实现ComparaTo接口 实现compare方法

Map集合体系

双列集合体系

key=value（键值对集合）

  • Collection集合格式：[元素1，元素2，元素3]
  • Map集合格式：

Map<K,V>

  • HashMap
    • LinkedHashMap
  • TreeMap
  • HashTable
    • Properties

特点：

  • Map集合的特点都是由键决定的
  • Map的集合的键是无序的，不重复的，无索引的，值可以重复
  • Map集合后面重复的键对应的值会覆盖前面重复的值

实现类的特点：

  • HashMap：元素按照键是无序的、不重复的、无索引的、值不做要求。（与Map体系一样）
  • LinkedHashMap：元素按照键是有序的，不重复的，无索引的，值不做要求
  • TreeMap 元素是按照键是排序的，不重复，无索引的，值不做要求

Map的API

  • V put (key , V value) 添加元素
  • V remove （Object key） 根据键值对删除对应的元素
  • void clear（） 移除所有的键值对
  • Boolean containsKey（Object key）判断集合是否包含指定的键
  • Boolean containsValue（Object value） 判断集合是否包含对应指定的值
  • Boolean isEmpty（） 判断集合是否为空
  • int size（） 集合的长度也就是集合中的键值对的个数
  • V get（Object key） 根据键得到对应的值
  • Set keySet() 获得全部的键的集合
  • Collection values(); 获得全部值的集合
  • putAll（Map a）合并其他的Map集合

遍历Map集合

1.键找值

...
Map<string,Integer> s = new HashMap<>();
....
Set<String> keys =s.keySet();
for(String key:keys){
    int value=s.get(key);
    syso(value);
}

2.键值对流程

先把Map集合转化成Set集合，Set集合中的每个元素都是键值对的实体类型了

遍历Set集合，然后提取键以及提取值

  • Set<Map.Entry<K,V> >entrySet() 获得所有的键值对
  • K getKey（） 获得键
  • K getValue() 获得值
...
Map<string,Integer> s = new HashMap<>();
....
    //把Map集合变成Set集合
    Set<Map.Entry<String,Integer>> entries = s.entrySet();
for(Map.Entry<String,Integer> entry :entries){
    String key =entry.getKey();
    String value =entry.getValue;
}

3.lambda

  • default void forEach(BiConsumer<? super K, ? super V> action) 结合lamdba 遍历
maps.forEach( new BiConsumer<String,Integer>(){
    @Overrride
    public void accept(String key,Integer value){
        syso(key------value)
    }
})

HashnMap

  • 无序、不重复、无索引
  • 底层：哈希表 依赖hashCode和equals来判断键唯一

Set系列集合的底层就是Map实现的，只是Set集合中的元素只要数据，不要键而已

LinkedHashMap

  • 有序、不重复、无索引
  • 底层是：哈希表和双链表

TreeMap

  • 不重复、无索引、可排序
  • TreeMap的底层和TreeSet的底层原理是一样的

自定义排序：

  • 类实现Comparable接口
  • 自定义Comparator比较器对象，重写比较规则

集合嵌套

统计投票人数：

版权声明：本文版权归作者所有,遵循 CC 4.0 BY-SA 许可协议, 转载请注明原文链接
https://www.cnblogs.com/HJZ114152/p/16406704.html