第49节：Java集合框架中底层文档的List与Set

2022-07-29 10:04:22

第49节：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

第49节：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，用指定的元素取替代next或previous 返回的最后一个元素

使用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

二叉树结构

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

第49节：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 点赞
上一篇：js Date()日期函数浏览器兼容问题解决方法


下一篇：HOOK API（三）—— HOOK 所有程序的 MessageBox