Java集合框架中底层文档的List与Set

Java集合框架中底层文档的List与Set

Java集合框架中的List与Set

// 简书作者:达叔小生
Collection
-> Set 无序不重复 -> 无序HashSet,需要排序TreeSet
-> List 有序可重复 -> 查,改ArrayList,增删LinkedList

List为列表,中在列表中的对象是由顺序的排序的,并且是有重复的对象。

简单为:有序,有重复。

Set为集合,在集合中的对象是不按照顺序排列的,并且是没有重复的对象的。

简单为:无序,无重复。

Set为无序集合,无序无重复;

List为有序集合,有序有重复;

// 简书作者:达叔小生
Collection
-> Set
-> HashSet
-> LinkedHashSet
-> TreeSet -> List
-> ArrayList
-> Vector
-> LinkedList

Java集合框架中底层文档的List与Set

案例

// 简书作者:达叔小生
import java.util.List;
import java.util.ArrayList; public class Demo{
public static void main(String args[]){
// 创建列表的实现类对象
ArrayList<String> arrayList = new ArrayList<String>();
// 添加数据
arrayList.add("a");
arrayList.add("b");
arrayList.add("c");
// 移除
arrayList.remove(1);
// 获取数据
String s = arrayList.get(1);
System.out.println(s);
// 获取长度
int a = arrayList.size();
// 打印所有元素
for(int i=0; i<arrayList.size(); i++){
String s = arrayList.get(i);
System.out.println(s);
}
}
}
// 简书作者:达叔小生
public class ListDemo{
public static void main(String[] args){
// List
List list = new ArrayList();
// 添加元素
list.add( new Student("a",12) );
list.add( new Student("b",13) );
list.add( new Student("c",14) );
// 插入元素
// list.add( 1, new Student("d",15) );
// list.remove(44);
// 角标越界IndexOutOfBoundsException)
// list.set( 2, new Student("dashucoding", 16) );
// 循环出对象
for(Iterator it = List.iterator(); it.hasNext(); ){
Student stu = (Student) it.next();
System.out.println(stu);
}
// 获取对象
Object obj = list.get(1);
System.out.println(obj);
// 获取对象
for(int i = 0; i<list.size(); i++){
System.out.println(list.get(i));
}
}
// 简书作者:达叔小生
import java.util.Set;
import java.util.HashSet;
public class Demo{
public static void main(String args[]){
HashSet<String> hashSet = new HashSet<String>();
Set<String> set = hashSet;
// 实现类向上转型为接口
// 同理 Set<String> set = new HashSet<String>();
// 添加元素
set.add("a");
set.add("b");
set.add("c");
set.add("d");
// 获取集合中的元素长度
int a = set.size();
}
}
// 简书作者:达叔小生
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
public class Demo{
public static void main(String args[]){
HashSet<String> hashSet = new HashSet<String>();
Set<String> set = hashSet;
// 实现类向上转型为接口
// 同理 Set<String> set = new HashSet<String>();
// 添加元素
set.add("a");
set.add("b");
set.add("c");
set.add("d");
// 迭代器 iterator() 遍历整个set
// 通过迭代器取出集合中的对象
Iterator<String> it = set.iterator<String>();
while(it.hasNext){
String s = it.next();
System.out.println(s);
}
}
}
// 简书作者:达叔小生
public class ListIteratorDemo{
// 创建List对象
List list = new ArrayList();
// 添加元素
List.add("a");
List.add("b");
List.add("c");
// 获取元素,iterator()方法进行迭代
Iterator it = list.iterator();
// 获取元素
while(it.hasNext()){
System.out.println(it.next());
}
}

知识点

next()返回迭代的下一个元素,如果抛出异常为:NoSuchElementException,为没有元素可以迭代。

迭代器

在迭代过程中,使用了集合的方法对元素进行操作,导致迭代器不知道集合中的变化,容易产生数据的不确定性,所以不要使用集合的方法进行操作元素,可以使用迭代器的方法进行操作。

迭代器的方法:

// 简书作者:达叔小生
hasNext()
next()
remove()

迭代器 java.util 接口 Iterator<E>

知道的接口:ListIterator<E>,XMLEventReader

知道的实现类:BeanContextSupport.BCSIterator,EventReaderDelegate,Scanner。

// 简书作者:达叔小生
public interface Iterator<E>

迭代器的三个方法:

方法 说明
hasNext() 返回的是boolean类型,如果集合中还有元素存在,就可以进行迭代,然后返回true,代表为还有元素存在,反之,返回的是false
next() 返回的是E,返回的是迭代出来的下一个元素
remove() 返回的类型为void,从迭代器中移除迭代器中的最后一个元素

列表迭代器

接口 Iterator<E>下的子接口有个:

ListIterator<E> 为列表迭代器

// 简书作者:达叔小生
java.util
接口ListIterator<E>
超级接口:Iterator<E>
// 简书作者:达叔小生
public interface ListIterator<E> extends Iterator<E>
// 简书作者:达叔小生
while(it.hasNext()){
Object obj = it.next();
if("a".equals(obj)){
list.add("aaaaa");
}
}

列表迭代器的特性可以在迭代期间进行修改列表,然后获取迭代器在列表中的当前位置。

方法 说明
add(E e) 方法返回的是void类型,可以将指定的元素进行插入到列表中
hasNext() 方法返回的是boolean类型,该方法表示如果next返回一个元素后,不是抛出异常,则代表有下一个元素,则返回ture,否则返回false
hasPrevious() 返回的是boolean类型,该方法的作用是如果逆向遍历列表,列表迭代器中有多个元素,则返回为true,即简单说就是有没有前一个
next() 返回的是E,该方法表示返回列表中的下一个元素
nextIndex() 返回的是Int类型,该方法对next的后续调用所返回元素的索引
previous() 返回的是列表中的前一个元素,取出前一个
previousIndex() 返回的类型为int类型,返回对previous的后续调用所返回元素的索引
remove() 返回的类型为void,从列表中移除一个元素
set(E e) 返回的类型为Void,用指定的元素取替代nextprevious 返回的最后一个元素

使用ListIterator

// 简书作者:达叔小生
// 创建List对象
List list = new ArrayList();
// 添加元素
List.add("a");
List.add("b");
List.add("c");
// 列表迭代器
ListIterator it = list.listIterator();
while(it.hasNext()){
Object obj = it.next();
if("a".equals(obj)){
// 添加 it.add("dashucoding");
// 删除 it.set("dashucoding");
}
}

迭代器的List接口的子接口ListIterator,可以实现增删改查

List

接口List<E>,知道的实现类:

List是有序的,带索引的,元素可以重复

List可以增删改查,增加add(),删除remove(),修改set(),查询get()

// 简书作者:达叔小生
实现类:
AbstractList , ArrayList , LinkedList , Vector
AbstractSequentialList , AttributeList , CopyOnWriteArrayList , RoleList , RoleUnresolvedList , Stack

ArrayList (数组结构,不同步的,为了提高效率), LinkedList(链接列表结构,就像链子一样,不同步的) , Vector(可以实现可增长的对象数组,可变化,同步的)

ArrayList

// 简书作者:达叔小生
ArrayList为数组结构,长度可以改变
java.util
类 ArrayList<E>
java.lang.Object
-> java.util.AbstractCollection<E>
-> java.util.AbstractList<E>
-> java.util.ArrayList<E>

知道的实现接口:

Serializable,Cloneable,Iterable<E>,Collection<E>,List<E>,RandomAccess

知道的子类:

AttributeList, RoleList, RoleUnresolvedList

// 简书作者:达叔小生
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

LinkedList 可以用于实现堆栈,队列(栈内存先进后出,队列先进先出)

// 简书作者:达叔小生
java.util
类 LinkedList<E>
java.lang.Object
-> java.util.AbstractCollection<E>
-> java.util.AbstractList<E>
-> java.util.AbstractSequentialList<E>
-> java.util.LinkedList<E> public class LinkedList<E>
extends AbstractSequentiaList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

知道的接口:Serializable, Cloneable, Iterable<E>, Collection<E>, Deque<E>, List<E>, Queue<E>

LinkedList 队列

// 简书作者:达叔小生
public class LinkedListDemo{
public static void main(String[] args){
// 创建一个队列对象
Queue queue = new Queue();
// 队列添加元素
queue.add("a");
queue.add("b");
queue.add("c");
while(!queue.isNull){
System.out.println(queue.myGet());
}
}
}

队列

class Queue{
// 封装了一个链表的数据结构
private LinkedList link;
Queue(){
link = new LinkedList();
}
// 功能
public void add(Object obj){
// 内部,使用链表方法
link.addFirst(obj);
}
// 先进先出
public Object myGet(){
return link.removeList();
}
// 判断队列中的元素是否为空
public boolean isNull(){
return link.isEmpty();
}
}

堆栈,手枪弹夹,队列,排队买票

// 去除重复元素
public static void getSingleElement(List list){
// 临时容器
List temp = new ArrayList();
// 原容器
for(Iterator it = list.iterator(); it.hasNext(); ){
// 遍历原对象元素
Object obj = it.next();
if(temp.contains(obj)){
// 判断是否存在
temp.add(obj);
}
}
list.clear();
list.addAll(temp);
}
// 简书作者:达叔小生
public class ArrayListDemo{
public static void main(String[] args){
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
System.out.println(list);
}
}
// 简书作者:达叔小生
public boolean equals(Object obj){
if(this == obj){
return true;
}
if(!(obj instanceof Student)){
throw new ClassCastException();
}
Student stu = (Student) obj;
return this.name.equals(stu.name) && this.age == stu.age;
}
// 简书作者:达叔小生
public boolean contains(Object o){
return indexOf(o) >= 0;
}
// 简书作者:达叔小生
public int indexOf(Object o){
if(o == null){
for(int i = 0; i<size; i++){
if(elementData[i] == null){
return i;
}
}
}else{
for( int i = 0; i<size; i++){
if(o.equals(elementData[i])){
return i;
}
}
}
return -1;
}
// 简书作者:达叔小生
List
-> Vector
-> ArrayList
-> LinkedList

接口集合框架-Set接口

API-set

java.util
接口 Set<E>
参数E:此set所维护元素的类型
超级接口
Collection<E>,Iterable<E>
知道的子接口
NavigableSet<E>,SortedSet<E>
知道实现类
AbstractSet,ConcurrentSkipListSet,CopyOnWriteArraySet,EnumSet,HashSet,
JobStateReasons,LinkedHashSet,TreeSet

HashSet查询效率很高,它的子类(儿子)LinkedHashSet,可以迭代顺序的set接口的哈希表和链接列表的实现。

public class LinkedHashSetDemo{
public static void main(String[] args){
Set set = new LinkedHashSet();
set.add("a");
set.add("b");
set.add("c");
for(Iterator it = set.iterator(); it.hesNext();){
System.out.println(it.next());
}
}
}
public interface Set<E>
extends Collection<E>

Set为一个不包含重复的集合,

Set的一些方法:

方法 说明
add(E e) 返回类型为boolean,该方法用来添加元素
addAll(Collection<? extends g> c) 返回的是boolean类型,该方法是用来添加所有元素到set中的
clear() 返回void类型,是用来移除set中的所有元素
contains(Object o) 返回boolean类型,该方法是指定set中是否包含该元素,如果有则返回true,否则就为false
containsAll(Collection<?> c) 返回boolean类型,如果在set中有包含所有指定的collection元素,就返回true,否则返回false
equals(Object o) 返回类型为boolean,用来比较指定对象与此set的相等性
hashCode() 返回的类型为Int,返回set的哈希码值
isEmpty() 返回的是int类型,返回set不包含元素,则返回true
iterator() 返回的是Iterator<E>类型,返回在此set中的元素上进行迭代的迭代器。
remove(Object o) 返回boolean类型,如果set中存在指定的元素,就将其移除
removeAll(Collection<?> c) 返回boolean类型,移除set中那些包含在指定collection中的元素
retainAll(Collection<?> c) 返回boolean类型,仅保留set中那些包含在指定collection中的元素
size() 返回Int类型,返回set中的元素数
toArray() 返回一个包含set中所有元素的数组
toArray([] a) 返回一个包含set中所有元素的数组,返回数组的运行时类型是指定数组的类型。
public class SetDemo{
public static void main(String[] args){
Set set = new HashSet();
set.add("a");
set.add("b");
set.add("c");
// set.add(new Student("a",12));
// set.add(new Student("b",13));
// set.add(new Student("c",14)); for(Iterator it = set.iterator(); it.hasNext(); ){
Object object = (Object) it.next();
System.out.println(it.next();
}
}
}
Set
-> HashSet
-> TreeSet

HashSet<E>

java.lang.Object
-> java.util.AbstractCollection<E>
-> java.util.AbstractSet<E>
-> java.util.HashSet<E>
类HashSet<E>
知道已实现的接口:
Serializable,Cloneable,Iterable<E>,Collection<E>,Set<E>
知道的子类:
JobStateReasons,LinkedHashSet
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>,Cloneable,Serializable

HashSet该类实现了Set的接口,数组中存储的是元素,哈希值对应关系,所以叫哈希表或叫散列,查询速度快。有重复元素,用不了哈希表,即不可以包含重复的元素,不保证顺序,方法有hasCode()equals()方法。

方法 说明
hashCode() 返回的是Ine类型,返回该对象的哈希值
// 简书作者:达叔小生
public int hashCode(){
return 1;
} public boolean equals(Object obj){
if(this == obj)
return true;
if(obj == null)
return false;
if(getClass() != obj.getClass())
return false;
if(age != other.age)
return false;
if(name == null){
if(other.name != null)
return false;
}else if(!name.equals(other.name))
return false;
return true;
}
}

TreeSet<E>,可以进行排序set集合中的元素,比较结果为0,视为相同元素不存。

案例

// 简书作者:达叔小生
public class TreeSetDemo{
public static void main(String[] args){
Set set = new TreeSet(new ComparatorLength() );
set.add("a");
set.add("b");
set.add("c");
for(Iterator it = set.iterator();it.hasNext(); ){
System.out.println(it.next());
}
}
}
// 简书作者:达叔小生
public class ComparatorLength implements Comparator{
public int compare(Object o1,Object o2){
// 比较字符串,强转
String s1=(String)o1;
String s2=(String)o2;
int temp = s1.length() - s2.length();
return temp == 0? s1.compareTo(s2) : temp;
}
}
// 简书作者:达叔小生
public class TreeSet<E>
extends AbstractSet<E>
implements NavigableSet<E>,Cloneable,Serialirable
// 简书作者:达叔小生
java.lang
接口 Comparable<T>
参数为可以与对象进行比较
// 定义一个类实现Comparator
public class ComparatorName implements Comparator{
public int compare(Object o1,Object o2){
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int temp = s1.getName().compareTo(s2.getName());
return temp==0? s1.getAge()-s2.getAge() : temp;
}
}

已知的那些子接口:

Delayed,Name,RunnableScheduledFuture<V>,ScheduleFuture<V>

方法:实现comparable接口,可以排序的功能

方法 说明
compreTo(T o) 返回类型为Int,是用来比较对象与指定对象的顺序
// 简书作者:达叔小生
public int compareTo(Object o){
if(!(o instanceof Student)){
throw new ClassCastException();
}
Student stu = (Student) o;
if(this.age>stu.age)
return 1;
if(this.age<stu.age)
return -1;
return 0;
}
// 简书作者:达叔小生
public class TreeSetDemo{
public static void main(String[] args){
// Set set = new TreeSet();
TreeSet set = new TreeSet();
set.add("a");
set.add("b");
set.add("c");
for(Iterator it = set.iterator(); it.hasNext(); ){
System.out.println(it.next());
}
}
}
// 源码
public boolean add(E e){
return m.put(e, PRESENT)==null;
}

构造方法:

方法 说明
TreeSet() 无参构造方法,该set根据其元素的自然顺序进行排序
TreeSet(Collection<? extend E> e) 构造一个包含指定collection元素的新TreeSet,它按照其元素的自然顺序进行排序
TreeSet(Comparator<? super E> comparator) 构造一个新的空TreeSet,它根据指定比较器进行顺序
TreeSet(SortedSet s) 构造一个与指定有序set具有相同映射关系和相同排序的新TreeSet

二叉树结构

二叉树结构把小的放在左边,大的放在右边。

Java集合框架中底层文档的List与Set

for each 循环

// 简书作者:达叔小生
public class ForeachDemo{
public static void main(String[] args){
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
for(Object str : list){
System.out.println(obj);
}
}
}

枚举,一枚一枚的举出了来

方法 说明
hasMoreElements() 返回的是booleam类型,测试枚举是否包含更多的元素
nextElement() 如果该枚举对象至少还有一个可提供的元素,就返回此枚举,取出下一个元素
// 简书作者:达叔小生
public class EnumerationDemo{
public static void main(String[] args)}
Vector v = new Vector();
v.addElement("a");
v.addElement("b");
v.addElement("c");
for(Enumeration e = v.elements(); e.hasMoreElements();){
System.out.println(e.nextElement());
}
// 不考虑,先考虑Iterator
for(Object obj : v){
System.out.println(obj);
}
}
}

集合:

List -> ArrayList(数组,查询快),LinkedList(链表,增删快)

Set -> HashSet(哈希表,查询快,表对应唯一)

TreeSet(二叉树,就知道排序的,有规则)

往后余生,唯独有你

简书作者:达叔小生

90后帅气小伙,良好的开发习惯;独立思考的能力;主动并且善于沟通

简书博客: https://www.jianshu.com/u/c785ece603d1

结语

  • 下面我将继续对 其他知识 深入讲解 ,有兴趣可以继续关注
  • 小礼物走一走 or 点赞
上一篇:HOOK API(三)—— HOOK 所有程序的 MessageBox


下一篇:ios中蓝牙自动连接出现硬件提示框的问题