java集合详解

今天我们主要来学习java中的容器相关的知识。按照从上往下依次学习Collection接口set接口，list接口以及map接口。Collection 接口是一组允许重复的对象。Set 接口继承 Collection，无序不允许重复,使用自己内部的一个排列机制,List 接口继承 Collection,有序允许重复，以元素安插的次序来放置元素，不会重新排列。Map 接口是一组成对的键值对象,即所持有的是 key-value pairs。Map 中不能有重复的 key。拥有自己的内部排列机制。容器中的元素类型都为引用类型, 不能放置原生数据类型(使用装箱即可)，使用泛型保留类型。

一.Collection类

Collection 表示一组对象，它是集中，收集的意思，就是把一些数据收集起来，Collection接口的两个子接口：
Set 中的数据没有顺序，不可重复；
List 中的数据有顺序，可重复。

package com.se.practice;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

/**
 * 集合：Collection
 * 	成员方法：
 * 	容器可以存储任意类型的数据
 * 	泛型中的数据类型只能为引用类型，基本数据类型会发生非自动装箱
 * 
 * 遍历：
 * 		1.增强for
 * 		2.迭代器
 * 
 *
 */
public class CollectionDemo {
	public static void main(String[] args) {
		Collection col=new ArrayList();
		Collection col2=new ArrayList();
		col.add("春天");
		col.add(1234);
		col2.addAll(col);
		System.out.println(col);
		System.out.println(col2);
		
		
		//boolean contains(Object o)如果此collection 包含的指定元素，则返回true。         
		System.out.println(col.contains("春天"));
		
		
		//equals
		System.out.println(col.equals(col2));
		
		
		//boolean isEmpty() 判断此Collection是否包含元素,如果不包含元素，返回true反之false
		
		System.out.println(col.isEmpty());
		
		//boolean remove(Object o)
		System.out.println(col.remove("春天"));
		System.out.println(col);
		
		//int size() 返回Collection中的元素数
		System.out.println(col.size());
		
		
		
		//Object[] toArray()返回包含此Collection 中所有元素的数组。
		col.toArray();
		Object[] a=col.toArray();
		System.out.println(Arrays.toString(a));
		
		
		//增强for
		for(Object o:col){
			System.out.println(o);
		}
		
		
		//迭代器
		//1.获取操作这个容器的迭代器对象
		Iterator it=col.iterator();
		//2.判断下一个是否有数据
		if(it.hasNext()){
			//3.获取写一个数据
			System.out.println(it.next());
		}
	}
}

二.Set接口

Set 接口中的元素无序不可重复:不包含重复元素,最多包含一个 null,元素没有顺序 。

package com.se.practice;

import java.util.HashSet;
import java.util.Set;
public class SetDemo {
	public static void main(String[] args) {
		Set set=new HashSet();
		set.add(false);
		set.add(true);
		set.add(false);
		set.add(null);
		set.add(null);
		System.out.println(set);
		System.out.println(set.contains(null));
		
	}
}

1.HashSet
HashSet 是 Set 接口的一个子类，主要的特点是：里面不能存放重复元素，而且采用散列的存储方法，所以没有顺序。这里所说的没有顺序是指：元素插入的顺序与输出的顺序不一致。 使用重写 equals 和 hashcode 来实现自定义的类型的去重。Java 中规定，两个内容相同的对象应该具有相等的 hashcode。

package com.se.practice;

import java.util.HashSet;
import java.util.Set;

/**
 * 
 * HashSet
 * 底层：哈希表结构(数组+链表+红黑树);
 * 优点：查询，添加，删除，修改效率高
 * 缺点：无序
 * 
 * 如果两个对象的hashcode的值不相同，两个对象肯定不相同，如果值相同，可能不是相同对象，可能是相同对象
 *
 */
public class HashSet1 {
	public static void main(String[] args) {
		Set<String>set=new HashSet();
		set.add("啤酒鸡翅");
		set.add("黄金脆皮鸡");
		set.add("糖醋排骨");
		set.add("红烧肉");
		set.add("蒜蓉小龙虾");
		System.out.println(set);
		
		Set<Person>person=new HashSet();
		person.add(new Person("001","Itachi",12));
		person.add(new Person("001","Itachi",12));
		person.add(new Person("002","kakasi",15));
		System.out.println(person);
	}
}
class Person{
	String id;
	String name;
	int age;
}

三.List接口

List接口，位置有序允许元素重复。多了一些关于 位置( 顺序)的方法。
1.ArrayList
ArrayList 是 List 的子类，它和 HashSet 想法,允许存放重复元素，因此有序。集合中元素被访问的顺序取决于集合的类型。如果对ArrayList 进行访问，迭代器将从索引 0 开始，每迭代一次，索引值加 1。然而，如果访问 HashSet 中的元素,每个元素将会按照某种随机的次序出现。虽然可以确定在迭代过程中能够遍历到集合中的所有元素，但却无法预知元素被访问的次序。

package com.se.practice;

import java.util.ArrayList;

/**
 * ArrayList 有序的可重复的
 * 底层：数组实现，进行动态扩容，每次使用copyOf方法进行扩容，每次扩容后的容量是原来容量的1.5倍
 * 优点：随机获取或者遍历效率高
 * 缺点：增删效率低
 * 线程不安全，效率高
 * 
 * 
 * Vector 向量
 * 底层：数组实现，使用copyOf方法进行动态扩容，每次扩容后的容量是原来容量的2倍
 * 线程安全  ，效率低
 */
public class ArrayList01 {
	public static void main(String[] args) {
		ArrayList<Person> list=new ArrayList();
		list.add(new Person("001","Itachi",18));
		list.add(new Person("002","ShiShui",20));
		list.add(new Person("003","obito",23));
		
		
		System.out.println(list);
		System.out.println(list.indexOf(new Person("003","oboto",23)));
	}
}
class Person{
	private String id;
	private String name;
	private int age;
	public Person() {
		super();
	}
	public Person(String id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	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;
	}
	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}

2.LinkedList

package com.se.practice;

import java.util.LinkedList;

/**
 * LinkedList
 * 底层：双向链表实现
 * 优点：做增删效率高
 * 缺点：查询和遍历效率低
 * 
 *新增功能：新增了一些操作与头部和尾部的方法
 */
public class LinkedList01 {
	public static void main(String[] args) {
		LinkedList list=new LinkedList();
		list.add("haha");
		list.add("hehe");
		list.add("xixi");
		System.out.println(list);
		
		
		/*
		 * void addFirst(E e)
		 * 将指定元素插入此链表的开头。
		 * void addLast(E e)
		 * 将指定元素添加到链表的结尾
		 */
		
		list.addFirst("yinyin");
		list.addFirst("huohuo");
		System.out.println(list.element());
		System.out.println(list);
	}
}