黑马程序员_集合知识总结


-----------------------------------------------android培训、java培训、期待与您交流！---------------------------------------------

❶为什么出现集合类

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，对对象进行存储，

集合就是存储对象最常用的一种方式。

❷集合的整体框架图



❸集合的分类

❶List集合

①List集合特点:元素是有序的，元素可以重复

②常见List集合及其特点

ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。(当数组满的时候以50%的大小扩增)

LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。

Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。(当数组满的时候以100%的大小扩增)

③List特有方法:凡是可以操作角标的方法都是该体系特有的方法。

增

add(index,element);

addAll(index,Collection);

删

remove(index);

改

set(index,element);

查

get(index):

subList(from,to);

listIterator();

int indexOf(obj):获取指定元素的位置。

ListIterator listIterator();

④LinkedList特有方法

offerFirst();offerLast();

获取元素，但不删除元素。如果集合中没有元素，会返回null。

peekFirst()和peekLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null。

pollFirst()和pollLast();

⑤ListIterator的特点

ListIterator弥补了Iterator不可以对正在操作的集合进行添加和修改并且有hasPrevious()和CRUD方法

⑥ArrayList里面的contains和remove底层都是调用的equals方法

❷Set集合

①Set集合特点:元素是无序的，元素不可以重复

②HashSet:底层数据结构是哈希表，不是线程安全的，不同步

③hash表的特点

hash表保证元素唯一性的原理：

ⓐ通过元素的两个方法，hashCode和equals来完成。

ⓑ如果元素的HashCode值不相同，不好会判断equals是否为true

ⓒ如果元素的hashcode值相同同，调用equals方法

ⓓ如果HashCode相同equals方法返回的是假那么把该对象顺延放在该地址下面

④TreeSet

ⓐ可以对Set集合中的元素进行排序

ⓑ底层数据结构是二叉树(小的元素放在左边大的元素放在右边)

ⓒ保证元素唯一性的依据：compareTo方法

ⓓTreeSet排序的第一种方式：

让元素自身具备比较性， 元素需要实现Comparable接口，覆盖compareTo方法

这种方式也成为元素的自然顺序，或者叫做默认顺序。

ⓔTreeSet的第二种排序方式：

当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性(写一个集合比较器)

❸两种比较排序方式的实现

其中hashCode和equals方法用来判断两个元素是否相等的方法，两个元素年龄相同的时候按照姓名进行排序

public class Test
{
public static void main(String[] args)
{

TreeSet<Student> students=new TreeSet<Student>();
students.add(new Student("zhangsan", 12));
students.add(new Student("lisi", 22));
TreeSet<Student> students2=new TreeSet<Student>(new MyComparator());
}
}
class Student implements Comparable<Student>
{
private String name;
private int age;
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public Student(String name, int age)
{
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s = (Student)obj;
return this.name.equals(s.name) && this.age==s.age;
}
@Override
public int compareTo(Student o)
{
int num = new Integer(this.age).compareTo(new Integer(o.age));
if(num==0)//如果年龄相同那么就以姓名进行比较
return this.name.compareTo(o.name);
return num;
}
}
class MyComparator implements Comparator<Student>
{
@Override
public int compare(Student o1, Student o2)
{
int num = new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));
if(num==0)//如果年龄相同那么就以姓名进行比较
return o1.getName().compareTo(o2.getName());
return num;
}
}


❹Map集合

①添加

put(K key, V value) ，putAll(Map<? extends K,? extends V> m)

如果在添加时有相同的键那么后添加的值会覆盖原有键对应值,并且put方法会返回被覆盖的值。

System.out.println("put:"+map.put("01","zhangsan1"));

System.out.println("put:"+map.put("01","wnagwu"));

②删除

clear() ，remove(Object key)

③判断

containsValue(Object value) ，containsKey(Object key) ，isEmpty()

④获取

get(Object key) ，size() ，values() ，entrySet() ，keySet()

⑤Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。

⑥HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。

⑦TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序

⑧Map.Entry<k,v>其实就是Map中的一个static内部接口

interface Map

{

 public static interface Entry

 {

  public abstract Object getKey();

  public abstract Object getValue();

 }

}

❺Collections

①为什么要用Collections

有一个集合需要保证唯一，要对其进行排序就不能TreeSet了，所以Collections就是解决这个问题的

②Collections里面重要的方法

ⓐ对这句话的理解：

首先是对List泛型集合的排序，该类必须是Comparable的子类，但是Comparable也是一个泛型的类型

它可以是T或者T的父类 

public static <T extends Comparable<? super T>> void sort(List<T> list)

ⓑ按照自己的比较器进行排序

public static <T> void sort(List<T> list,Comparator<? super T> c)

ⓒ返回集合的最大值

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

ⓓ从自己的比较器 返回集合的最大值

public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp)

ⓔ查找集合中元素的位置查找之前先调用sort方法进行排序

public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)

ⓕ从自己的比较器 查找集合中元素的位置查找之前先调用sort方法进行排序

public static <T> int binarySearch(List<? extends T> list,T key,Comparator<? super T> c)

ⓖ把指定集合中的元素全部替换为指定的值

public static <T> void fill(List<? super T> list,T obj)

ⓗ把集合中的某些值替换为新的值

public static <T> boolean replaceAll(List<T> list,T oldVal,T newVal)

ⓘ把集合中的元素反向排序

public static void reverse(List<?> list)

ⓙ强行逆转实现了Comparable接口的对象的自然数比较顺序，返回一个比较器

public static <T> Comparator<T> reverseOrder()

ⓚ强行逆转指定比较器的顺序，返回一个比较器

public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)

ⓛ随机的改变序列的排序方式

public static void shuffle(List<?> list)

ⓜ传递一个没有加锁的集合返回一个加了锁的集合

public static <T> List<T> synchronizedList(List<T> list)

❻Arrays

①为什么要使用Arrays

集合的思想和方法来操作数组中的元素，但是不可以使用集合的增删方法

②使用Arrays的好处

比方说要看某个数组里面是否含有某个元素List<String> list = Arrays.asList(arrays);

那么就可以用数组里面的这个方法list.contains("cc")来判断某个元素,而不用在使用for循环了

❼集合变数组

①为什么要将集合变数组？

为了限定对元素的操作,不需要进行增删了。

②数组大小创建多大才合适呢

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会新创建了数组。没有使用的地方用null来补充。

所以创建一个刚刚好的数组最优

ArrayList<String> al = new ArrayList<String>();

String[] arr = al.toArray(new String[al.size()]);

-----------------------------------------android培训、java培训、java学习型技术博客、期待与您交流！ --------------------------




详情请查看：http://edu.csdn.net/heima