累计时间: 2小时
知识点补充:
存放数据的容器: 数组:
1: 数组的长度固定:
Student stu[] = new Student[20];
new Student("lisi",21);
数组扩容:
(1)创建一个临时的数组:
(2)将数组的内容copy到 临时数组。
(3)原来的数组扩容:
(4)把临时数组当中的内容copy回来:
2: 集合: 存放数据。
当存放的内容数量不固定,不确定,有限采用集合。
3: 区别:
(1)数组的长度是固定。
数组存放的数据类型,必须相同或者是相兼容:
(2)集合自动扩容。
集合当中可以存放任意的数据类型:
一: 集合:
1: 在JDK1.0 时候,提供了集合:
线性表:
Vector
|
stack
映射结构:
Dictionary(目录)
|
Hashtable
|
Properties
在JDK1.2 新添加了集合类: 形成了集合框架:
线性表结构:
Collection(接口)
|-------List: (接口) 允许重复元素:
|------ArrayList: (重要)
|------Vector:
|------Stack:
|------LinkedList:
|-------Set: (接口) 元素不能重复:
|------HashSet:
|------TreeSet:
|------LinkedHashSet:
|-------Queue: (接口)
|------LinkedList:
实现类: 底层根据数据结构不同而区分:
映射结构;
Map
|----HashMap: (重点)
|----TreeMap:
|----Hashtable:
|----Properties: (重点)
学习: 看顶层,用底层:
二: 集合: 位于java.util.*;
Collection :接口:
add(Object obj);
addAll(Collection c);
remove(Object);
removeAll(Collection c);
clear();
size();
contains();
containsAll();
isEmpty();
toArray();
retainAll();
iterator();
三: 集合的细节:
* 1: 存放在集合当中,存放对象的引用:
* 2: 往集合当中存放内容, 元素失去了原有的类型,自动提升为Object类型:
* 3: 集合当中不能存放基本数据类型,但是在JDK1.5后,有自动装箱功能:
四: List接口:
特点: 存放的元素有序,可重复, 支持下标访问。
List集合: 围绕索引添加了一系列的方法:
增加:
add(index, obj);
addAll(int index, Collection<? extends E> c)
删除:
remove(int index) ;
改:
set(int index, E element)
查:
get(int index)
一:集合:
Collection集合:
|---List: 元素可重复,有序,支持下标访问:
|----ArrayList: 底层是数组: 查询块, 增删相比稍慢,可以被接收。
该类的所有的方法都是异步:数据不安全, 效率高。
|---- new ArrayList(); 初始容量大小为10. 加载因子: 0.5。 50%扩展:
|---- new ArrayList(Collection c);将Collection集合 的实现类转换成一个ArrayList集合:
|---- new ArrayList(int num); 指定初始容量大小: (不建议使用:)
|----Vector类: 底层数组: 该类已经被ArrayList取代。
该类的实现:线程同步, 数据安全, 效率低。
|---- new Vector(); 创建一个空集合: 初始容量大小为10, 两倍扩展: 底层数组: 方法实现: 同步,数据安全,
效率低
|----- new Vector(Collection<? extends E> c) 将一些其他的集合对象转换成Vector集合:
|------elements(); 获得一个枚举: 元素的个数可以被列举:
|-----LinkedList :类: 底层是链表结构: 主要是针对头元素和尾元素进行操作:
其他 在思维导图中已经全部说明。
二 : 面试问题;
(1) Vector 和 ArrayList的区别:
共同点:
不同点:
(2) 给定一个ArrayList集合, 使用枚举遍历;
(3) String StringBuilder StringBuffer 三者之间的异同点:
StringBuilder: 线程异步, 数据不安全, 效率高。
StringBuffer: 线程同步,数据安全, 效率低:
(4) 面试问题: 模拟队列: LinkedList:
// 模拟栈结构:
三: LinkedList: 类:
API方法“:
添加头和尾:
addFirst(E e)
addLast(E e)
获得头和尾:
getFirst()
getLast();
移除头和尾部;
removeFirst()
removeLast()
如果集合当中没有操作的该元素,会抛出异常:
去除List 集合当中的重复元素:
====================
以下三组方法; 在JDK1.6时候存在:如果集合当中没有可操作的元素,返回null。
添加头和尾
offerFirst(E e)
offerLast(E e)
获得头和尾:
peekFirst()
peekLast()
移除头和尾部;
pollFirst()
pollLast()
push();
栈: Stack : 特点: FILO: 先进后出:
队列: Queue : 特点: FIFO:先进先出:
图中没有提到map 作补充 后面再补一张图:
List集合与Map集合的关系
从底层实现来看,Set集合和Map集合很类似;从用法的角度来看,List集合和Map集合也有很多类似的地方。
- Map接口提供了get(K key)方法,允许Map对象根据key来取得对应的value。
- List接口提供了get(int index)方法,允许List对象根据元素索引index来取得对应的value。
即可以说List相当于所有key都是int类型的Map,也可以说Map是相当于索引是任意类型的List。
2018年8月18日17:44:06于易动
不太完整 待更ing。。
下面是代码例子:
List类
ArrayList:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo01 {
public static void main(String[] args) {
/*
增加:
add(index, obj);
addAll(int index, Collection<? extends E> c)
*/
List list= new ArrayList();
list.add(0,"你好吗?");
list.add(1,"你好吗?");
list.add(2,"一般");
System.out.println(list);
/* 删除:
remove(int index) ;*/
// list.remove("")
list.remove(1);
System.out.println(list);
/*
改:
set(int index, E element)
*/
list.set(1, "今天周五");
/* 查:
get(int index) */
Object object = list.get(1);
System.out.println(object);
//List遍历方式:
System.out.println("==========================");
for(int i=0 ; i<list.size();i++){
System.out.println(list.get(i));
}
System.out.println("==========================");
Iterator it = list.iterator();
while(it.hasNext()){
Object next = it.next();
System.out.println(next);
}
System.out.println("==========================");
//增强的for循环:
for(Object obj: list){
System.out.println(obj);
}
/*
* 传统的for循环: 当对某个元素的内容进行相关操作的时候,一般使用传统for循环:
* 增强的for: 只用来遍历:
*/
}
}
![](https://i-blog.csdnimg.cn/blog_migrate/ee3a7632d4679d1dda7e6f96900e8c21.png)
Vector类
实现添加元素和迭代遍历
package com.guangyu.copy;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo01 {
public static void main(String[] args) {
Vector v= new Vector();
v.add("a");
v.add("b");
v.add("c");
v.add("d");
//使用枚举迭代每一个元素
Enumeration elements = v.elements();
while(elements.hasMoreElements()){
Object nextElement = elements.nextElement();
System.out.println(nextElement);
}
/*
* Vector 类: 迭代的方式:
* (1)枚举:
* (2)迭代器:
* (3)反向迭代器:
* (4)传统for循环: get(index )
* (5)增强for循环:
*
*/
// v.iterator();
System.out.println(v.capacity());
}
}
LinkedList类
实现模拟堆栈结构存储
package com.guangyu.copy;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo01 {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.addFirst("a");
list.addFirst("b");
list.addFirst("c");
list.addFirst("d");
System.out.println(list);// list: [d, c, b, a]
System.out.println(list.getFirst());// d
// System.out.println(list.removeFirst());// d
// System.out.println(list.removeFirst());// c
System.out.println("==============");
/*while(!list.isEmpty()){
String str= (String)list.removeFirst();
System.out.println(str);// dcba 模拟了栈结构:
}*/
while(!list.isEmpty()){
String str= (String)list.removeLast();
System.out.println(str);// dcba 模拟了队列结构:
}
// list.removeLast(); NoSuchElementException
}
}
Queue类
LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限(即在方法中的参数类型如果是Queue时,就完全只能访问Queue接口所定义的方法 了,而不能直接访问 LinkedList的非Queue的方法),以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。
所以说 queue 还是用链表结构实现的,学过数据结构的话 ,就知道用双向指针实现的。
下面程序模拟实现队列和调用方法:
import java.util.LinkedList;
/*
* 使用LinkedList模拟队列:
* 队列的特点: FIFO
*/
public class Queue {
// LinkedList:
private LinkedList list;
public Queue(LinkedList list){
this.list= list;
}
// 模拟添加的方法;
public void myAdd(Object obj){
list.offerFirst(obj);
}
//定义取元素的方法;
public Object myGet(){
Object obj = list.pollLast();
return obj;
}
//判断是否为空:
public boolean MyIsEmpty(){
return list.isEmpty();
}
}
public class QueueDemo01 {
public static void main(String[] args) {
//Queue 接口: LinkedList :
Queue q = new LinkedList();
//队列的特点: 先进先出: FIFO
// offer
q.offer("abd");
q.offer("dba");
q.offer("java");
q.offer("xiaoxuedi");
// peek: 集合当中没有任何的元素 返回null。 不移除:
Object peek = q.peek();
System.out.println(peek);
System.out.println(peek);
//poll 获得头,并且移除:
Object poll = q.poll();
Object poll2 = q.poll();
System.out.println(poll);
System.out.println(poll2);
System.out.println("==========");
while(!q.isEmpty()){
Object poll3 = q.poll();
System.out.println(poll3);
}
}
}
Set类
Treeset:
1 存放元素 按照默认的规则
import java.util.TreeSet;
public class TreeDemo01 {
public static void main(String[] args) {
//创建一个treeset对象:
TreeSet set = new TreeSet();// treeset集合当中存放的元素: 按照默认的规则存放:
set.add("cba");
set.add("zba");
set.add("nba");
set.add("abc");
// 底层原理: 二叉树:
System.out.println(set);
}
}
2 按照自定义比较规则存放(优先级高于默认的比较规则)
如果你没有指定规则的话,你的对象有多个类型无法比较时,会抛出类转换异常。所以自定义比较方法,如果指定泛型,在自定义的时候会自动出现你要比较的对象 所在的类 的类型。
public class TreeSetDemo03 {
@SuppressWarnings("all")
public static void main(String[] args) {
/*
* 演示: 自定义比较规则,存放字符串:
*
* 需求: 字符串的默认的字典顺序,不能满足实际的需求: 需要
* 自定义比较规则: 根据字符串的长度进行降序排序:
*/
TreeSet set = new TreeSet(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
/*
* 长度的降序: 长度相同, name的升序:
*/
int num1= o2.length()- o1.length();
return num1==0 ? o1.compareTo(o2):num1;
}
});// treeset集合当中存放的元素: 按照默认的规则存放:
set.add("nibiexxxx");
set.add("a");
set.add("b");
set.add("zba");
set.add("kknba");
System.out.println(set);
}
}
上面程序在创建对象的时候,指定泛型String。然后实现接口的方法
https://blog.csdn.net/u012250875/article/details/55126531
LinkedHashSet:
import java.util.LinkedHashSet;
public class LinkedHashSetDemo01 {
public static void main(String[] args) {
//创建一个对象:
/*
* 有序:按照存放的顺序:
* 唯一: 通过哈希码:和equals 保证元素的唯一:
*/
LinkedHashSet ls = new LinkedHashSet();
ls.add("java");
ls.add("spring");
ls.add("spring");
ls.add("struts");
ls.add("hibernate");
ls.add("springboot");
System.out.println(ls);
}
}
存的时候默认的是字符串的比较方法。可以自定义一个类继承接口 重写compare方法。
import java.util.Comparator;
/*
* 自定义比较规则:
* 该规则被重复利用的时候,可以定在再外部,形成一个单独的类:
*/
public class myCompatorByLength implements Comparator{
@Override
public int compare(Object o1, Object o2) {
//指定了一个比较规则: 根据字符串的长度进行降序排序:
String str1= (String)o1;
String str2= (String)o2;
// 长度相同: 按照字符串的升序排序:
int num2= str1.compareTo(str2);
int num1= str2.length() - str1.length();
return num1==0? num2:num1;
}
}
EmumSet:
专门为枚举设计的集合,适合批量操作。
这个自己没啥心得转载一篇吧https://blog.csdn.net/chengqiuming/article/details/70139107
2018年8月22日11:03:50于易动
完善了一下集合,不想让自己写的东西是那种复制API转载抄袭几篇的文章。
要么不急着写,要么就等自己有所心得的时候再写,水平高不高无所谓,主要是自己的东西就好,
个人看法,谢谢!