(主推)集合框架2:List与Set总结|Arrays|Collection与Collections - 黑马程序员技术交流社区

List和Set集合的总结|ArrayList与Vector|Collection与Collections |Arrays工具类|集合去重

1.List总结

List 接口是一个有序可重复集合，List集合默认按元素的添加顺序来设置元素的索引,可以通过索引来访问指定位置的元素(顺序索引从0开始)。List 接口继承Collection接口，实现了Collection的所有方法，凡是可操作角标的方法都是List特有的方法：

import java.util.*;
import static java.lang.System.*;
class ListMethodDemo
{
public static void main(String[] args)
{
ArrayList list = new ArrayList();
list.add("java01");
list.add("java02");
list.add("java03");
list.add("java04");
out.println("原集合：" + list);
//在指定位置添加元素
list.add(0,"java00");
//如果索引超出范围 (index < 0 || index > size()),抛出IndexOutOfBoundsException
//list.add(-1,"java-1");
out.println("增加元素集合：" + list);
//删除指定位置的元素
list.remove(0);
//如果索引超出范围 (index < 0 || index > size()),抛出IndexOutOfBoundsException
//list.remove(-1,"java-1");
out.println("删除元素集合：" + list);
//修改元素
list.set(0,"java");
//如果索引超出范围 (index < 0 || index > size()),抛出IndexOutOfBoundsException
//list.set(-1,"java");
out.println("修改元素集合：" + list);
//获取所有元素
ListIterator listit = list.listIterator();//列表迭代器
while(listit.hasNext()){
out.println(listit.next());
}
//通过indexOf获取对象位置,若元素不存在，返回-1
out.println(list.indexOf("java"));
//子列表,如果是非法的端点值 (fromIndex < 0 || toIndex > size || fromIndex > toIndex)，抛出IndexOutOfBoundsException
List sub = list.subList(0,10);
out.println(sub);
}
}

复制代码

List是接口，同时也拥有自己的具体实现类， ArrayList，LinkedList，Vector。
ArrayList
底层数据结构是数组结构，线程不安全，特点：查询速度很快
LinkedList
LinkedList底层数据结构是链表，线程不安全，特点是增删速度很快，查询速度稍慢。
LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。
此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

/*
使用LinkedList模拟堆栈和队列
堆栈：先进后出(被子) FILO
队列：先进先出(水管) FIFO
*/
import java.util.*;
import static java.lang.System.*;
class LinkedListDemo
{
public static void main(String[] args)
{
DuiLie dl = new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
out.println("先进后出：");
while(!dl.isNull()){
out.println(dl.myGetFILO());
}
/*out.println("先进先出：");
while(!dl.isNull()){
out.println(dl.myGetFIFO());
}*/
}
}
class DuiLie
{
private LinkedList list;
public DuiLie(){
list = new LinkedList();
}
public void myAdd(Object obj){
list.offerFirst(obj);
}
public Object myGetFIFO(){//先进先出
return list.removeLast();
}
public Object myGetFILO(){//先进后出
return list.removeFirst();
}
public boolean isNull(){
return list.isEmpty();
}
}

复制代码

Vector
底层数据结构是数组结构，线程安全，与Arraylist、LinkedList相比，操作效率低
关于使用List集合的几点建议：
•如果需要遍历List集合元素，对应ArrayList、Vector集合，则应该使用随机访问方法（get）来遍历集合元素，这样性能更好。对应LinkedList集合，则应采用迭代器（Iterator）来遍历集合元素。
•如果需要经常执行插入、删除操作来改变Lst集合大小，则应该使用LinkedList集合，而不是ArrayList。
•如果多条线程需要同时访问List集合中的元素，可以考虑使用Vector这个同步实现，或者考虑使用Collections工具类实现同步。

2.Set总结

Set接口继承Collection接口，是一个无序且不重复的集合。先说HashSet
HashSet集合的底层结构是一个哈希表数据结构，无序（存进去和取出来的顺序可能不一致），不可以存入重复的元素，存入HashSet集合的元素需要覆盖hashCode()方法和equals()方法。
HashSet是如何保证元素的唯一性的呢？
是通过元素的两个方法 hashCode() 和equals()方法。
如果元素的hashCode()相同,才会判断equals是否为true;
如果元素的hashCode()不同，直接存入到HashSet集合，则不会调用equals方法。

HashSet对于判断元素是否存在，以及删除等操作，依赖的是也是hashCode和equals方法。

import java.util.*;
import static java.lang.System.*;
/*
HashSet是如何保证元素的唯一性的呢？
是通过元素的两个方法 hashCode() 和equals() 方法。
如果元素的hashCode()相同,才会判断equals是否为true;
如果元素的hashCode()不同，直接存入到HashSet集合，则不会调用equals方法。
HashSet对于判断元素是否存在，以及删除等操作，依赖的是也是hashCode和equals方法。
*/
class HashSetTest
{
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new Student("zhangsan",18));
hs.add(new Student("zhangsan",18));
hs.add(new Student("lisi",40));
hs.add(new Student("lisi",40));
hs.add(new Student("wangwu",20));
hs.add(new Student("wangwu",20));
Iterator it = hs.iterator();
while(it.hasNext()){
Student s = (Student)it.next();
out.println("name=" + s.getName() + "...age=" + s.getAge());
}
}
}
class Student//学生类
{
private String name;//姓名
private int age;//年龄
Student(String name, int age){
this.name = name;
this.age = age;
}
public int hashCode(){//覆写hashCode的方法，保证元素唯一性
return name.hashCode() + age*28;
}
public boolean equals(Object obj){//覆写Object的equals方法
if(!(obj instanceof Student))
return false;
Student s = (Student)obj;
return this.name.equals(s.name) && this.age == s.age;
}
public String getName(){//获取学生姓名
return this.name;
}
public int getAge(){//获取学生年龄
return this.age;
}
}

复制代码

再说TreeSet：
TreeSet底层的数据结构是二叉树数据结构不可有重复元素，TreeSet集合取出是有序的，之所以有序是因为TreeSet有两种排序方式。

TreeSet排序的第一种方式：让存入TreeSeet集合的元素自身具备比较性。元素需要实现Comparable接口，覆盖CompareTo方法。
这种方式也称为元素的自然顺序。
ThreeSet的第二种排序方式。
当元素自然不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。定义一个比较器类将比较器对象作为参数传递给TreeSet集合的构造函数。当两种排序方式都存在时，以比较器方式为主。

import java.util.*;
import static java.lang.System.*;
/*
TreeSet有两种排序方式。
1.让存入TreeSeet集合的元素自身具备比较性。元素需要实现Comparable接口，覆盖CompareTo方法。这种方式也称为元素的自然顺序。
2.当元素自然不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。定义一个比较器类将比较器对象作为参数传递给TreeSet集合的构造函数。
实现Comparator 接口，覆盖compare方法
当两种排序方式都存在时，以比较器方式为主。
如何保证元素的唯一性：
compareTo()方法返回 0
*/
class TreeSetTest
{
public static void main(String[] args)
{
/*第一种排序方式：自然排序,让集合自身具备比较性
需求：存储学生对象，按照年龄排序，如果年龄相等按照姓名的顺序排序
*/
TreeSet first = new TreeSet();
first.add(new Student("zhangsan",19));
first.add(new Student("zhangsan",19));
first.add(new Student("lisi",18));
first.add(new Student("wangwu",20));
first.add(new Student("zhaoliu",19));
out.println("第二种排序方式：");
Iterator itFir = first.iterator();
while(itFir.hasNext()){
Student s = (Student)itFir.next();
out.println("name=" + s.getName() + "...age=" + s.getAge());
}
/*第二种排序方式：让集合自身具备比较性*/
TreeSet second = new TreeSet(new MyComp());
second.add(new Student("zhangsan",19));
second.add(new Student("zhangsan",16));
second.add(new Student("lisi",18));
second.add(new Student("wangwu",20));
second.add(new Student("zhaoliu",17));
out.println("第二种排序方式：");
Iterator itSec = second.iterator();
while(itSec.hasNext()){
Student s = (Student)itSec.next();
out.println("name=" + s.getName() + "...age=" + s.getAge());
}
}
}
class Student implements Comparable//学生类,该接口强制是student具有比较性
{
private String name;//姓名
private int age;//年龄
Student(String name, int age){
this.name = name;
this.age = age;
}
public int compareTo(Object obj){//覆写compareTo方法，让元素自身具备比较性
if(!(obj instanceof Student))
throw new RuntimeException("类型不匹配，不是学生对象！");
Student s = (Student)obj;
int num = Integer.valueOf(this.age).compareTo(Integer.valueOf(s.age));
if(num == 0){
num = this.name.compareTo(s.name);
}
return num;
}
public String getName(){//获取学生姓名
return this.name;
}
public int getAge(){//获取学生年龄
return this.age;
}
}
class MyComp implements Comparator//自定义比较器
{
public int compare(Object o1,Object o2){
if(!(o1 instanceof Student || o2 instanceof Student))
throw new RuntimeException("类型不匹配，不是学生对象！");
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if(num == 0){
num = Integer.valueOf(s1.getAge()).compareTo(Integer.valueOf(s2.getAge()));
}
return num;
}
}

复制代码

/*
Arrays用于操作数组的工具类。下面演示Arrays中常用方法。
数组变集合
asList(T...a)
好处：可以使用集合的思想和方法来操作数组中的元素
注意：如果数组中的元素都是对象，那么变成集合时，数组中的元素直接变成集合中的元素
如果数组中的元素都是基本数据类型，那么变成集合时,会将该数组作为集合中的元素
集合变数组
toArray();
toArray(T[] t);
好处：限定了对集合的操作，不可增删
排序
sort(Object[] a)
根据元素的自然顺序对指定对象数组按升序进行排序。
*/
import java.util.*;
import static java.lang.System.*;
import static java.util.Arrays.*;
class ArraysDemo
{
public static void main(String[] args)
{
//数组变结合
String[] arr = {"aaa","bbb","ccc","ddd"};
List<String> list = asList(arr);
out.println(list);
//Integer[] nums = {1,5,9};
int[] nums = {1,5,9};
List<int[]> numsList = asList(nums);
out.println(numsList);
//集合变数组
ArrayList<String> li = new ArrayList<String>();
li.add("java01");
li.add("java05");
li.add("java03");
String[] arrs = li.toArray(new String[li.size()]);
out.println(Arrays.toString(arrs));
//排序
Arrays.sort(arrs);
out.println(Arrays.toString(arrs));
}
}

复制代码