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



-----------------------------------------------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.youkuaiyun.com/heima