java集合框架（细讲）

集合框架

1，为什么需要集合

变量：只能存储一个任何数据类型的数据

int a = 1;
String str = "";
Person p = new Person();

数组：可以存储相同数据类型的一组数据，长度不可变

int[] arr = {1,"2",3,4}
Object[] obj = new Object[4];
obj[1] = 1;
obj[2] = "2";
obj[3] = new Person();
arr[3] = 3;

如果并不知道程序运行时会需要多少对象，或者需要
更复杂方式存储对象——可以使用Java集合框架

2，集合框架的体系结构

List : 有顺序，有重复，有下标

Set : 无顺序，无重复，无下标

Map : 键值对

2，集合和数组的区别

​ 1）数组长度不可变化而且无法保存具有映射关系的数据；集合类用于保存数量不确定的数据，以及保存具有映射关系的数据。

2）数组元素既可以是基本类型的值，也可以是对象；集合只能保存对象。

3，集合数据的特点

Java集合类主要由两个根接口Collection和Map派生出来的，

​ Collection派生出了三个子接口：List、Set、Queue（Java5新增的队列），因此Java集合大致也可分成List、Set、Queue、Map四种接口体系，（注意：Map不是Collection的子接口）。

​ List代表了有序可重复集合，可直接根据元素的索引来访问；

​ Set代表无序不可重复集合，只能根据元素本身来访问；

​ Queue是队列集合；

​ Map代表的是存储key-value对的集合，可根据元素的key来访问value。

上图中淡绿色背景覆盖的是集合体系中常用的实现类，分别是ArrayList、LinkedList、ArrayQueue、HashSet、TreeSet、HashMap、TreeMap等实现类。

4,List接口

add(E e) ; 添加元素  Element 元素
add(int index, E element); 在index索引处插入元素element对象
addAll(Collection<? extends E> c); 将集合对象c 追加到集合后
addAll(int index, Collection<? extends E> c) ;
clear() ;	清空元素
contains(Object o) ;返回的boolean类型，表示是否包含某个对象
containsAll(Collection<?> c) ;判断是否包含某个集合对象
equals(Object o); 重写Object的equals方法
get(int index) ; 通过下标获取对象的元素对象
indexOf(Object o) ; 返回o对象所在的下标		如果没找到返回-1
lastIndexOf(Object o) ;
isEmpty() ; 判断集合是否为空，是否有元素对象
remove(int index) ; 根据索引删除元素对象
remove(Object o) ; 根据对象删除
set(int index, E element); 替换对应所有的元素对象为element
size() ;返回集合的长度

5,list接口的常用的实现类

1，ArrayList

​ 底层的实现是数组，查询快

2，LinkedList

​ 底层是双向链表，添加，删除快

包含了List接口定义的所有方法，但还是有自己特有的方法
void  addFirst(Object o)	在列表的首部添加元素
void  addLast(Object o)	在列表的末尾添加元素
Object  getFirst()	返回列表中的第一个元素
Object  getLast()	返回列表中的最后一个元素
Object  removeFirst()	删除并返回列表中的第一个元素
Object  removeLast()	删除并返回列表中的最后一个元素

6，泛型集合

List<Integer> list = new ArrayList<Integer>();
list.add(1);

泛型就是限制集合中添加的数据类型

7，集合的遍历

第一种
List<Object> list = new ArrayList<Object>();
list.add("a");
list.add("b");
list.add("c");
list.add(1);
for (int i = 0; i < list.size(); i++) {
	System.out.println(list.get(i));
}
第二种
for(Object s : list){
	System.out.println(s);
}
第三种
Iterator<Object> it = list.iterator();//迭代器
while(it.hasNext()){//判断有没有下一个元素
	Object obj = it.next();//获得下一个元素
	System.out.println(obj);
}

8，list集合的排序

第一种方式 Comparator 接口

package demo01;
import java.util.Comparator;
/*
	比较器
*/
public class MyCompartor implements Comparator<Dog> {
	@Override
	public int compare(Dog o1, Dog o2) {
		return o2.getAge()-o1.getAge();
	}
}

public class Demo01 {
	public static void main(String[] args) {
		List<Dog> list = new ArrayList();
		list.add(new Dog(2,"小黑1"));
		list.add(new Dog(4,"小黑2"));
		list.add(new Dog(3,"小黑3"));
		list.add(new Dog(5,"小黑4"));
		
		//new MyCompartor()没有对象名的叫做匿名对象
        //排序
		Collections.sort(list,new MyCompartor());
		
		for(Dog dog : list){
			System.out.println(dog);
		}
	}
}

第二种方式 Comparable 接口

package demo01;

public class Dog implements Comparable<Dog>{
	private int age;
	private String name;
	public Dog() {
		// TODO Auto-generated constructor stub
	}
	 
	@Override
	public String toString() {
		return "Dog [age=" + age + ", name=" + name + "]";
	}

	public Dog(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	@Override
	public int compareTo(Dog o) {
		return this.age>o.getAge()?-1:1;
	}
	
}

public class Demo01 {
	public static void main(String[] args) {
		List<Dog> list = new ArrayList();
		list.add(new Dog(2,"小黑1"));
		list.add(new Dog(4,"小黑2"));
		list.add(new Dog(3,"小黑3"));
		list.add(new Dog(5,"小黑4"));
		
		//new MyCompartor()没有对象名的叫做匿名对象
		Collections.sort(list);
		
		for(Dog dog : list){
			System.out.println(dog);
		}
	}
}

9,list集合的删除对象

重写equals方法
	@Override
	public boolean equals(Object obj) {
		 Dog dog = (Dog) obj;
		 if(this.name==dog.getName()&&this.age==dog.getAge()){
			 return true;
		 }else{
			 return false;
		 }
	}

public class Demo01 {
	public static void main(String[] args) {
		List<Dog> list = new ArrayList();
		list.add(new Dog(2,"小黑1"));
		list.add(new Dog(4,"小黑2"));
		list.add(new Dog(3,"小黑3"));
		list.add(new Dog(5,"小黑4"));
		list.remove(new Dog(4,"小黑2"));
		System.out.println(list.size());
	}
}

2，set集合

無順序，無下標，無重複

Set接口定义的方法

add(E e) ;
clear() ;
contains(Object o) ;
isEmpty() ;
iterator() ;
remove(Object o) ;
size() ;
toArray() ;

1,遍历方式

Set<String> set = new HashSet<String>();
        set.add("a");
        set.add("b");
        set.add("c");

        for (String str : set) {
            System.out.println(str);
        }

public static void main(String[] args) {
		Set<String> set = new HashSet<String>();
		set.add("a");
		set.add("b");
		set.add("c");
		
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			String str = it.next();
			System.out.println(str);
		}
	}

3,Map集合

键值对 key - value

通过key找value

map接口的方法

key是唯一的，可以为null值，但是只能有一个null的key

如果key值重复，则后面的value值会替换前面的value值

clear() 
containsKey(Object key) ;
containsValue(Object value) 
get(Object key)
isEmpty() 
put(K key, V value) 
size() 

entrySet() 
keySet() 
values() 

1,遍历方法

public static void main(String[] args) {
		Map<Integer,Object> map = new HashMap<Integer,Object>();
		map.put(1, "a");
		map.put(2, "b");
		map.put(3, "c");
		map.put(4, "d");
		
		//遍历键
		Set<Integer> set = map.keySet();//获得键的集合
		 for(Integer i : set){
			 System.out.println(i+"/"+map.get(i));
		 }
	}

//遍历值
		Collection<Object> coll = map.values();
		Iterator<Object> it = coll.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}

//即遍历键又遍历值
		Set<Entry<Integer, Object>> set = map.entrySet();
		for(Entry<Integer, Object> entry : set){
			System.out.println(entry.getKey()+"/"+entry.getValue());
		}
//一步到位
for(Entry<Integer, Object> entry : map.entrySet()){									System.out.println(entry.getKey()+"/"+entry.getValue());
}

while(it.hasNext()){
System.out.println(it.next());
}

```java
//即遍历键又遍历值
		Set<Entry<Integer, Object>> set = map.entrySet();
		for(Entry<Integer, Object> entry : set){
			System.out.println(entry.getKey()+"/"+entry.getValue());
		}
//一步到位
for(Entry<Integer, Object> entry : map.entrySet()){									System.out.println(entry.getKey()+"/"+entry.getValue());
}