首页 JavaSE

# 数据结构

# 栈

  1. 压栈 / 弹栈
  2. 栈顶元素、栈底元素
  3. 先进后出

# 队列

  1. 入队列 / 出队列
  2. 前端、后端
  3. 先进先出

# 数组

查询效率高，增删效率低

# 链表

查询效率低（必须从头开始查找，增删效率高）

# 哈希表

  1. 比较方法
  2. 哈希值
  3. equals
  4. 结构：数组 + 链表
  5. 元素位置："hashCode % 位置"
  6. 相同位置的元素通过链表形式连接

# 集合体系结构

  1. Collection：单列
    1. List：可重复
      1. ArrayList
      2. LinkedList
    2. Set：不可重复
      1. HashSet
      2. TreeSet
  2. Map：双列
    1. HashMap

# Collection

# 概述

单列集合的顶层接口，无法直接实现

# 创建对象

多态：利用 ArrayList

Collection<String> c = new ArrayList<String>();

# 成员方法

# add() 方法

boolean add(E e)		// 永远返回 true，重写 toString () 方法

# remove() 方法

boolean remove(Object o)	// 移除某个元素

# clear() 方法

void clear()			// 清空集合

# contains() 方法

boolean contains(Object o)	// 判断是否存在元素

# isEmpty() 方法

boolean isEmpty()		// 判断是否为空

# size() 方法

int size()			// 返回集合中元素个数

# 快捷键补充

alt + 7 ：查看结构框架

# 迭代器 Iterator

# 概述

  1. Iterator：迭代器用于集合遍历
  2. Iterator<E> iterator(); ：返回集合元素的迭代器
  3. 迭代器依赖于集合存在

# 常用方法

  1. E next() ：返回迭代器下一个元素
  2. boolean hasNext() ：是否存在下一个元素
while(it.hasNext()) {
    String s = it.next();
    System.out.println(s);
}

# List 集合及其子类

# List

List：有序集合，可以控制每个元素的插入位置

# List 特有方法

# add (index, e)：指定插入

void add(int index, E e)

# remove (index)：指定索引删除

E remove(int index)		// 返回老元素

# set (index,e)：指定修改

E set(int index, E e)	// 返回老元素

# get (index)：指定获取

E get(int index)		// 返回索引获取的元素

# ListIterator

# 概述

ListIterator：列表迭代器，是 List 集合特有的

# 特点

  1. 可以任意方向遍历
  2. 可以迭代时修改元素

# 方法

  1. E previous() ：返回迭代器上一元素
  2. boolean haoPrevious() ：是否存在上一元素
  3. void add(E e) ：插入指定元素
List<String> list = new ArrayList<String>();
ListIterator<String> it = list.listiterator();
while(it.hasNext()) {
    String s = it.next();
    if(s.equals("world")) {
        it.add("javase");
    }
}

# ArrayList

数组实现：查询快，增删慢

# LinkedList

# 概述

链表实现：查询慢，增删快

# 特有功能

  1. void addFirst()
  2. void addLast()
  3. E getFirst()
  4. E getLast()
  5. E removeFirst()
  6. E removeLast()

# 并发修改异常

# 异常原因

遍历时修改了集合元素长度

List<String> list = new ArrayList<String>();
Iterator<String> it = list.iterator();
while(it.hasNext()) {
    String s = it.next();
    if(s.equals("java")) {
        list.add("javaEE");
    }
}

# 修改方法

# 不用迭代器，用 for 循环索引元素

List<String> list = new ArrayList<String>();
for (int i = 0; i < list.size(); i++) {
    String s = list.get(i);
    if(s.equals("world")) {
        list.add("JavaEE");
    }
}

# 用列表迭代器添加元素

List<String> list = new ArrayList<String>();
ListIterator<String> it = list.listiterator();
while (it.hasNext()) {
    String s = it.next();
    if(s.equals("world")){
        it.add("JavaEE");
    }
}

# 增强 for

  1. 增强 for 循环：简化数组和 Collection 集合的遍历
  2. 实现 Iterator 接口的类允许其对象称为增强型 for 循环的目标
  3. 原理是 Iterator 迭代器 -> 会触发 "并发修改异常"
int[] arr = {1,2,3,4,5};
for(int i : arr) {
    System.out.println(i);
}

# Set 及其子类

# Set

  1. 不包含重复元素
  2. 没有索引、不能用普通 for 循环遍历
  3. 迭代顺序随机

# HashSet

# 哈希值

  1. 根据对象的地址 / 字符串 / 数字算出来的 int 类型的数值
  2. public int hashCode
    1. 返回对象的哈希值
    2. Object 类

# HashSet 概述

  1. 底层为哈希表 (HashMap)
  2. 迭代顺序无保证
  3. 没有索引，不能用 for 循环遍历
  4. Set 集合没有重复元素 -> 需要重写对象的 hashCode 与 equals 方法

# HashSet 存储特点

  1. 比较方法
    1. 哈希值
    2. equals
  2. 结构：数组 + 链表
    1. 元素位置："hashCode % 位置"
    2. 相同位置的元素通过链表形式连接

# LinkedHashSet

  1. 底层：链表 + 哈希表
  2. 可预测的迭代次序
  3. HashSet 集合没有重复元素

# TreeSet

  1. 元素有序
  2. 自然排序：无参构造 TreeSet()
  3. 比较器排序：带参构造 TreeSet(Comparator comparator)
  4. 存储引用类 / 包装类类型

自然排序 -> 重写 compareTo 方法

@Override
public int compareTo(Student s){
    return this.age - s.age == 0 ? this.name.compareTo(s.name) : this.age - s.age;
}

比较器排序 -> 匿名内部类

TreeSet<Studen> ts = new TreeSet<>(new Comparator<Student>(){
    @Override
    public int compare(Student s1, Student s2){
        return s1.getAge() - s2.getAge() == 0 ? s1.getName().compareTo(s2.getName()) : s1.getAge() - s2.getAge();
    }
})

# 泛型

# 泛型概述

  1. 将类型由原来的具体的类型参数化，然后在使用 / 调用时传入的具体的类型
  2. 本质：参数化类型
  3. 实参类型只能是引用数据类型
  4. 泛型定义格式
  5. <类型>
  6. <类型 1，类型 2...>

# 泛型类定义格式

  1. 修饰符 class 类名<类型>{...}
  2. 类型可以是随便写的任意标识
    1. T：type
    2. E：element
    3. K：key
    4. V：value

# 泛型方法

  1. 泛型方法 -> 不限制类型
  2. 泛型方法定义格式： 修饰符 <类型> 返回值类型 方法名(类型 变量名){...}

# 泛型接口

修饰符 interface 接口名<类型>{...}

# 类型通配符

  1. 类型通配符： <?>
  2. 标识各种泛类 List 的父类
  3. 元素可以匹配任何类型
  4. 不能添加元素
  5. 类型通配符的上限： <? extends 类型>

# 可变参数

# 可以参数定义格式

修饰符 返回值类型 方法名(数据类型...变量名){}

public static int sum(int...a){
    int sum = 0;
    for(int i : a){
        sum += i;
    }
    return sum;
}

# 特点

  1. 变量其实是数组
  2. 多个参数要把可变参数放到最后

# 可变参数的应用

# Arrays 工具类的静态方法

// 定义
public static <T> List<T> asList(T...a)
// 使用
List<String> list = Arrays.asList("baozi","bjh");

返回有指定数组支持的固定大小的列表 -> 不能增删可以改

# List 接口的静态方法

// 定义
public static <E> List<E> of(E...elements);
// 使用
List<String> list = List.of("baozi","baobao");

返回包含任意数量元素的不可变列表 -> 不能增删改

# Set 接口的静态方法

// 定义
public static <E> Set<E> of(E...elements);
// 使用
Set<String> s = Set.of("baozi","baobao");

返回一个包含任意数量元素的不可变集合 -> 不能增删改

# Map

# 概述

Interface Map<K,V>

  1. K：键 V：值
  2. 将 key 映射到 value 的对象
  3. key 不可以重复 && 每个 key 只对应一个 value

# 创建 Map 集合的方式

多态

# 具体实现类：HashMap

  1. 添加元素： V put(K key, V value)
  2. 删除： V remove(Object key)
  3. 清空： void clear()
  4. 判断键是否存在： boolean containsKey(Object key)
  5. 判断值是否存在： boolean containsValue(Object value)
  6. 判断是否为空： boolean isEmpty()
  7. 返回集合长度： int size()
  8. Map 的获取方法
// 根据键获取值
// V get(Object key)
Map<String,String> map = new Map<>();
map.put("1","baozi");
System.out.println(map.get("1"));
// 获取所有键的集合
// Set<K> keySet()
Set<String> keySet = map.keySet();
for(String key : keySet){
    System.out.println(key);
}
// 获取所有值的集合
// Collection<V> values()
Collection<String> values = map.values();
for(String value : values){
    System.out.println(value);
}
// 获取所有键值对对象的集合
// Set<Map.Entry<K,V>> entrySet()
Set<Map.Entry<String,String>> entrySet = map.entrySet();
for(Map.Entry<String,String> me : entrySet){
    System.out.println(me.getKey() + "," + me.getValue());
}
// Map 集合遍历
// 方式 1
Set<String> keySet = map.keySet();
for(String key : keySet){
    System.out.println(key + "," + map.get(key));
}
// 方式 2
Set<Map.Entry<String,String>> entrySet = map.entrySet();
for(Map.Entry<String,String> me : entrySet){
    System.out.println(me.getKey() + "1" + me.getValue());
}

# Collections 工具类

常用方法（类要重写 compareTo 方法）

# 列表升序排列

// 定义
public static <T extends Comparable<? superT>> void sort(List<T> list);
// 使用：普通集合
Collections.sort(list);
// 使用：类的集合 --> 比较器排序 --> 匿名内部类 / 类内重写
ArrayList<Student> array = new ArrayList<>();
Collection.sort(array,new Comparator<Student>(){
    @Override
    public int compare(Student s1,Student s2){
        return s1.getAge() - s2.getAge() == 0 ? s1.getName().compareTo(s2.getName()) : s1.getAge() - s2.getAge();
    }
});

# 反转列表顺序

// 定义
public static void reverse(List<?> list);
// 使用
Collection.reverse(list);

# 列表随机排列

// 定义
public static void shuffle(List<?> list);
// 使用
Collection.shuffle(list);
更新于 阅读次数 次

请我喝[茶]~(￣▽￣)~*

Baozi 微信支付

微信支付

Baozi 支付宝

支付宝

Baozi 微信

微信