集合与泛型

集合:

Collection 接口 list与set接口的父接口
Collection 工具类
Collection 接口存储一组不唯一，无序的对象
数组存储的元素是不唯一且有序的
List 接口存储一组不唯一，有序（插入顺序）的对象
Set 接口存储一组唯一，无序的对象
Map接口存储一组键值对象，提供key到value的映射

List接口实现类:

ArrayList

ArrayList实现了长度可变的数组，在内存中分配连续的 空间，遍历元素和随机访问元素的效率比较高
以下为ArrayList常用方法：
boolean add(Object o) :在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o):在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size() :返回列表中的元素个数
Object get(int index): 返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o): 判断列表中是否存在指定元素
Boolean remove(Object o): 从列表中删除元素

**LinkedList

LinkedList采用链表(双向链表)存储方式，插入、删除元素时效率比较高
以下为LinkedList常用方法:
在列表的首部添加元素
void addFirst(Object o)
在列表的末尾添加元素
void addLast(Object o)
返回列表中的第一个元素
Object getFirst()
返回列表中的最后一个元素
Object getLast()
删除并返回列表中的第一个元素
Object removeFirst()
删除并返回列表中的最后一个元素
Object removeLast()**
Vector：线程安全的类型，所有效率均低

Set接口

Set接口存储一组唯一，无序的对象
HashSet是Set接口常用的实现类
Set中存放对象的引用
自动扩容:
默认容量16,在元素达到自身容量4/3时，自动扩容一倍
以下为HashSet常用方法:
Interator:迭代器
hasNext():判断是否存在下一个元素
next():获取下一个元素
ListInterator:
hasPrevious():判断是否存在上一个、
previous():获取上一个元素

Map接口

map接口是一个独立的接口
主要用于存储一组键值对象，提供key到value的映射
一个映射不能包含重复的key，每个key最多只能映射到一个值。（值可以为null）

常用实现类:
HashMap
以下为HashMap常用方法:

public class MapTest {
	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String,String>();
		map.put("1", "中");
		map.put("2", "美");
		map.put("3", "英");
		map.put("4", "法");	
		map.put("5", "德");
		//通过key获取值
		System.out.println(map.get("2"));
//		//通过key删除键值对
		map.remove("3");
//		//map中的键值对个数
		System.out.println(map.size());
//		//判断该Key在集合中是否存在    containsValue:判断该Value在集合中是否存在
		System.out.println(map.containsKey("1"));
		
		//1:仅遍历key
		
		Set<String> keySet=map.keySet();
		for(String key : keySet){
			System.out.println(key);
		}
		
		//2.仅遍历value
		Collection<String> valueSet = map.values();
		
		for(String value : valueSet){
			System.out.println(value);
		}
		
		//3.遍历key及value
		
		Set<Entry<String, String>> en =map.entrySet();
		for(Entry<String, String> entry : en){
			System.out.println(entry.getKey()+entry.getValue());
		}
		
		//4.Iterator迭代器
		Set<Entry<String, String>> entrys =map.entrySet();
		Iterator iterator=entrys.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		
		
	}
}

集合特点：

自动扩容
泛型
API方法
强有力的数据结构：
ArrayList
LinkedList
HashSet

集合与数组的区别:

   **1.数组的长度是固定的，集合的长度是可变的。
     2.数组只能存储同类型的对象，集合可以存储不同类型的对象。
     3.集合只能存储对象不能存储基本类型**

泛型：

泛型主要用于解决类型转换问题
泛型类:

/如果类中存在泛型变量，类必须声明为泛型类
//如果类中存在泛型函数，可以将类声明为泛型类也可以将函数声明为泛型函数
          
public class genericUtils<E>{
    
    E e;
	
    E[] es;
	
    List<E> lists;
    
    public <T>T getSomething(){
    	System.out.println("泛型方法");
    	return null;
    }
    }
}

泛型方法:

public <T>T getSomething(){
        	System.out.println("泛型方法");
        	return null;
        }

泛型变量:

	    E e;
    	
        E[] es;
    	
        List<E> lists;

TreeSet ：自然排序，从低到高

//自然排序: 从低到高
		TreeSet<Integer>   sets = new TreeSet<Integer>();
			sets.add(1);
			sets.add(2);
			sets.add(9);
			sets.add(7);
			sets.add(5);
			sets.add(4);
			sets.add(3);
			sets.add(6);
			sets.add(8);
			for(Integer integer:sets){
				System.out.println(integer);
			}

运行结果如下:

Collections类

Collections和Collection不同，前者是集合的操作类，后者是集合接口

Collections排序
Collections类可以对集合进行排序、查找和替换操作
实现一个类的对象之间比较大小，该类要实现Comparable接口
重写compareTo()方法
Collections排序示例:
创建一个学生类:

//实现Comparator接口重写Comparator接口中的compare方法，实现根据名称排序，如果名称重复根据年龄排序
public class Student implements Comparator<Student> {  
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
	public Student() {
		super();
	}
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "学生名称:" + name + ", 年龄:" + age ;
	}
	@Override
	//重写Comparator接口中的compare方法，比较大小，实现根据名称排序，如果名称重复根据年龄排序
	public int compare(Student o1, Student o2) {
		//如果两个学生名称相同，那么根据年龄进行排序
		if(o1.getName().equals(o2.getName())){
			return o1.getAge()-o2.getAge();
		}else{
			//如果两个学生名称不同，那么根据名称进行排序
			return o1.getName().compareTo(o2.getName());
		}
		
	}
	
}

在main方法中进行测试

public static void main(String[] args) {
			//往asList集合中添加数据
		List<Student> asList = Arrays.asList(new Student("a", 15), 
											new Student("b", 16), 
											new Student("a", 14), 
											new Student("c", 13),
											new Student("b", 18), 
											new Student("d", 20)

										);
		
		//使用Collections的sort方法对asList集合进行排序
		Collections.sort(asList,new Student());
		//使用增强型for循环对asList进行遍历输出
		for(Student stu : asList){
			System.out.println(stu);
		}
	}

运行结果如下: