《java学习笔记》之集合概述

• */

arrayList.add(“D”);

arrayList.add(“C”);

arrayList.add(“B”);

arrayList.add(“A”);

System.out.println(arrayList.indexOf(“A”));//0

System.out.println(arrayList.indexOf(“F”));//-1

System.out.println(arrayList.lastIndexOf(“A”));//7

System.out.println(arrayList.lastIndexOf(“F”));//-1

//Object remove(int index) 移除列表中指定位置的元素（可选操作）

arrayList.remove(0);

//Collection 还有remove(Object o)方法，删除元素

System.out.println(arrayList.get(0));//B A被删除了

//Object set(int index, E element) 用指定元素替换列表中指定位置的元素（可选操作）。

for (Object o : arrayList){

System.out.print(o + " ");//B C D D C B A

}

arrayList.set(0,“A”);

System.out.println();

for (Object o : arrayList){

System.out.print(o + " ");//A C D D C B A

}

}

}

五.ArrayList集合

public class ArrayListTest01 {

public static void main(String[] args) {

//构造方法

//默认容量是10

ArrayList arrayList1 =new ArrayList();

指定初始化容量

ArrayList arrayList2 =new ArrayList(100);

//public ArrayList(Collection c)

// 构造一个包含指定 collection 的元素的列表

// 这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

//创建一个HashSet集合

Collection hashSet= new HashSet();

hashSet.add(1);

hashSet.add(2);

hashSet.add(3);

ArrayList arrayList =new ArrayList(hashSet);

//遍历

for (int i = 0; i <arrayList.size() ; i++) {

System.out.print(arrayList.get(i) + " ");//1 2 3

}

}

}

六.LinkedList集合

6.1 模拟单向链表

//模拟单链表

//链表的基本单元的Node

//对于单向链表来说：Node中存储了当前节点的数据，以及下一节点的内存地址

public class Node {

//存储的数据

Object element;

//下一节点的内存地址

Node next;

//构造方法

public Node() {

}

public Node(Object element, Node next) {

this.element = element;

this.next = next;

}

}

//单向链表类

public class Link {

//头节点

Node heard = null;

//size

int size = 0;

public int size(){

return this.size;

}

//向链表末尾中添加元素

public void add(Object o){

//判断是否是头文件

if (heard == null){

heard = new Node(o,null);

}else{

//头不是空

//找出当时的末尾节点

Node currentNode = findCurrentNode(heard);

currentNode = new Node(o,null);

}

size ++;

}

/**

• @param node 起始节点

• @return 末尾节点

*/

public Node findCurrentNode(Node node) {

//递归

if (node.next == null){

return node;

}else {

return findCurrentNode(node.next);

}

}

}

public class LinkTest {

public static void main(String[] args) {

Link myLink = new Link();

myLink.add(1);

myLink.add(2);

myLink.add(3);

myLink.add(4);

myLink.add(5);

//元素个数

System.out.println(myLink.size);

}

}

6.2 LinkedList

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

/*

• 链表的优点：

• 由于链表上的元素在空间上的内存地址不连续

• 因为随机增删的时候不会有大量的元素位移，因此随机增删效率较高

• 在以后的开发中，如果遇到随机增删集合中的元素业务较多时，建议使用LinkedList

• */

public class LinkedListTest {

public static void main(String[] args) {

//创建一个LinkedList对象

List linkedList= new LinkedList();

//添加元素

linkedList.add(1);

linkedList.add(2);

linkedList.add(3);

linkedList.add(4);

linkedList.add(5);

//遍历

//for each

for(Object o:linkedList){

System.out.print(o + " ");

}

System.out.println();

//迭代器迭代

Iterator iterator = linkedList.iterator();

while(iterator.hasNext()){

System.out.print(iterator.next() + " ");

}

System.out.println();

LinkedList集合底层也是有下标的

//注意：ArrayList之所以检索效率高，不单是因为有下标，主要是底层是数组的原因

//LikedList集合照样有下标，但是检索/查找效率某个元素效率比较低，因为只能从头节点开始一个一个遍历

//下标循环

for (int i = 0; i <linkedList.size() ; i++) {

System.out.print(linkedList.get(i) + " ");

}

//LinkedList集合有初始化吗？没有

//最初这个链表中没有任何元素，first和last引用都是null

//不管是LikedList还是ArrayList，以后写代码不需要关系具体是哪个

//因为我们要面向接口编程，调用的方法都是接口中的方法

//List list2 = new ArrayList();//这样写表示调用了数组

List list2 = new LinkedList();//这样写表示底层调用了双向链表

list2.add(“123”);

list2.add(“456”);

list2.add(“789”);

for (int i = 0; i < list2.size(); i++) {

System.out.println(list2.get(i));

}

}

}

七.Vector集合

import java.util.*;

/*

• Vector:

• 1.底层也是一个数组

• 2.初始化容量：10

• 3.扩容之后是原来的二倍

• ArrayList是原来的1.5倍
  

• 4.Vector的方法都带 synchronized 关键字，线程安全，效率较低

• 6.怎么将一个线程不安全的ArrayList转换成线程安全的Vector？

•   使用集合工具类：
  

•       Java.util.Collections
  

•       java.util.Collection是集合接口
  

•       java.util.Collections是集合工具类
  

• */

public class VectorTest{

public static void main(String[] args) {

//多态

Collection vector= new Vector();

//添加元素

vector.add(1);

vector.add(2);

vector.add(3);

vector.add(4);

vector.add(5);

//遍历/迭代

Iterator iterator =vector.iterator();

while(iterator.hasNext()){

System.out.print(iterator.next() + " ");

}

//Vector 是线程安全的

//ArrayList不是线程安全的

//怎么将ArrayList变成线程安全的呢？

List arrayList = new ArrayList();

//集合工具类

Collections.synchronizedList(arrayList);

//现在 arrayList 是线程安全的了

}

}

八.Set接口

import java.util.HashSet;

import java.util.Set;

public class SetTest {

public static void main(String[] args) {

//Set是Collection的子接口，不能new set对象

//‘Set’ is abstract; cannot be instantiated

//Set set =new Set();

Set hashSet= new HashSet();

}

}

九.HashSet集合

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

/*

• HashSet集合：

• 无序不可重复

• */

public class HashSetTest {

public static void main(String[] args) {

Set hashSet = new HashSet<>();

hashSet.add(3);

hashSet.add(1);

hashSet.add(2);

hashSet.add(5);

hashSet.add(8);

hashSet.add(4);

hashSet.add(3);

hashSet.add(1);

hashSet.add(3);

//遍历

Iterator iterator= hashSet.iterator();

while(iterator.hasNext()){

System.out.print(iterator.next() + " " );

}

}

}

十.TreeSet集合

10.1 TreeSet集合的基础语法

import java.util.Iterator;

import java.util.Set;

import java.util.TreeSet;

/*

• TreeSet集合存储元素特点：

• 1.无序不可重复，但是存储的元素可以自动按照大小排序

• 称为：可排序集合

• 2.无序：这里的无序是指存进去的顺序和取出来的顺序不同，且没有下标

• 3.TreeSet底层实际上是一个TreeMap

• 4.TreeMap底层是一个二叉树

• 5.放到TreeSet集合里的元素，等同于放到TreeMap集合的key里面

• 6.TreeSet集合中的元素：无序不可重复，但是按着元素的大小排序

• 称为：可排序集合*/

public class TreeSetTest01 {

public static void main(String[] args) {

Set treeSet= new TreeSet<>();

treeSet.add(10);

treeSet.add(5);

treeSet.add(20);

treeSet.add(1);

//迭代

Iterator iterator =treeSet.iterator();

while(iterator.hasNext()){

System.out.print(iterator.next() + " ");//1 5 10 20 排序了

}

System.out.println();

treeSet.clear();

treeSet.add(“A”);

treeSet.add(“Z”);

treeSet.add(“B”);

treeSet.add(“F”);

treeSet.add(“D”);

treeSet.add(“H”);

for (Object o :treeSet){

System.out.print(o + " ");//A B D F H Z 小到大的排序

}

}

}

10.2 自定义类在TreeSet里怎么排序

第一种方法：

`import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

public class TreeSetTest03 {

public static void main(String[] args) {

//创建顾客对象

Customer customer1 =new Customer(1);

Customer customer2 =new Customer(2);

Customer customer3 =new Customer(3);

Customer customer4 =new Customer(4);

Customer customer5 =new Customer(5);

//创建TreeSet对象

TreeSet treeSet =new TreeSet<>();

//添加元素

treeSet.add(customer1);

treeSet.add(customer2);

treeSet.add(customer3);

treeSet.add(customer4);

treeSet.add(customer5);

//迭代

Iterator iterator = treeSet.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

/*Customer{age=1}

Customer{age=2}

Customer{age=3}

Customer{age=4}

Customer{age=5}

*/

}

}

//放在TreeSet集合中的元素要实现java.lang.Comparable接口

//并且实现compareTo方法，equals可以不重写

//这里要泛型，要不然下面会报错

class Customer implements Comparable{

int age;

public Customer(){

}

public Customer(int age){

this.age = age;

}

//需要在这个方法中编写比较的逻辑

//k.compareTo(t.key)

//拿着参数k和集合的每一个key比较，返回值可能是大于零，可能是小于零，可能是等于零

//比较规则还是由程序员来定

@Override

public int compareTo(Customer c) {

/*if (this.age == c.age){

return 0;

}else if (this.age >c.age){

return 1;

}else if (this.age < c.age){

return 1;

}*/

return this.age -c.age;

}

//重写toString方法

@Override

public String toString() {

return “Customer{” +

“age=” + age +

‘}’;

}

}

`

import java.util.TreeSet;

public class TreeSetTest04 {

public static void main(String[] args) {

//创建Vip对象

Vip vip1 =new Vip(10,“A”);

Vip vip2 =new Vip(20,“A”);

Vip vip3 =new Vip(10,“Z”);

Vip vip4 =new Vip(30,“Z”);

Vip vip5 =new Vip(15,“D”);

//创建集合对象

TreeSet treeSet =new TreeSet<>();

//添加元素

treeSet.add(vip1);

treeSet.add(vip2);

treeSet.add(vip3);

treeSet.add(vip4);

treeSet.add(vip5);

//遍历

for (Vip vip : treeSet){

System.out.println(vip);

}

/*Vip{age=10, name=‘A’}

Vip{age=10, name=‘Z’}

Vip{age=15, name=‘D’}

Vip{age=20, name=‘A’}

Vip{age=30, name=‘Z’}

*/

}

}

//先按照年龄升序，如果年龄一样在按着姓名升序

class Vip implements Comparable{

private int age;

private String name;

//构造方法

public Vip() {

}

public Vip(int age, String name) {

this.age = age;

this.name = name;

}

//实现 compareTo 方法

@Override

public int compareTo(Vip o) {

if (this.age == o.age){

//String类实现了 compareTo 方法

return this.name.compareTo(o.name);

}else {

return this.age - o.age;

}

}

@Override

public String toString() {

return “Vip{” +

“age=” + age +

“, name='” + name + ‘’’ +

‘}’;

}

}

第二种方法：

import java.util.Comparator;

import java.util.TreeSet;

//TreeSet集合元素可排序的第二种方式：使用比较器的方式

/*放到TreeSet或者TreeMap集合key部分的元素想要做到排序，有两种方式：

•   第一种：放在集合中的元素实现 java.lang.Comparable接口
  

•   第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。
  

• Comparable和Comparator怎么选择？

• 如果比较规则一直不变的话，或者比较规则只有一个：Comparable

• 如果比较规则经常改变的话，或者比较规则有多个 ：Comparator*/

public class TreeSetTest05 {

public static void main(String[] args) {

//给构造方法传一个比较器

//TreeSet testTreeSet = new TreeSet<>(new AnimalTestComparator());

//或者用匿名内部类

TreeSet testTreeSet = new TreeSet<>(new Comparator() {

@Override

public int compare(AnimalTest o1, AnimalTest o2) {

return o1.getNo() - o2.getNo();

}

});

//创建AnimalTest对象

AnimalTest animalTest1 =new AnimalTest(10);

AnimalTest animalTest2 =new AnimalTest(5);

AnimalTest animalTest3 =new AnimalTest(15);

AnimalTest animalTest4 =new AnimalTest(1);

AnimalTest animalTest5 =new AnimalTest(20);

//添加元素

testTreeSet.add(animalTest1);

testTreeSet.add(animalTest2);

testTreeSet.add(animalTest3);

testTreeSet.add(animalTest4);

testTreeSet.add(animalTest5);

for (AnimalTest a:testTreeSet){

System.out.println(a);

}

/*AnimalTest{no=1}

AnimalTest{no=5}

AnimalTest{no=10}

AnimalTest{no=15}

AnimalTest{no=20}

*/

}

}

class AnimalTest{

private int no;

public AnimalTest() {

}

public AnimalTest(int no) {

this.no = no;

}

public int getNo() {

return no;

}

public void setNo(int no) {

this.no = no;

}

@Override

public String toString() {

return “AnimalTest{” +

“no=” + no +

‘}’;

}

}

/*

//单独编写一个比较器

//比较器实现java.util.Comparator接口。(Comparable是java.lang包下的)

class AnimalTestComparator implements Comparator{

@Override

//比较方法

public int compare(AnimalTest o1, AnimalTest o2) {

return o1.getNo() - o2.getNo();

}

}*/

十一.Map接口

11.1 Map集合的常用方法

/*

• java.util.Map接口中常用的方法：

• 1.Map和Collection没有继承关系

• 2.Map集合以key和value的方式存储数据：键值对

•   key和value都是引用数据类型
  

•   key和value都是存储对象的内存地址
  

•   key起主导作用，value是key的一个附属品
  

• 3.Map集合中常用方法

V put(K key, V value) 向Map集合中添加键值对

V get(Object key) 通过key获取value

void clear() 清空Map集合

boolean containsKey(Object key) 判断Map集合中是否包含某个key

boolean containsValue(Object value) 判断Map集合中是否包含某个Value

boolean isEmpty() 判断Map结合中的元素个数是否为零

Set keySet() 获取Map集合中所有的key（所有的键是一个set集合）

V remove(Object key) 通过key删除Value

int size() 获取Map集合中键值对的个数

Collection values() 获取Map集合中所有的value，返回一个Collection

Set<Map.Entry<K,V>> entrySet() 将Map集合转化成Set集合

*/

public class MapTest01 {

public static void main(String[] args) {

//Map 也是一个接口

//‘Map’ is abstract; cannot be instantiated

//Map map =new Map();

//泛型，创建集合对象

Map<Integer,String> hashMap= new HashMap<>();

//向集合中添加元素

//V put(K key, V value) 向Map集合中添加键值对

hashMap.put(1,“钢铁侠”);//1 在这自动装箱了

hashMap.put(2,“雷神”);

hashMap.put(3,“美队”);

hashMap.put(4,“绿巨人”);

//boolean containsKey(Object key) 判断Map集合中是否包含某个key

System.out.println(hashMap.containsKey(1));//true

System.out.println(hashMap.containsKey(10));//false

//boolean containsValue(Object value) 判断Map集合中是否包含某个Value

System.out.println(hashMap.containsValue(“钢铁侠”));//true

System.out.println(hashMap.containsValue(“蜘蛛侠”));//false

//Set keySet() 获取Map集合中所有的key（所有的键是一个set集合）

Set set = hashMap.keySet();

System.out.println(set.size());//4

//遍历这个set集合

for (Object o : set) {

System.out.println(set);

/*[1, 2, 3, 4]

[1, 2, 3, 4]

[1, 2, 3, 4]

[1, 2, 3, 4]

*/

}

//Collection values() 获取Map集合中所有的value，返回一个Collection

Collection c = hashMap.values();

//遍历集合

Iterator iterator =c.iterator();

while (iterator.hasNext()){

System.out.println(iterator.next());

}

/*钢铁侠

雷神

美队

绿巨人

*/

//Set<Map.Entry<K,V>> entrySet() 将Map集合转化成Set集合

Set set1 = hashMap.entrySet();

System.out.println(set.size());//4

//遍历这个set集合

for (Object o : set) {

System.out.println(set1);

}

/*[1=钢铁侠, 2=雷神, 3=美队, 4=绿巨人]

[1=钢铁侠, 2=雷神, 3=美队, 4=绿巨人]

[1=钢铁侠, 2=雷神, 3=美队, 4=绿巨人]

[1=钢铁侠, 2=雷神, 3=美队, 4=绿巨人]

*/

// V get(Object key) 通过key获取value

System.out.println(hashMap.get(1));//钢铁侠

System.out.println(hashMap.get(2));//雷神

//int size() 获取Map集合中键值对的个数

System.out.println(hashMap.size());//4

//V remove(Object key) 通过key删除Value

hashMap.remove(1);

System.out.println(hashMap.size());//3

System.out.println(hashMap.containsKey(1));//false

//boolean isEmpty() 判断Map结合中的元素个数是否为零

System.out.println(hashMap.isEmpty());//false

//void clear() 清空Map集合

hashMap.clear();

System.out.println(hashMap.isEmpty());//true

}

}

11.2 Map集合的遍历

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

/*

Map集合的遍历(非常重要)

*/

public class MapTest02 {

public static void main(String[] args) {

Map<Integer,String> hashMap = new HashMap<>();

hashMap.put(1,“钢铁侠”);//1 在这自动装箱了

hashMap.put(2,“雷神”);

hashMap.put(3,“美队”);

hashMap.put(4,“绿巨人”);

//第一种方式：获取所有的key，遍历key，来遍历所有的value

//先获取所有的key，所有的key是一个Set集合

Set hashSet= hashMap.keySet();

//可以用迭代器

Iterator iterator = hashSet.iterator();

while(iterator.hasNext()){

Object o = iterator.next();

String s =hashMap.get(o);

System.out.println(s);

}

System.out.println(“================================”);

//还可以用for each 循环

for(Object o : hashSet){

System.out.println(hashMap.get(o));

}

System.out.println(“================================”);

//第二种方式

//Set<Map.Entry<K,V>> entrySet() 将Map集合转化成Set集合

//Set集合中元素的类型是： Map.Entry

Set<Map.Entry<Integer,String>> set = hashMap.entrySet();

//遍历Set集合,每一次取出一个Node

//可以用迭代器迭代

Iterator<Map.Entry<Integer,String>> iterator1 = set.iterator();

while(iterator1.hasNext()){

Map.Entry<Integer,String> entry = iterator1.next();

Integer key = entry.getKey();

String value = entry.getValue();

System.out.println(key + " = " + value);

}

System.out.println(“================================”);

for (Map.Entry<Integer,String> node : set){

System.out.println(node.getKey() + " = " + node.getValue());

}

}

}

十二.HashMap集合

12.1 HashMap中get和put方法

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

/*

• HashMap集合：

• 1.HashMap集合底层是哈希表/散列表的数据结构

• 2.哈希表是一个数组和单向链表的结合体

•   数组：在查询方面效率很高
  

•   单向链表：在随机增删方面效率很高
  

•   哈希表将以上两种数据结构融合在一起了，充分发挥了他们各自的优点
  

• 3.HashMap底层代码：

•   public class HashMap{
  

•           //HashMap底层实际上是一个数组（一维数组）
  

•           transient Node<K,V>[] table;
  

•          //静态内部类HashMap.Node
  

•          static class Node<K,V> implements Map.Entry<K,V>{
  

final int hash;//哈希值（哈希值是key的hashCode()方法执行的结果，hash值通过哈希函数/算法，可以转化成数组的数组的下标）

final K key; //Map集合的key

V value; //Map集合的value

Node<K,V> next;//下一个节点的内存地址

• }

•  哈希表/散列表：一维数组，这个数组里面的每一个元素是一个单向列表（数组和链表的结合体）
  

•  4.最主要掌握：
  

•      map.put(key,value)
  

•      value = map.get(k)
  

•      这两个方法的原理
  

•   5.HashMap集合的key部分特点：
  

•       无序不可重复
  

•       无序？ 因为不一定挂在哪个单向链上
  

•       不可重复？equals方法来保证HasMap集合的key不可重复
  

•       如归key重复了，value会被覆盖
  

•               放在HashSet的元素实际上是放到了HashMap的集合key部分中了
  

•                   所以HashSet也要重写equals和HashCode
  

•   6.HashMap使用不当时无法发挥性能
  

•       假设将所有的HashCode()方法返回固定值，那么就会导致底层哈希表变成纯单向链表
  

•           称为   散列分布不均匀
  

• •       假设将所有的HashCode()方法返回不同值，那么就会导致底层哈希表变成一维数组
    

也是 散列分布不均匀

散列分布均匀 需要重写HashCode()有技巧

7.重点：

放在HashMap集合中key部分的元素，以及放在HashSet中的元素，需要重写HashCode和equal方法

8.HashMap集合的默认容量是16，默认加载因子是0.75

•     这个默认加载因子是当HashSet集合底层数组容量达到75%时开始扩容
  

• 重点：HashMap集合初始化容量必须是2的倍数，这是官方推荐的

• 这是因为达到散列分布均匀，为了提高HashMap集合的存取效率所必须的
  

*/

public class HashMapTest01 {

public static void main(String[] args) {

//测试HashMap集合key部分元素特点

//Integer是key，它的HashCode和equals方法都已经重写了

Map<Integer,String> hashMap= new HashMap<>();

hashMap.put(1,“钢铁侠”);//1 在这自动装箱了

hashMap.put(2,“雷神”);

hashMap.put(3,“美队”);

hashMap.put(3,“绿巨人”);

System.out.println(hashMap.size());//3

//遍历

Set<Map.Entry<Integer,String>> set = hashMap.entrySet();

Iterator<Map.Entry<Integer,String>> iterator = set.iterator();

while(iterator.hasNext()){

Map.Entry<Integer,String> entry = iterator.next();

System.out.println(entry.getKey() + " = " + entry.getValue());

}

//可知，原来的美队被覆盖了

/*1 = 钢铁侠

2 = 雷神

3 = 绿巨人

*/

}

}

12.2 自定义类在HashMap中get和put

import java.util.HashMap;

import java.util.HashSet;

import java.util.Objects;

/*1. 向Map集合中 存和取 都是先调用key的HashCode方法，然后再调用equals方法

• equals方法可能调用，可能不调用

• 拿put(k,v)举例，什么时候不调用equals

•   k.HashCode()方法返回哈希值，
  

•       哈希值是经过哈希算法得出数组下标
  

•       数组下标位置上如果是null，就不会调用equals
  

• 拿get(k)举例，什么时候不调用equals

•   哈希值是经过哈希算法得出数组下标
  

•       数组下标位置上如果是null，就不会调用equals
  

• 2. 注意：如果一个类的equals方法重写了，那么hashCode()必须重写

• 并且equals方法返回如果是true，呢么hashcode返回值必须一样

• equals方法返回true表示两个对象相同，在同一个单向链表上

• 对于同一个单向链表的节点来说，他们的哈希值都相同

• 使用hashCode的返回值也要是true

• 3.hashCode和equals直接用idea生成

*结论：

• 放在HashMap集合key部分和HashSet集合中的元素，要同时重写hashCode和equals方法

• */

public class HashMapTest02 {

public static void main(String[] args) {

People people1 =new People(“钢铁侠”,123);

People people2 =new People(“钢铁侠”,123);

//重写equals方法和hashCode方法之前

System.out.println(people1.equals(people2));//false

System.out.println(people1.hashCode());//1809787067

System.out.println(people2.hashCode());//1802598046

//重写equals，没重写hashCode

System.out.println(people1.equals(people2));//true

//HashSet存储在HashMap的key部分

HashSet hashSet = new HashSet<>();

hashSet.add(people1);

hashSet.add(people2);

//按理来说，这两个对象equals返回true，应该是重复了，而HashSet集合无序不可重复

//应该只有一个元素

System.out.println(hashSet.size());//2

//这是因为这两个元素的 hash值不同，所以存储在数组的位置不同

//因此我们要重写hashCode方法

System.out.println(people1.hashCode());//1170776379

System.out.println(people2.hashCode());//1170776379

System.out.println(hashSet.size());//1

}

}

class People{

//属性

private String name;

private int no;

//构造方法

public People() {

}

public People(String name, int no) {

this.name = name;

this.no = no;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getNo() {

return no;

}

public void setNo(int no) {

this.no = no;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

People people = (People) o;

return no == people.no &&

Objects.equals(name, people.name);

}

@Override

public int hashCode() {

return Objects.hash(name, no);

}

}

十三.Hashtable集合

Hashtable是线程安全的，底层也是哈希表

十四.Properties集合

import java.util.Properties;

/*

• 目前只需要掌握Properties属性类的相关方法

• Properties是一个Map集合，继承HashTable，Properties的key和value都是String类型的

• Properties被称为属性类对象

• Properties是线程安全的

• */

public class PropertiesTest {

public static void main(String[] args) {

Properties properties =new Properties();

//Properties需要掌握两个方法，一个存一个取

properties.setProperty(“123”,“钢铁侠”);

properties.setProperty(“456”,“蜘蛛侠”);

System.out.println(properties.getProperty(“123”));//钢铁侠

System.out.println(properties.getProperty(“456”));//蜘蛛侠

}

}

十五.TreeMap集合

TreeMap底层是二叉树

TreeMap集合的key可以自动按照大小顺序排序。

总结（所有的实现类）：

---

ArrayList：底层是数组。

LinkedList：底层是双向链表。

Vector：底层是数组，线程安全的，效率较低，使用较少。

HashSet：底层是HashMap，放到HashSet集合中的元素等同于放到HashMap集合key部分了。

TreeSet：底层是TreeMap，放到TreeSet集合中的元素等同于放到TreeMap集合key部分了。

HashMap:底层是哈希表。

Hashtable：底层也是哈希表，只不过线程安全的，效率较低，使用较少。

Properties：是线程安全的，并且key和value只能存储字符串String。

TreeMap：底层是二叉树。TreeMap集合的key可以自动按照大小顺序排序。

List集合存储元素的特点：

有序可重复

有序：存进去的顺序和取出的顺序相同，每一个元素都有下标。

可重复：存进去1，可以再存储一个1.

Set（Map）集合存储元素的特点：

无序不可重复

无序：存进去的顺序和取出的顺序不一定相同。另外Set集合中元素没有下标。

不可重复：存进去1，不能再存储1了。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后，附一张自己面试前准备的脑图：

面试前一定少不了刷题，为了方便大家复习，我分享一波个人整理的面试大全宝典

• Java核心知识整理

• Spring全家桶（实战系列）

Step3：刷题

既然是要面试，那么就少不了刷题，实际上春节回家后，哪儿也去不了，我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

以下是我私藏的面试题库：

很多人感叹“学习无用”，实际上之所以产生无用论，是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，都应该有主动性，所以如果拥有大厂梦，那么就要自己努力去实现它。

最后祝愿各位身体健康，顺利拿到心仪的offer！
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

十五.TreeMap集合

TreeMap底层是二叉树

TreeMap集合的key可以自动按照大小顺序排序。

总结（所有的实现类）：

---

ArrayList：底层是数组。

LinkedList：底层是双向链表。

Vector：底层是数组，线程安全的，效率较低，使用较少。

HashSet：底层是HashMap，放到HashSet集合中的元素等同于放到HashMap集合key部分了。

TreeSet：底层是TreeMap，放到TreeSet集合中的元素等同于放到TreeMap集合key部分了。

HashMap:底层是哈希表。

Hashtable：底层也是哈希表，只不过线程安全的，效率较低，使用较少。

Properties：是线程安全的，并且key和value只能存储字符串String。

TreeMap：底层是二叉树。TreeMap集合的key可以自动按照大小顺序排序。

List集合存储元素的特点：

有序可重复

有序：存进去的顺序和取出的顺序相同，每一个元素都有下标。

可重复：存进去1，可以再存储一个1.

Set（Map）集合存储元素的特点：

无序不可重复

无序：存进去的顺序和取出的顺序不一定相同。另外Set集合中元素没有下标。

不可重复：存进去1，不能再存储1了。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-PuvyESxc-1713513979337)]

[外链图片转存中…(img-kS70DL1D-1713513979341)]

[外链图片转存中…(img-746wbAmw-1713513979343)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后，附一张自己面试前准备的脑图：

[外链图片转存中…(img-AJH1vHP1-1713513979345)]

面试前一定少不了刷题，为了方便大家复习，我分享一波个人整理的面试大全宝典

• Java核心知识整理

[外链图片转存中…(img-Evk86gOs-1713513979346)]

• Spring全家桶（实战系列）

[外链图片转存中…(img-remOe8bc-1713513979348)]

Step3：刷题

既然是要面试，那么就少不了刷题，实际上春节回家后，哪儿也去不了，我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

以下是我私藏的面试题库：

[外链图片转存中…(img-DSE6Dn9e-1713513979350)]

很多人感叹“学习无用”，实际上之所以产生无用论，是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，都应该有主动性，所以如果拥有大厂梦，那么就要自己努力去实现它。

最后祝愿各位身体健康，顺利拿到心仪的offer！
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！