Java容器常用方法

基本类型 ：变量里直接存的是数据本身（值）。

int a = 10; //变量a里直接写着10

引用类型：变量里存的是对象的地址（引用/指针），而不是对象本身。

Person p = new Person();//p里存的是一个类似0x7f...的地址，真正的Person对象在地址0x7f...里。

ArrayList 方法

创建

import java.util.ArrayList; // 引入 ArrayList 类

ArrayList<E> objectName =n ew ArrayList<>();　 // 初始化
//如
ArrayList<Integer> nums = new ArrayList<>();
ArrayList<String> names = new ArrayList<>();

添加、检索、删除------add()、get()、remove()

删除有按索引删除 和按值删除。传入int按索引；传入对象按值。

注意：ArrayList存的是引用类型 ，所以里面存的是地址 ，不是对象本身。举个例子：

当我们nums.add(111)时，首先创建了一个新Integrt对象，值为111，地址为X。ArrayList真正记录的不是Integrt对象，而是地址X。

同理set修改时nums.set(0,100)，首先创建了一个新Integrt对象，值为100，地址为W。ArrayList真正记录的地址由X改为W。

ArrayList<Integer> nums = new ArrayList<>();

//增加
nums.add(111);
nums.add(222);
nums.add(333);
System.out.println(nums); //[111,222,333]

//检索
System.out.println(nums.get(0)); //111
System.out.println(nums.get(1)); //222
System.out.println(nums.get(2)); //333

//删除1------穿如int类型，按下标删除
nums.remove(0); 
System.out.println(nums); //[222,333]
//删除2------传入对象类型，按值删除
nums.remove((Integer)222); 
System.out.println(nums); //[333]

修改------set()

ArrayList<Integer> nums = new ArrayList<>();

//增加
nums.add(111);
nums.add(222);
nums.add(333);
System.out.println(nums); //[111,222,333]

//修改
//nums[0] = 100;  ❌
nums.set(0,100);
System.out.println(nums); //[100,222,333]

长度、判空------size()、isEmpty()

ArrayList<Integer> nums = new ArrayList<>();

//长度和判空
System.out.println(nums.size()); //0
System.out.println(nums.isEmpty()); //true

nums.add(111);

//长度和判空
System.out.println(nums.size()); //1
System.out.println(nums.isEmpty()); //false

切片------subList()

和python一样的左闭右开，即subList(启示索引,截至索引+1)

注意：返回值为**"视图"而非"副本"，和原始列表共享空间**。要用List，因为返回的是一个实现了 List 接口的对象（在 ArrayList 内部，它实际上是一个名为 SubList 的内部类）

视图比浅拷贝还浅。

ArrayList<Integer> nums = new ArrayList<>();

//增加
nums.add(111);
nums.add(222);
nums.add(333);
System.out.println(nums); //[111,222,333]

//截取
System.out.println(nums.subList(1,3)); //[222,333]

//承接1------用List承接试图，此时共享空间
List <Integer> nums2 = nums.subList(1,3);
//承接2------创建独立的副本
ArrayList<Integer> nums3 = new ArrayList<>(nums.subList(1,3));

排序

sort的逻辑递增排序。按自定义规则排序本质上是按自定义规则递增。

自定义排序时，java和C++有本质区别：C++中定义的是a<b的判别器 ；Java中定义的是a-b的减法器。

我们喜欢Collections的sort，封装的那个sort我不喜欢。

ArrayList<Integer> nums = new ArrayList<>();

//增加
nums.add(222);
nums.add(111);
nums.add(-333);
        
//排序------升序(默认)
Collections.sort(nums);
System.out.println(nums); //[-333, 111, 222]
//排序------降序Collections.reverseOrder()
Collections.sort(nums,Collections.reverseOrder());
System.out.println(nums); //[222, 111, -333]
//排序------手写排序规。绝对值排序
Collections.sort(nums,(a,b)->{
    return Math.abs(a)-Math.abs(b);
});
System.out.println(nums); //[111, 222, -333]

拷贝

拷贝的三种类型：

引用拷贝 ：两个不同的引用，指向同一个对象地址。

浅拷贝 ：两个不同的引用，指向不同对象的地址 。但对象内部的引用，指向相同的地址。

深拷贝 ：两个不同的引用，指向完全没有关系的两个对象的地址（对象内部的引用，也指向不同的地址）。

注意：ArrayList存的是引用类型 ，所以里面存的是地址 ，不是对象本身。

所以，浅拷贝ArrayList<Integer> nums3 = new ArrayList<>(nums);虽然创建了新的容器，但是里面存的是同一些地址。

ArrayList<Integer> nums = new ArrayList<>();

Integer a = new Integer(111);
Integer b = new Integer(222);
Integer c = new Integer(333);

//增加;
nums.add(a);
nums.add(b);
nums.add(c);

//引用拷贝(或曰别名)
ArrayList<Integer> nums2 = nums;

//浅拷贝
ArrayList<Integer> nums3 = new ArrayList<>(nums);

//输出nums、nums2、num3指向容器的地址
System.out.println(System.identityHashCode(nums));  //705927765
System.out.println(System.identityHashCode(nums2)); //705927765
													//可得，引用拷贝和原数据用的是同一个容器
System.out.println(System.identityHashCode(nums3)); //366712642
													//可得，浅拷贝新建了一个容器

//输出对象a,b,c的地址
System.out.println(System.identityHashCode(a));	//1829164700
System.out.println(System.identityHashCode(b)); //2018699554
System.out.println(System.identityHashCode(c)); //1311053135

//输出对象原列表指向的对象的地址
System.out.println(System.identityHashCode(nums.get(0))); //1829164700
System.out.println(System.identityHashCode(nums.get(1))); //2018699554
System.out.println(System.identityHashCode(nums.get(2))); //1311053135

//输出对象浅拷贝列表指向的对象的地址。可得两个列表存的是同一些对象的地址
System.out.println(System.identityHashCode(nums3.get(0))); //1829164700
System.out.println(System.identityHashCode(nums3.get(1))); //2018699554
System.out.println(System.identityHashCode(nums3.get(2))); //1311053135

遍历

//普通for循环
for (int i = 0; i<list.size(); i++){
    System.out.println(list.get(i).getName());
}
//增强型 For 循环
for (Person p : list) {//p是引用拷贝，即p指向和list元素的指向相同
    System.out.println(p.getName());
}
//迭代器
Iterator<Person> it = list.iterator();//获取迭代器
while (it.hasNext()) {
    Person p = it.next();
}

方法	描述
常用
add()	将元素插入到指定位置的 arraylist 中
get()	通过索引值获取 arraylist 中的元素
set()	替换 arraylist 中指定索引的元素。set(下标,新值)
remove()	删除 arraylist 里的单个元素。remove((int)下标) 或 remove((对象)值)
size()	返回 arraylist 里元素数量
isEmpty()	判断 arraylist 是否为空
subList()	截取部分 arraylist 的元素，返回视图，共享同一个容器。
clear()	删除 arraylist 中的所有元素
toArray()	将 arraylist 转换为数组

集合

import java.util.HashSet; // 引入 HashSet 类

HashSet<String> sites = new HashSet<String>();

方法	说明
add(Object e)	添加元素到集合，成功返回 true，重复元素返回 false。
remove(Object o)	删除指定元素，成功返回 true，元素不存在返回 false。
contains(Object o)	检查集合是否包含指定元素。
size()	返回集合中的元素数量。
isEmpty()	判断集合是否为空。
clear()	清空集合中的所有元素。
toArray()	将集合转换为数组。
addAll(Collection<? extends E> c)	添加另一个集合的所有元素（并集操作）。
retainAll(Collection<?> c)	仅保留与指定集合共有的元素（交集操作）。
removeAll(Collection<?> c)	删除与指定集合共有的元素（差集操作）。

Map

方法	功能	返回值	补充
put(K key, V value)	放入键值对。若 Key 已存在，则覆盖旧值。	返回旧值 (若无则 null)	最基础的添加/更新操作。
get(Object key)	根据 Key 获取 Value。	返回 Value (若无则 null)	查询数据。
getOrDefault(key,0)	根据 Key 获取 Value，没有返回默认值。	自定义默认值	查询数据。
remove(Object key)	删除指定 Key 的映射。	返回被删除的 Value (若无则 null)	删除数据。
containsKey(Object key)	判断是否包含某个 Key。	boolean	检查 Key 是否存在 (比 get()!=null 更严谨，因为 Value 可能为 null)。
containsValue(Object value)	判断是否包含某个 Value。	boolean	检查 Value 是否存在 (性能较差，需遍历)。
size()	获取键值对数量。	int	获取大小。
isEmpty()	判断是否为空。	boolean	快速判空。
clear()	清空所有元素。	void	重置 Map。

Deque队列

LinkedList<Integer> L = new LinkedList<>();
for(int i = 0; i<5; i++)
    L.add(i);//队尾，入队
for(int i = 5; i<10; i++)
    L.push(i);//队头，入栈


LinkedList<Integer> L2 = new LinkedList<>(L);
for(int i = 0; i<10; i++)
    System.out.print(L.get(i));// 9876501234
System.out.println();
for(int i = 0; i<10; i++)
    System.out.print(L.poll());// 9876501234
System.out.println();
for(int i = 0; i<10; i++)
    System.out.print(L2.pop());// 9876501234

Deque<Integer> L = new ArrayDeque<>();
for(int i = 0; i<5; i++)
    L.add(i);//队尾，入队
for(int i = 5; i<10; i++)
    L.push(i);//队头，入栈

Deque<Integer> L2 = new ArrayDeque<>(L);
for (Integer element : L2) {
    System.out.print(element);// 9876501234
}
System.out.println();

//poll和pop一样，都是取第一个。
for(int i = 0; i<10; i++)
    System.out.print(L.poll());// 9876501234
System.out.println();
for(int i = 0; i<10; i++)
    System.out.print(L2.pop());// 9876501234