java集合框架

最新推荐文章于 2024-02-28 09:56:44 发布

有趣的程序Boy

最新推荐文章于 2024-02-28 09:56:44 发布

阅读量287

点赞数

分类专栏： java知识点文章标签： java 集合框架 list map

本文链接：https://blog.csdn.net/yloveyzcl/article/details/81776003

版权

java知识点专栏收录该内容

25 篇文章 0 订阅

订阅专栏

3 集合框架

3.1 ArrayList

使用数组的局限性

如果要存放多个对象，可以使用数组，但是数组有局限性
比如声明长度是10的数组
不用的数组就浪费了
超过10的个数，又放不下

ArrayList存放对象

为了解决数组的局限性，引入容器类的概念。最常见的容器类就是
ArrayList
容器的容量"capacity"会随着对象的增加，自动增长

3.1.1常用方法

增加

public class IOTest {

public static void main(String[] args){

ArrayList al=new ArrayList();

al.add(5);

System.out.println(al); // [5]

}

判断是否存在

通过方法contains 判断一个对象是否在容器中
判断标准：是否是同一个对象，而不是name是否相同

获取指定位置的对象

通过get获取指定位置的对象，如果输入的下标越界，一样会报错

获取对象所处的位置

indexOf用于判断一个对象在ArrayList中所处的位置
与contains一样，判断标准是对象是否相同，而非对象的name值是否相等

删除

remove用于把对象从ArrayList中删除
remove可以根据下标删除ArrayList的元素

替换

set用于替换指定位置的元素

获取大小

public class IOTest {

public static void main(String[] args){

ArrayList al=new ArrayList();

System.out.println(al.size()); // 0

al.add(5);

System.out.println(al); // [5]

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

}

转换为数组

toArray可以把一个ArrayList对象转换为数组

把另一个容器所有对象都加进来

addAll 把另一个容器所有对象都加进来

清空

public class IOTest {

public static void main(String[] args){

ArrayList al=new ArrayList();

al.add(5);

System.out.println(al); // [5]

al.clear();

System.out.println(al.size()); // 0

}

3.1.2 List接口

ArrayList实现了接口List
常见的写法会把引用声明为接口List类型
注意：是java.util.List,而不是java.awt.List

List al=new ArrayList();

3.1.3泛型 Generic

泛型 Generic

不指定泛型的容器，可以存放任何类型的元素
指定了泛型的容器，只能存放指定类型的元素以及其子类

List<Object> list=new ArrayList<Object>();

// 不过JDK7提供了一个可以略微减少代码量的泛型简写方式

List<Object> list=new ArrayList<>();

3.1.4 遍历

用for循环遍历

迭代器遍历

public class Test {

public static void main(String[] args) {

// 不过JDK7提供了一个可以略微减少代码量的泛型简写方式

List<Object> list=new ArrayList<>();

list.add(10);

list.add(20);

list.add(30);

System.out.println(list); // [10,20,30]

// 通过迭代器遍历

Iterator<Object> it=list.iterator();

while(it.hasNext()){

Object l=it.next();

System.out.println(l); // 10 20 30

}

用增强型for循环 foreach遍历

public class Test {

public static void main(String[] args) {

// 不过JDK7提供了一个可以略微减少代码量的泛型简写方式

List<Object> list=new ArrayList<>();

list.add(10);

list.add(20);

list.add(30);

System.out.println(list); // [10,20,30]

// 通过foreach遍历

for (Object object : list) {

System.out.println(object); // 10 20 30

}

3.2 LinkedList

序列分先进先出FIFO,先进后出FILO
FIFO在Java中又叫Queue 队列
FILO在Java中又叫Stack 栈

3.2.1 LinkedList 与 List接口

与ArrayList一样，LinkedList也实现了List接口，诸如add,remove,contains等等方法。

双向链表 – Deque

除了实现了List接口外，LinkedList还实现了双向链表结构Deque，可以很方便的在头尾插入删除数据

队列 – Queue

LinkedList 除了实现了List和Deque外，还实现了Queue接口(队列)。
Queue是先进先出队列 FIFO，常用方法：
offer 在最后添加元素
poll 取出第一个元素
peek 查看第一个元素

3.3 二叉树

二叉树概念

二叉树由各种节点组成
二叉树特点：
每个节点都可以有左子节点，右子节点
每一个节点都有一个值

二叉树排序-插入数据

假设通过二叉树对如下10个随机数进行排序
67,7,30,73,10,0,78,81,10,74
排序的第一个步骤是把数据插入到该二叉树中
插入基本逻辑是，小、相同的放左边，大的放右边

public class Node {

// 左子节点

public Node leftNode;

// 右子节点

public Node rightNode;

// 值

public Object value;

// 插入数据

public void add(Object v) {

// 如果当前节点没有值，就把数据放在当前节点上

if (null == value)

value = v;

// 如果当前节点有值，就进行判断，新增的值与当前值的大小关系

else {

// 新增的值，比当前值小或者相同

if ((Integer) v -((Integer)value) <= 0) {

if (null == leftNode)

leftNode = new Node();

leftNode.add(v);

}

// 新增的值，比当前值大

else {

if (null == rightNode)

rightNode = new Node();

rightNode.add(v);

}

public static void main(String[] args) {

int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };

Node roots = new Node();

for (int number : randoms) {

roots.add(number);

}

二叉树排序-遍历

通过上一个步骤的插入行为，实际上，数据就已经排好序了。接下来要做的是看，把这些已经排好序的数据，遍历成我们常用的List或者数组的形式
二叉树的遍历分左序，中序，右序
左序即：中间的数遍历后放在左边
中序即：中间的数遍历后放在中间
右序即：中间的数遍历后放在右边
如图所见，我们希望遍历后的结果是从小到大的，所以应该采用中序遍历

public class Node {

// 左子节点

public Node leftNode;

// 右子节点

public Node rightNode;

// 值

public Object value;

// 插入数据

public void add(Object v) {

// 如果当前节点没有值，就把数据放在当前节点上

if (null == value)

value = v;

// 如果当前节点有值，就进行判断，新增的值与当前值的大小关系

else {

// 新增的值，比当前值小或者相同

if ((Integer) v -((Integer)value) <= 0) {

if (null == leftNode)

leftNode = new Node();

leftNode.add(v);

}

// 新增的值，比当前值大

else {

if (null == rightNode)

rightNode = new Node();

rightNode.add(v);

}

// 中序遍历所有的节点

public List<Object> values() {

List<Object> values = new ArrayList<>();

// 左节点的遍历结果

if (null != leftNode)

values.addAll(leftNode.values());

// 当前节点

values.add(value);

// 右节点的遍历结果

if (null != rightNode)

values.addAll(rightNode.values());

return values;

}

public static void main(String[] args) {

int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };

Node roots = new Node();

for (int number : randoms) {

roots.add(number);

}

System.out.println(roots.values());

}

3.4 HashMap

HashMap的键值对

HashMap储存数据的方式是—— 键值对

public class Test {

public static void main(String[] args){

HashMap<String, String> hm=new HashMap<>();

hm.put("name","Tom");

hm.put("age","18");

System.out.println(hm.get("name")); //Tom

System.out.println(hm.get("age")); // 18

}

键不能重复，值可以重复

对于HashMap而言，key是唯一的，不可以重复的。
所以，以相同的key 把不同的value插入到 Map中会导致旧元素被覆盖，只留下最后插入的元素。
不过，同一个对象可以作为值插入到map中，只要对应的key不一样

3.5 HashSet

Set中的元素，不能重复

Set中的元素，没有顺序。
严格的说，是没有按照元素的插入顺序排列
HashSet的具体顺序，既不是按照插入顺序，也不是按照hashcode的顺序。

public class Test {

public static void main(String[] args){

HashSet<Integer> hs=new HashSet<>();

hs.add(10);

System.out.println(hs); // [10]

}

Set不提供get()来获取指定位置的元素
所以遍历需要用到迭代器，或者增强型for循环

HashSet和HashMap的关系

可以发现HashSet自身并没有独立的实现，而是在里面封装了一个Map.
HashSet是作为Map的key而存在的
而value是一个命名为PRESENT的static的Object对象，因为是一个类属性，所以只会有一个。

3.6 Collection

Collection是 Set List Queue和 Deque的接口
Queue: 先进先出队列
Deque: 双向链表
注：Collection和Map之间没有关系，Collection是放一个一个对象的，Map 是放键值对的
注：Deque 继承 Queue,间接得继承了 Collection

3.7 Collections

Collections是一个类，容器的工具类,就如同Arrays是数组的工具类

反转

reverse 使List中的数据发生翻转

Collections.reverse();

混淆

shuffle 混淆List中数据的顺序

Collections.shuffle();

排序

sort 对List中的数据进行排序

Collections.sort(numbers);

交换

swap 交换两个数据的位置

Collections.swap(numbers,0,5);

滚动

rotate 把List中的数据，向右滚动指定单位的长度

Collections.rotate(numbers,2);

线程安全化

synchronizedList 把非线程安全的List转换为线程安全的List

Collections.synchronizedList(numbers);

3.8 ArrayList与HashSet

ArrayList: 有顺序
HashSet: 无顺序

List中的数据可以重复
Set中的数据不能够重复
重复判断标准是:
首先看hashcode是否相同
如果hashcode不同，则认为是不同数据
如果hashcode相同，再比较equals，如果equals相同，则是相同数据，否则是不同数据

3.9 ArrayList和LinkedList

ArrayList 插入，删除数据慢
LinkedList，插入，删除数据快
ArrayList是顺序结构，所以定位很快，指哪找哪。就像电影院位置一样，有了电影票，一下就找到位置了。
LinkedList 是链表结构，就像手里的一串佛珠，要找出第99个佛珠，必须得一个一个的数过去，所以定位慢

public class TestCollection {

public static void main(String[] args) {

List<Integer> l;

l = new ArrayList<>();

insertFirst(l, "ArrayList");

l = new LinkedList<>();

insertFirst(l, "LinkedList");

}

private static void insertFirst(List<Integer> l, String type) {

int total = 1000 * 100;

final int number = 5;

long start = System.currentTimeMillis();

for (int i = 0; i < total; i++) {

l.add(0, number);

}

long end = System.currentTimeMillis();

System.out.printf("在%s 最前面插入%d条数据，总共耗时 %d 毫秒 %n", type, total, end - start);

}

定位数据

public class TestCollection {

public static void main(String[] args) {

List<Integer> l;

l = new ArrayList<>();

modify(l, "ArrayList");

l = new LinkedList<>();

modify(l, "LinkedList");

}

private static void modify(List<Integer> l, String type) {

int total = 100 * 1000;

int index = total/2;

final int number = 5;

//初始化

for (int i = 0; i < total; i++) {

l.add(number);

}

long start = System.currentTimeMillis();

for (int i = 0; i < total; i++) {

int n = l.get(index);

n++;

l.set(index, n);

}

long end = System.currentTimeMillis();

System.out.printf("%s总长度是%d，定位到第%d个数据，取出来，加1，再放回去%n 重复%d遍，总共耗时 %d 毫秒 %n", type,total, index,total, end - start);

System.out.println();

}

3.10 HashMap和Hashtable的区别

HashMap和Hashtable的区别

HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式
区别1：
HashMap可以存放 null
Hashtable不能存放null
区别2：
HashMap不是线程安全的类
Hashtable是线程安全的类

3.11 HashSet LinkedHashSet TreeSet

HashSet：无序
LinkedHashSet：按照插入顺序
TreeSet：从小到大排序

public class TestCollection {

public static void main(String[] args) {

HashSet<Integer> numberSet1 =new HashSet<Integer>();

//HashSet中的数据不是按照插入顺序存放

numberSet1.add(88);

numberSet1.add(8);

numberSet1.add(888);

System.out.println(numberSet1);

LinkedHashSet<Integer> numberSet2 =new LinkedHashSet<Integer>();

//LinkedHashSet中的数据是按照插入顺序存放

numberSet2.add(88);

numberSet2.add(8);

numberSet2.add(888);

System.out.println(numberSet2);

TreeSet<Integer> numberSet3 =new TreeSet<Integer>();

//TreeSet 中的数据是进行了排序的

numberSet3.add(88);

numberSet3.add(8);

numberSet3.add(888);

System.out.println(numberSet3);

}

3.12 hashcode原理

hashcode概念
所有的对象，都有一个对应的hashcode（散列值）

List查找的低效率

HashMap的性能表现快

这是一种用空间换时间的思维方式

HashSet判断是否重复

HashSet的数据是不能重复的，相同数据不能保存在一起，到底如何判断是否是重复的呢？
根据HashSet和HashMap的关系，我们了解到因为HashSet没有自身的实现，而是里面封装了一个HashMap，所以本质上就是判断HashMap的key是否重复。
再通过上一步的学习，key是否重复，是由两个步骤判断的：
hashcode是否一样
如果hashcode不一样，就是在不同的坑里，一定是不重复的
如果hashcode一样，就是在同一个坑里，还需要进行equals比较
如果equals一样，则是重复数据
如果equals不一样，则是不同数据

3.13 Comparator比较器

假设Hero有三个属性 name,hp,damage
一个集合中放存放10个Hero,通过Collections.sort对这10个进行排序
那么到底是hp小的放前面？还是damage小的放前面？Collections.sort也无法确定
所以要指定到底按照哪种属性进行排序
这里就需要提供一个Comparator给定如何进行两个对象之间的大小比较

Comparable

使Hero类实现Comparable接口
在类里面提供比较算法
Collections.sort就有足够的信息进行排序了，也无需额外提供比较器Comparator