javase集合框架

  1. 1.集合中储存的对象的引用,不是对象本身
  2. 结合算法类:Collections:提供用来处理集合的大量静态方法(可以直接用Collections.静态方法()来使用),例如排序,乱序,反转,二分法查找等
    static void Collections.shuffle(list)乱序
    static void Collections.sort(list) 排序
    static void Collections.swap(list,int,int)指定两点调换
    static void Collections.reverse(list)反转
    boolean disjoint(list1,list2)如果两个集合没有相同元素则返回true
    慢慢补充。。。
  3. Arrays类:对数组进行操作的算法类
    Arrays.sort()排序
    Arrays.asList()转换成集合
    慢慢补充
  4. Comparable:这是一个按照自然顺序排序的接口,实现此接口的类就可以比较,使用Colletions.sort()和Arrays.sort()时元素的类型需要实现此接口,唯一的方法是:

对于类 C 的每一个 e1 和 e2 来说,当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2)
具有相同的 boolean 值时,类 C 的自然排序才叫做与 equals 一致。注意,null 不是任何类的实例,即使
e.equals(null) 返回 false,e.compareTo(null) 也将抛出 NullPointerException。

int compareTo(T t);

public class Student implements Comparable<Student>{
	//比较分数,分数相等时再比较姓名;
	@Override
	public int compareTo(Student o) {
		if(this.score==o.score) {
			return this.name.compareTo(o.getName());
		}
		return this.score-o.score;
	}
}

 1. Comparator比较器:可以定义一个比较方法使比较更灵活

>  注释:ClassCastException - 如果参数的类型不允许此 Comparator 对它们进行比较

Collection.sort(List,Comparator);
 2. Comparable 和Comparator的区别:Comparable按照自然顺序比较,Comparator按照自定义顺序比较;每个类只能使用一个Comparable使用方式,而能使用多个Comparator方式;Comparator的优先级较高
 3. List接口代表有序的可重复的集合,集合中每个元素都有其对应的顺序索引,可以通过索引来访问指定位置的元素集合,默认按照元素添加的顺序排序
add(String);
clear();
remove(int)移除相应位置的元素
removeAll()移除所有元素
remove(String)移除第一次出现的该元素
getItem(int);
 4. 泛型(数据类型参数化)
安全检查;直接完成类型转化
 9.ArraysList类型动态数组,实现List接口,可以随时扩容,
 **线程不安全Vector线程安全但是不经常使用**
 boolean add(E)添加指定元素到此列表的尾部
 add(int,E)将指定元素添加到列表的指定位置
 addAll(Collection)按照Collection迭代器制定的
indexof(String)返回首次出现词元素的索引,若不存在返回-1	
toArray()
size()
10. ArrayList源代码

> 重要属性:
elementData:用来存储数据的Object[]数组
size:元素的个数
构造方法
三个构造方法;
():空的数组
(int):固定长度
(Collection):与集合中元素个数相同的数组
重要方法
add():增加一个元素或多个元素,根据新增加的元素判断空间是否够用,如够不,不扩容,不够则采有两种算法扩容,
size+size>>1:即1.5倍
size+新增加元素的长度(如果增加的是多个元素时(Collection))

 11. 链表
链表是数据结构中线性结构中的一种;
	链表中由多个存储在不同位置的节点(元素)组成,每个节点由三部分级成;
		数据
		前驱节点:上一个节点是谁 (引用)
		后继节点:下一个节点是谁(引用)
源代码

> 源代码
	内部类
	private static class Node<E> {
        E item;   //元素
        Node<E> next;   //后一个节点
        Node<E> prev;   //前一个节点

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
	重要属性:
		size:元素个数;
		first:指向头节点
		last:指向尾节点
	构造方法;
		():空链表
		(Collection):将集合中的数据取出存在链表中
	方法:
		add():
创建一个新节点(前驱,后继,元素)
将上一个节点的next指向它;last指向它
		get();
			size/2后,判断从前向后找,还是从后向前找;
	

 12. 栈
栈(Stack):
	特点:先进后出;FILO(first in last out)
	三个方法:
		push(数据):入栈
		pop():出栈(获取栈顶元素,并删除)
		peek():获得栈顶元素的引用,但不删除;

	

> 例题.比如说,入栈的顺序是 a b c ,以下哪个选择不可能是出栈的顺序 	
> A  a,b,c 	B  c,b,a 	C  b,a,c 	D 
> c,a,b

 1. 队列接口Queue
队列;先进先出的集合,FIFO:first in first out;
	操作;
		offer():向队列尾部插入一个元素
		poll();从队列头部获得一个元素,并从队列中删除此元素
		peek():获得队列头部的元素;	
 2. Deque双端队列
实现类:
			ArrayDeque
			LinkedList
 3. set接口
 Set是Collection的子接口
 Set集合不允许添加相同的元素,否则添加不成功,判断两个对象相同使用equals
 4. HashSet是使用Set的常用接口,使用Hash算法储存元素便于查找和插入。
**特点:不能保证元素顺序
		不是线程安全
		集合元素可以使用NULL
**
当向HashSet中存数据时,HashSet会调用HashCode()方法来得到对象的HashCode值然后根据HashCode值来决定对象在HashSet中的储存位置,如果两个元素的equals()返回为TRUE但是HashCode()不等,会把他们储存在不同位置,但是可以添加成功
什么算是重复:Object类判断相等是根据equals(),相等对象必须有相等的哈希码
			HashSet中先判断hashCode,不相等则不判断equals()
			
List<E> list=new ArrayList<E>(set);可以转换为LIst
HashMap Node类型的数组,每个元素都是一个链表,长度是16,哈西冲突通过链表解决但是
equals不相等hashcode可能相等
 5. Iterator:迭代器
	作用:从集合(Collection)中遍历数据
	操作步骤;
获得集合的迭代器   Iterator<String> ite=set.iterator();
从迭代器取出每条数据
	while(ite.hasNext()){
		String s=ite.next();
	}
 6.TreeSet:实现了SortedSet接口,是一个排序的集合,内部通过红黑树实现,实现Comparable接口,或者传递一个Comparator类,根据这两项判断数据是否相同。
 first()
 pollfirst();
 subSet();
 headSet();
 
 6. Map集合框架的另一个顶层接口,Map中元素成对出现,形式是<Key,Vaklue>,Key不重复,每个Key对应一个Value.
clear();
containsKey();
containsValue();
entrySet()返回映射中的Set视图(键值对的集合)

Set<Entry<K,V>> set=map.entrySet();
for(Entry<K,E>e:sets){
System.out.println(e.getKey()+":"+e.getValue());
}


keySet()键的集合

Set keys=map.keySet();
System.out.println(keys);
Itreator ite=set.Iterator();
while(ite,.itenext()){
System.out.prinltn(ite.next());
}
for(String s:keys){
System.out.println(s+":"+map.get(s));
}

values()键值的集合

Collection e=map.values();
for(E s:e){
System.out.println(s);
}


putAll()将指定映射放到该映射中
remove()
get()得到指定键所对应的映射
put(K,V)
 1. hashMap:Map最常用的实现类
源码分析:
Node类,此类实现Map.Entry接口,此类是对key,和value的封装;同时它也是一个单向链表;
	它的属性有;
		hash;哈希值
		key :键
		value:值
		next: 下一个节点的引用;
	属性:
		size:元素个数
		loadfactor:加载因子,默认为0.75;当(元素的个数/数组长度超)过这个值是,将会扩容;
		table:内部用来存储键值(Node)对的数组;
	构造方法:
		():初始长度16,加载因子是0.75
		(int):指定初始长度;  建议2的次方
		(int,double);指定初始长度和加载因子
		(map):有初始值;
		方法;
		put(key,value):
重新计算hash值
判断容量是否扩容,并完成扩容
计算存储位置;     (table.legth-1)&hash  ==   hash%table.legth;
存储新元素
		如果此位置没有元素,直接存到此位置
		如果此位置的key与新key相等,替换
		如果不相等,则遍历单向链表;
		
 2. HashTable(哈希表)
早期版本遗留的Map实现,属于Dictinary类
**线程安全,而HashMap线程不安全**
对于null来说,HashMap支持null(key,value),而Hashtable不支持null
 3. TreeMap:是SortedMap的实现类,具备了排序功能,它TreeMap中的元素(Key)按照Comparable或Comparator进行排序;
TreeMap内部是一个红黑树(平衡二叉树)
 4. TreeMap源码
内部类
		Entry
			K 键
			V value
			parent :父元素
			left: 左子元素
			right:右子元素
属性;
		comparator:比较器
		size:元素的个数
		root:根元素
put方法
找到root元素,判断是否为null,如果为null,将些元素赋给root;
如果root不为空,获得comparator,如果comparator不会 null,使用比较器进行,否则用comparable进行比较
与entry进行比较,如果<0,找left进行比较,如果>0,与rigth进行比较,如果=0,给entry 的value重新赋值
重复步骤3,直到entry为null,将此元素放到此节点中;

没有更多推荐了,返回首页